Rectangle Area

                                            
class Solution {
public:
    int computeArea(int ax1, int ay1, int ax2, int ay2, int bx1, int by1, int bx2, int by2) {
        int area1 = (ax2 - ax1) * (ay2 - ay1);
        int area2 = (bx2 - bx1) * (by2 - by1);
        
        int overlapWidth = min(ax2, bx2) - max(ax1, bx1);
        int overlapHeight = min(ay2, by2) - max(ay1, by1);
        int overlapArea = max(overlapWidth, 0) * max(overlapHeight, 0);
        
        return area1 + area2 - overlapArea;
    }
};

                                            
class Solution {
    public int computeArea(int ax1, int ay1, int ax2, int ay2, int bx1, int by1, int bx2, int by2) {
        int areaA = (ax2 - ax1) * (ay2 - ay1);
        int areaB = (bx2 - bx1) * (by2 - by1);
        
        int overlapWidth = Math.min(ax2, bx2) - Math.max(ax1, bx1);
        int overlapHeight = Math.min(ay2, by2) - Math.max(ay1, by1);
        
        int overlapArea = Math.max(overlapWidth, 0) * Math.max(overlapHeight, 0);
        
        return areaA + areaB - overlapArea;
    }
}

                                            
class Solution(object):
    def computeArea(self, ax1, ay1, ax2, ay2, bx1, by1, bx2, by2):
        area_a = (ax2 - ax1) * (ay2 - ay1)
        area_b = (bx2 - bx1) * (by2 - by1)
        
        overlap_width = min(ax2, bx2) - max(ax1, bx1)
        overlap_height = min(ay2, by2) - max(ay1, by1)
        overlap_area = max(overlap_width, 0) * max(overlap_height, 0)
        
        return area_a + area_b - overlap_area

                                            
int computeArea(int ax1, int ay1, int ax2, int ay2, int bx1, int by1, int bx2, int by2) {
    int area1 = (ax2 - ax1) * (ay2 - ay1);
    int area2 = (bx2 - bx1) * (by2 - by1);
    int overlapWidth = fmin(ax2, bx2) - fmax(ax1, bx1);
    int overlapHeight = fmin(ay2, by2) - fmax(ay1, by1);
    int overlapArea = fmax(overlapWidth, 0) * fmax(overlapHeight, 0);
    return area1 + area2 - overlapArea;
}

                                            
public class Solution {
    public int ComputeArea(int ax1, int ay1, int ax2, int ay2, int bx1, int by1, int bx2, int by2) {
        int areaA = Math.Abs(ax1 - ax2) * Math.Abs(ay1 - ay2);
        int areaB = Math.Abs(bx1 - bx2) * Math.Abs(by1 - by2);
        
        int overlapWidth = Math.Max(0, Math.Min(ax2, bx2) - Math.Max(ax1, bx1));
        int overlapHeight = Math.Max(0, Math.Min(ay2, by2) - Math.Max(ay1, by1));
        int overlapArea = overlapWidth * overlapHeight;
        
        return areaA + areaB - overlapArea;
    }
}

                                            
/**
 * @param {number} ax1
 * @param {number} ay1
 * @param {number} ax2
 * @param {number} ay2
 * @param {number} bx1
 * @param {number} by1
 * @param {number} bx2
 * @param {number} by2
 * @return {number}
 */
const computeArea = (ax1, ay1, ax2, ay2, bx1, by1, bx2, by2) => {
    const area1 = (ax2 - ax1) * (ay2 - ay1);
    const area2 = (bx2 - bx1) * (by2 - by1);
    
    const overlapWidth = Math.min(ax2, bx2) - Math.max(ax1, bx1);
    const overlapHeight = Math.min(ay2, by2) - Math.max(ay1, by1);
    const overlapArea = Math.max(overlapWidth, 0) * Math.max(overlapHeight, 0);
    
    return area1 + area2 - overlapArea;
};

                                            
function computeArea(ax1: number, ay1: number, ax2: number, ay2: number, bx1: number, by1: number, bx2: number, by2: number): number {
    const areaA = (ax2 - ax1) * (ay2 - ay1);
    const areaB = (bx2 - bx1) * (by2 - by1);
    
    const overlapWidth = Math.max(0, Math.min(ax2, bx2) - Math.max(ax1, bx1));
    const overlapHeight = Math.max(0, Math.min(ay2, by2) - Math.max(ay1, by1));
    const overlapArea = overlapWidth * overlapHeight;
    
    return areaA + areaB - overlapArea;
}

                                            
class Solution {
    /**
     * @param Integer $ax1
     * @param Integer $ay1
     * @param Integer $ax2
     * @param Integer $ay2
     * @param Integer $bx1
     * @param Integer $by1
     * @param Integer $bx2
     * @param Integer $by2
     * @return Integer
     */
    function computeArea($ax1, $ay1, $ax2, $ay2, $bx1, $by1, $bx2, $by2) {
        $areaA = abs($ax2 - $ax1) * abs($ay2 - $ay1);
        $areaB = abs($bx2 - $bx1) * abs($by2 - $by1);
        
        $overlapX = max(0, min($ax2, $bx2) - max($ax1, $bx1));
        $overlapY = max(0, min($ay2, $by2) - max($ay1, $by1));
        $overlapArea = $overlapX * $overlapY;
        
        return $areaA + $areaB - $overlapArea;
    }
}

                                            
class Solution {
    func computeArea(_ ax1: Int, _ ay1: Int, _ ax2: Int, _ ay2: Int, _ bx1: Int, _ by1: Int, _ bx2: Int, _ by2: Int) -> Int {
        let totalArea = (ax2 - ax1) * (ay2 - ay1) + (bx2 - bx1) * (by2 - by1)
        let overlapWidth = max(0, min(ax2, bx2) - max(ax1, bx1))
        let overlapHeight = max(0, min(ay2, by2) - max(ay1, by1))
        let overlapArea = overlapWidth * overlapHeight
        return totalArea - overlapArea
    }
}

                                            
class Solution {
    fun computeArea(ax1: Int, ay1: Int, ax2: Int, ay2: Int, bx1: Int, by1: Int, bx2: Int, by2: Int): Int {
        val area1 = (ax2 - ax1) * (ay2 - ay1)
        val area2 = (bx2 - bx1) * (by2 - by1)
        
        val overlapWidth = minOf(ax2, bx2) - maxOf(ax1, bx1)
        val overlapHeight = minOf(ay2, by2) - maxOf(ay1, by1)
        val overlapArea = maxOf(0, overlapWidth) * maxOf(0, overlapHeight)
        
        return area1 + area2 - overlapArea
    }
}

                                            
class Solution {
  int computeArea(int ax1, int ay1, int ax2, int ay2, int bx1, int by1, int bx2, int by2) {
    int areaA = (ax2 - ax1) * (ay2 - ay1);
    int areaB = (bx2 - bx1) * (by2 - by1);
    
    int overlapWidth = min(ax2, bx2) - max(ax1, bx1);
    int overlapHeight = min(ay2, by2) - max(ay1, by1);
    int overlapArea = max(overlapWidth, 0) * max(overlapHeight, 0);
    
    return areaA + areaB - overlapArea;
  }
}

                                            
func computeArea(ax1 int, ay1 int, ax2 int, ay2 int, bx1 int, by1 int, bx2 int, by2 int) int {
    area1 := (ax2 - ax1) * (ay2 - ay1)
    area2 := (bx2 - bx1) * (by2 - by1)

    overlapWidth := min(ax2, bx2) - max(ax1, bx1)
    overlapHeight := min(ay2, by2) - max(ay1, by1)

    overlapArea := 0
    if overlapWidth > 0 && overlapHeight > 0 {
        overlapArea = overlapWidth * overlapHeight
    }

    return area1 + area2 - overlapArea
}

func min(a, b int) int {
    if a < b {
        return a
    }
    return b
}

func max(a, b int) int {
    if a > b {
        return a
    }
    return b
}

                                            
# @param {Integer} ax1
# @param {Integer} ay1
# @param {Integer} ax2
# @param {Integer} ay2
# @param {Integer} bx1
# @param {Integer} by1
# @param {Integer} bx2
# @param {Integer} by2
# @return {Integer}
def compute_area(ax1, ay1, ax2, ay2, bx1, by1, bx2, by2)
    area_a = (ax2 - ax1) * (ay2 - ay1)
    area_b = (bx2 - bx1) * (by2 - by1)
  
    x_overlap = [0, [ax2, bx2].min - [ax1, bx1].max].max
    y_overlap = [0, [ay2, by2].min - [ay1, by1].max].max
    overlap = x_overlap * y_overlap
  
    total_area = area_a + area_b - overlap
  
    total_area
end

                                            
object Solution {
    def computeArea(ax1: Int, ay1: Int, ax2: Int, ay2: Int, bx1: Int, by1: Int, bx2: Int, by2: Int): Int = {
        val areaA = (ax2 - ax1) * (ay2 - ay1)
        val areaB = (bx2 - bx1) * (by2 - by1)
        
        val overlapWidth = math.max(0, math.min(ax2, bx2) - math.max(ax1, bx1))
        val overlapHeight = math.max(0, math.min(ay2, by2) - math.max(ay1, by1))
        
        val overlapArea = overlapWidth * overlapHeight
        
        areaA + areaB - overlapArea
    }
}

                                            
impl Solution {
    pub fn compute_area(ax1: i32, ay1: i32, ax2: i32, ay2: i32, bx1: i32, by1: i32, bx2: i32, by2: i32) -> i32 {
        let overlap_width = (ax2.min(bx2) - ax1.max(bx1)).max(0);
        let overlap_height = (ay2.min(by2) - ay1.max(by1)).max(0);
        let area1 = (ax2 - ax1) * (ay2 - ay1);
        let area2 = (bx2 - bx1) * (by2 - by1);
        let overlap_area = overlap_width * overlap_height;
        area1 + area2 - overlap_area
    }
}

                                            
-spec compute_area(Ax1 :: integer(), Ay1 :: integer(), Ax2 :: integer(), Ay2 :: integer(), Bx1 :: integer(), By1 :: integer(), Bx2 :: integer(), By2 :: integer()) -> integer().
compute_area(Ax1, Ay1, Ax2, Ay2, Bx1, By1, Bx2, By2) ->
    Rect1Area = abs(Ax2 - Ax1) * abs(Ay2 - Ay1),
    Rect2Area = abs(Bx2 - Bx1) * abs(By2 - By1),
    OverlapX = max(0, min(Ax2, Bx2) - max(Ax1, Bx1)),
    OverlapY = max(0, min(Ay2, By2) - max(Ay1, By1)),
    OverlapArea = OverlapX * OverlapY,
    TotalArea = Rect1Area + Rect2Area - OverlapArea.

                                            
defmodule Solution do
  @spec compute_area(ax1 :: integer, ay1 :: integer, ax2 :: integer, ay2 :: integer, bx1 :: integer, by1 :: integer, bx2 :: integer, by2 :: integer) :: integer
  def compute_area(ax1, ay1, ax2, ay2, bx1, by1, bx2, by2) do
    total_area = (ax2 - ax1) * (ay2 - ay1) + (bx2 - bx1) * (by2 - by1)
    overlap_area =
      if ax2 <= bx1 or bx2 <= ax1 or ay2 <= by1 or by2 <= ay1 do
        0
      else
        overlap_width = min(ax2, bx2) - max(ax1, bx1)
        overlap_height = min(ay2, by2) - max(ay1, by1)
        overlap_width * overlap_height
      end
    total_area - overlap_area
  end
end

To solve this coding challenge, we need to determine the total area covered by two rectangles in a 2D plane. The complexity arises when the rectangles might overlap, meaning we have to account for the overlapping area to prevent double-counting.

Explanation

Given two rectangles, we can define them using their bottom-left and top-right corners. For clarity, the rectangles are defined as:

Rectangle 1: (ax1, ay1) to (ax2, ay2)
Rectangle 2: (bx1, by1) to (bx2, by2)

To calculate the total area covered by both rectangles, we can follow these steps:

Detailed Steps

Calculate the Area of Each Rectangle Individually :

The area of Rectangle 1 can be calculated as the width (difference between x-coordinates) multiplied by the height (difference between y-coordinates).
Similarly, calculate the area of Rectangle 2.

Determine the Overlapping Region :

For overlap in the X-axis (width), find the maximum of the left-most edges and the minimum of the right-most edges.
For overlap in the Y-axis (height), find the maximum of the bottom-most edges and the minimum of the top-most edges.
If these calculations yield a valid overlap (both width and height are positive), compute the overlapping area.

Calculate the Combined Area :

Sum the areas of the two rectangles.
Subtract the overlapping area to avoid double-counting the intersecting region.

Step-by-Step Explanation in Pseudocode

Define the initial coordinates: ax1, ay1, ax2, ay2 for Rectangle 1 and bx1, by1, bx2, by2 for Rectangle 2.
Calculate Each Rectangle's Area:

                                            
# Calculate the width and height of Rectangle 1
width_rect1 = ax2 - ax1
height_rect1 = ay2 - ay1
# Area of Rectangle 1
area_rect1 = width_rect1 * height_rect1

# Calculate the width and height of Rectangle 2
width_rect2 = bx2 - bx1
height_rect2 = by2 - by1
# Area of Rectangle 2
area_rect2 = width_rect2 * height_rect2

Determine the Overlapping Dimensions:

                                            
# Calculate the horizontal overlap
overlap_width = min(ax2, bx2) - max(ax1, bx1)
# Calculate the vertical overlap
overlap_height = min(ay2, by2) - max(ay1, by1)

Calculate Overlapping Area If Valid:

                                            
# Valid overlap exists if both dimensions are positive
if overlap_width > 0 and overlap_height > 0:
overlap_area = overlap_width * overlap_height
else:
overlap_area = 0

Calculate the Total Area:

                                            
# Calculate the combined area by adding areas of both rectangles and subtract the overlapping area
total_area = area_rect1 + area_rect2 - overlap_area

Return the Result :

                                            
# Return the total area
return total_area

By breaking down the problem into these systematic steps, we ensure that each aspect of the challenge is addressed thoroughly. This structured approach is crucial in understanding the overlap of rectangular areas and accurately determining the combined space they cover.