223. Rectangle Area

leetcode medium

#csharp#leetcode#math#medium#two-pointers

Task

Даны координаты двух прямоугольных прямоугольников на двумерной плоскости, верните общую площадь, покрытую этими двумя прямоугольниками.

Первый прямоугольник определяется его нижним левым углом (ax1, ay1) и верхним правым углом (ax2, ay2).

Второй прямоугольник определяется его нижним левым углом (bx1, by1) и верхним правым углом (bx2, by2).

Пример:

Input: ax1 = -3, ay1 = 0, ax2 = 3, ay2 = 4, bx1 = 0, by1 = -1, bx2 = 9, by2 = 2

Output: 45

C# solution

matched/original

public class Solution {
    public int ComputeArea(int ax1, int ay1, int ax2, int ay2, int bx1, int by1, int bx2, int by2) {
        int areaOfA = (ay2 - ay1) * (ax2 - ax1);
        int areaOfB = (by2 - by1) * (bx2 - bx1);
        int left = Math.Max(ax1, bx1);
        int right = Math.Min(ax2, bx2);
        int xOverlap = right - left;
        int top = Math.Min(ay2, by2);
        int bottom = Math.Max(ay1, by1);
        int yOverlap = top - bottom;
        int areaOfOverlap = 0;
        if (xOverlap > 0 && yOverlap > 0) {
            areaOfOverlap = xOverlap * yOverlap;
        }
        int totalArea = areaOfA + areaOfB - areaOfOverlap;
        return totalArea;
    }
}

C++ solution

auto-draft, review before submit

#include <bits/stdc++.h>
using namespace std;

// Auto-generated C++ draft from the C# solution. Review containers, LINQ and helper types before submit.
class Solution {
public:
    public int ComputeArea(int ax1, int ay1, int ax2, int ay2, int bx1, int by1, int bx2, int by2) {
        int areaOfA = (ay2 - ay1) * (ax2 - ax1);
        int areaOfB = (by2 - by1) * (bx2 - bx1);
        int left = max(ax1, bx1);
        int right = min(ax2, bx2);
        int xOverlap = right - left;
        int top = min(ay2, by2);
        int bottom = max(ay1, by1);
        int yOverlap = top - bottom;
        int areaOfOverlap = 0;
        if (xOverlap > 0 && yOverlap > 0) {
            areaOfOverlap = xOverlap * yOverlap;
        }
        int totalArea = areaOfA + areaOfB - areaOfOverlap;
        return totalArea;
    }
}

Java solution

matched/original

class Solution {
    public int computeArea(int ax1, int ay1, int ax2, int ay2, int bx1, int by1, int bx2, int by2) {
        int areaOfA = (ay2 - ay1) * (ax2 - ax1);
        int areaOfB = (by2 - by1) * (bx2 - bx1);

        int left = Math.max(ax1, bx1);
        int right = Math.min(ax2, bx2);
        int xOverlap = right - left;

        int top = Math.min(ay2, by2);
        int bottom = Math.max(ay1, by1);
        int yOverlap = top - bottom;

        int areaOfOverlap = 0;
        if (xOverlap > 0 && yOverlap > 0) {
            areaOfOverlap = xOverlap * yOverlap;
        }

        int totalArea = areaOfA + areaOfB - areaOfOverlap;

        return totalArea;
    }
}

JavaScript solution

matched/original

function computeArea(ax1, ay1, ax2, ay2, bx1, by1, bx2, by2) {
    const areaOfA = (ay2 - ay1) * (ax2 - ax1);
    const areaOfB = (by2 - by1) * (bx2 - bx1);

    const left = Math.max(ax1, bx1);
    const right = Math.min(ax2, bx2);
    const xOverlap = right - left;

    const top = Math.min(ay2, by2);
    const bottom = Math.max(ay1, by1);
    const yOverlap = top - bottom;

    let areaOfOverlap = 0;
    if (xOverlap > 0 && yOverlap > 0) {
        areaOfOverlap = xOverlap * yOverlap;
    }

    const totalArea = areaOfA + areaOfB - areaOfOverlap;

    return totalArea;
};

Python solution

matched/original

class Solution:
    def computeArea(self,
                    ax1: int, ay1: int,
                    ax2: int, ay2: int,
                    bx1: int, by1: int,
                    bx2: int, by2: int) -> int:
        area_of_a = (ay2 - ay1) * (ax2 - ax1)
        area_of_b = (by2 - by1) * (bx2 - bx1)

        left = max(ax1, bx1)
        right = min(ax2, bx2)
        x_overlap = right - left

        top = min(ay2, by2)
        bottom = max(ay1, by1)
        y_overlap = top - bottom

        area_of_overlap = 0
        if x_overlap > 0 and y_overlap > 0:
            area_of_overlap = x_overlap * y_overlap

        total_area = area_of_a + area_of_b - area_of_overlap

        return total_area

Go solution

matched/original

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

    left := max(ax1, bx1)
    right := min(ax2, bx2)
    xOverlap := right - left

    top := min(ay2, by2)
    bottom := max(ay1, by1)
    yOverlap := top - bottom

    areaOfOverlap := 0
    if xOverlap > 0 && yOverlap > 0 {
        areaOfOverlap = xOverlap * yOverlap
    }

    totalArea := areaOfA + areaOfB - areaOfOverlap
    return totalArea
}

func max(x, y int) int {
    if x > y {
        return x
    }
    return y
}

func min(x, y int) int {
    if x < y {
        return x
    }
    return y
}

Explanation

Algorithm

Вычислить площади двух прямоугольников:

Рассчитайте площади прямоугольников A и B, умножив их ширину на высоту.

Вычислить перекрытие:

Найдите перекрытие по оси X и оси Y. Если перекрытие существует, вычислите площадь перекрытия.

Вычислить и вернуть общую площадь:

Вычтите площадь перекрытия из суммы площадей двух прямоугольников и верните результат.

😎