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

    return total_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
    return totalArea - overlap;
};

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; 

} 

}