Rectangle Area

class Solution {
    public int sumRectangleAreas(int x1, int y1, int x2, int y2, int x3, int y3, int x4, int y4) {
        int rect1Area = (y2 - y1) * (x2 - x1);
        int rect2Area = (y4 - y3) * (x4 - x3);
    
        int overlapLeft = Math.max(x1, x3);
        int overlapRight = Math.min(x2, x4);
        int widthOverlap = overlapRight - overlapLeft;
    
        int overlapTop = Math.min(y2, y4);
        int overlapBottom = Math.max(y1, y3);
        int heightOverlap = overlapTop - overlapBottom;
    
        int overlapArea = 0;
        if (widthOverlap > 0 && heightOverlap > 0) {
            overlapArea = widthOverlap * heightOverlap;
        }
    
        int combinedArea = rect1Area + rect2Area - overlapArea;
    
        return combinedArea;
    }
}

Calculate the combined area of two rectangles given their coordinates in a Java solution by performing the following tasks:

1. Compute the area of the first rectangle using the difference of coordinates x1 and x2 for width, and y1 and y2 for height. Repeat this process for the second rectangle using x3, x4, y3, and y4.

2. Determine any overlapped region by:

   • Finding the farthest left and right horizontal bounds where the rectangles intersect. This is achieved by using the maximum left boundary (Math.max(x1, x3)) and the minimum right boundary (Math.min(x2, x4)).
   • Calculate the width of the overlapping region if the right boundary is greater than the left.
   • Similar calculations are made for the vertical bounds to get the top and bottom edges of the intersection (Math.min(y2, y4) for the top and Math.max(y1, y3) for the bottom).
   • If there is overlap (both widths and heights provide positive values), compute the overlapping area.

3. Add the two areas of the rectangles and subtract any overlapping area (if it exists) to get the total combined area.

Return the calculated combined area from the function. This process accounts for all cases, ensuring that any overlap in areas reduces the overall combined area accurately, thus giving the correct measurement of the combined spatial occupancy of both rectangles.

function calculateTotalArea(leftX1, topY1, rightX1, bottomY1, leftX2, topY2, rightX2, bottomY2) {
    const rect1Area = (rightX1 - leftX1) * (bottomY1 - topY1);
    const rect2Area = (rightX2 - leftX2) * (bottomY2 - topY2);
    
    const intersectLeft = Math.max(leftX1, leftX2);
    const intersectRight = Math.min(rightX1, rightX2);
    const widthIntersect = intersectRight - intersectLeft;
    
    const intersectTop = Math.min(bottomY1, bottomY2);
    const intersectBottom = Math.max(topY1, topY2);
    const heightIntersect = intersectTop - intersectBottom;
    
    let overlapArea = 0;
    if (widthIntersect > 0 && heightIntersect > 0) {
        overlapArea = widthIntersect * heightIntersect;
    }
    
    const combinedArea = rect1Area + rect2Area - overlapArea;
    return combinedArea;
};

Calculate the total area of two potentially overlapping rectangles with the provided JavaScript function calculateTotalArea. The function accepts eight parameters defining the coordinates of two rectangles on a Cartesian plane. These parameters include the left, top, right, and bottom edges for each rectangle.

• Use the x and y coordinates from both rectangles to calculate the area of individual rectangles by subtracting the left coordinate from the right and the top from the bottom, then multiplying these differences.
• Determine possible intersections between the two rectangles. Check if there is any overlap by calculating the intersecting rectangle's width and height. Use the maximum value for left coordinates and the minimum for right coordinates to find the width. For height, use the minimum of the bottom and the maximum of the top coordinates.
• If the width and height of the intersection are greater than zero, an overlap exists, and the area of this intersection is added to calculate the overlapping area correctly.
• Subtract the overlapping area (if any) from the sum of the individual areas of both rectangles to obtain the combined area without double-counting the overlapped section.

The function returns the combined area, ensuring accurate calculation even in cases where the rectangles overlap. This solution is versatile for use in graphical applications, game development, or any system where spatial relationships need to be calculated.

class Rectangle:
    def calculateArea(self,
                      x1: int, y1: int,
                      x2: int, y2: int,
                      X1: int, Y1: int,
                      X2: int, Y2: int) -> int:
        first_rect_area = (x2 - x1) * (y2 - y1)
        second_rect_area = (X2 - X1) * (Y2 - Y1)
    
        left_edge = max(x1, X1)
        right_edge = min(x2, X2)
        horizontal_overlap = right_edge - left_edge
    
        upper_edge = min(y2, Y2)
        lower_edge = max(y1, Y1)
        vertical_overlap = upper_edge - lower_edge
    
        overlap_area = 0
        if horizontal_overlap > 0 and vertical_overlap > 0:
            overlap_area = horizontal_overlap * vertical_overlap
    
        combined_area = first_rect_area + second_rect_area - overlap_area
    
        return combined_area

The Python code provided defines a class Rectangle with a method to calculate the area of the union of two axis-aligned rectangles given their coordinates. Here's a concise breakdown of the method:

• It starts by computing the area of each rectangle separately using the formula width * height.
• It then determines if there is an overlap between the two rectangles. Overlapping is checked by finding the maximum left edge and the minimum right edge for horizontal overlap, and the maximum lower edge and the minimum upper edge for vertical overlap.
• If there is an overlap (both horizontal and vertical overlaps are positive), the area of the overlap is calculated.
• The method returns the combined area of both rectangles minus the area of the overlap, ensuring that any shared space between the rectangles is not counted twice.

This way, the code efficiently determines the total area covered by both rectangles, accounting for any overlapping regions.