# Solution For Rectangle Area

The Rectangle Area problem on LeetCode is a mathematical problem that involves finding the area of two overlapping rectangles.

The problem statement reads as follows:

“Find the total area covered by two rectilinear rectangles in a 2D plane. Each rectangle is defined by its bottom left corner and top right corner coordinates.”

The input is given in the form of four integers: the coordinates of the bottom left corner and top right corner of the two rectangles. The output is the total area covered by the two rectangles.

Example:

Input:

rectangle1 = [-3, 0, 3, 4]

rectangle2 = [0, -1, 9, 2]

Output:

45

To solve this problem, the first step is to calculate the area of each rectangle separately. This can be done by finding the difference between the x-coordinates and y-coordinates of the bottom left and top right corners of each rectangle.

Next, we need to check if the two rectangles overlap. To do this, we need to compare the x-coordinates and y-coordinates of the rectangles and see if they intersect.

If the rectangles intersect, we need to find the area of the intersection. This can be done by finding the x-coordinate and y-coordinate of the bottom left corner and top right corner of the intersection rectangle.

Now, we can calculate the total area covered by the two rectangles by subtracting the area of the intersection rectangle from the sum of the areas of the two rectangles.

Here is the Python code to solve the Rectangle Area problem on LeetCode:

“`
class Solution:
def computeArea(self, A: int, B: int, C: int, D: int, E: int, F: int, G: int, H: int) -> int:
# Calculate the area of each rectangle
area1 = (C – A) * (D – B)
area2 = (G – E) * (H – F)

``````    # Check if the two rectangles intersect
x_overlap = max(0, min(C, G) - max(A, E))
y_overlap = max(0, min(D, H) - max(B, F))
overlap_area = x_overlap * y_overlap

# Calculate the total area covered by the two rectangles
total_area = area1 + area2 - overlap_area

``````

“`

In the above code, we define a class called Solution and a method called computeArea. The method takes in the coordinates of the two rectangles as input and returns the total area covered by the two rectangles.

First, we calculate the area of each rectangle separately. Next, we calculate the overlap area by finding the x-coordinate and y-coordinate of the intersection rectangle. We use the max and min functions to find the x-coordinate and y-coordinate of the bottom left and top right corners of the intersection rectangle.

Finally, we calculate the total area covered by the two rectangles by subtracting the overlap area from the sum of the areas of the two rectangles. We return the total area as output.

## Step by Step Implementation For Rectangle Area

```/*

Calculate the area of a rectangle, given its width and height.

*/

public int rectangleArea(int width, int height) {

// calculate the area of the rectangle

return width * height;

}```
```class Solution:
def computeArea(self, A: int, B: int, C: int, D: int, E: int, F: int, G: int, H: int) -> int:

#calculate the area of the first rectangle
area1 = (C-A) * (D-B)

#calculate the area of the second rectangle
area2 = (G-E) * (H-F)

#calculate the overlap between the two rectangles
overlap = self.overlap(A, B, C, D, E, F, G, H)

#calculate and return the total area
return area1 + area2 - overlap

def overlap(self, A: int, B: int, C: int, D: int, E: int, F: int, G: int, H: int) -> int:

#calculate the width and height of the overlap
width = self.overlapDimension(A, C, E, G)
height = self.overlapDimension(B, D, F, H)

#calculate and return the area of the overlap
return width * height

def overlapDimension(self, a: int, c: int, e: int, g: int) -> int:

#if the rectangles do not overlap in this dimension, return 0
if a >= g or c <= e:
return 0

#otherwise, calculate and return the dimension of the overlap
else:
return min(c, g) - max(a, e)```
```/**
* @param {number} A
* @param {number} B
* @param {number} C
* @param {number} D
* @param {number} E
* @param {number} F
* @param {number} G
* @param {number} H
* @return {number}
*/
var computeArea = function(A, B, C, D, E, F, G, H) {
//find the total area of both rectangles
var totalArea = (C-A)*(D-B) + (G-E)*(H-F);

//find the overlapping area
var xOverlap = Math.max(0, Math.min(C,G) - Math.max(A,E));
var yOverlap = Math.max(0, Math.min(D,H) - Math.max(B,F));
var overlap = xOverlap * yOverlap;

//subtract the overlapping area from the total area to get the final answer
};```
```class Solution {
public:
int computeArea(int A, int B, int C, int D, int E, int F, int G, int H) {
//calculate the area of first rectangle
int area1 = (C-A) * (D-B);
//calculate the area of second rectangle
int area2 = (G-E) * (H-F);

//calculate the length of overlapping area
int length = 0;
if(E>=A && E<=C){
length = min(C,G) - E;
}
else if(A>=E && A<=G){
length = min(C,G) - A;
}

//calculate the width of overlapping area
int width = 0;
if(F>=B && F<=D){
width = min(D,H) - F;
}
else if(B>=F && B<=H){
width = min(D,H) - B;
}

//calculate the area of overlapping rectangle
int area = length * width;

//calculate the total area
return area1 + area2 - area;

}
};```
```using System;

public class Solution {

public int ComputeArea(int A, int B, int C, int D, int E, int F, int G, int H) {

//Compute the area of rectangle 1

int rect1 = (C-A) * (D-B);

//Compute the area of rectangle 2

int rect2 = (G-E) * (H-F);

//Compute the area of the intersection

int intersect = Math.Min(C,G) - Math.Max(A,E) * Math.Min(D,H) - Math.Max(B,F);

//Return the sum of the areas of the two rectangles, minus the area of the intersection

return rect1 + rect2 - intersect;

}

}```

Scroll to Top

## Top 100 Leetcode Practice Problems In Java

Get 30% Off Instantly!
[gravityforms id="5" description="false" titla="false" ajax="true"]