Overlapping rectangles - multidimensional arrays

Question

Task: You are given two rectangles.For each rectangle you are given its bottom-left and top-right points. Check if they overlap. If they do, check for bottom-left and top-right points of the overlapping area.

I decided to solve this by using multidimensional arrays. Using object might make it more transaprent tho. Is there anything, that I could change (especially in terms of task approach, code bugs, code style and performance ) ?

I came up with following code: Method wich checks if the give rectangles overlap

    public static bool Overlapping(int[][] firstRectangle, int[][] secondRectangle)
    {
        bool XOverlapping = secondRectangle[0][0] <= firstRectangle[1][0] && 
        firstRectangle[0][0] <= secondRectangle[1][0];
        bool YOverlapping = secondRectangle[0][1] <= firstRectangle[1][1] && 
        firstRectangle[0][1] <= secondRectangle[1][1];
        if (XOverlapping && YOverlapping) 
        {
            return true;
        }
        else
        {
            return false;
        }
    }

Method which checks for bottom-left and top-right points of the overlapping area.

 public static void GetOverlappingArea(int[][] firstRectangle, int[][] secondRectangle)
    {
        if (Overlapping(firstRectangle, secondRectangle))
        {
            int startXOverlapping = Math.Max(firstRectangle[0][0], secondRectangle[0][0]);
            int endXOverlapping = Math.Min(firstRectangle[1][0], secondRectangle[1][0]);
            int startYOverlapping = Math.Max(firstRectangle[0][1], secondRectangle[0][1]);
            int endYOverlapping = Math.Min(firstRectangle[1][1], secondRectangle[1][1]);
            Console.WriteLine("Left down corner: (" + startXOverlapping + " , " + startYOverlapping + "), Upper right corner: (" + endXOverlapping + " , " + endYOverlapping + ")");
        }
        else
        {
            Console.WriteLine("Rectangles do not overlap");
        }
    }

My test method

        static void Main(string[] args)
    { 
        int[][] FirstRectangle = new[] { new[] { 2, 4 }, new[] { 8, 7 } };
        int[][] SecondRectangle = new[] { new[] { 5, 7 }, new[] { 10, 15 } };
        GetOverlappingArea(FirstRectangle, SecondRectangle);
    }

Answer 1

Class selection

First, I believe a multidimensional array is not good enough for describing rectangles. For instance, it's easy to forget what dimension responsible for what direction:

int[][] FirstRectangle = new[] { new[] { 2, 4 }, new[] { 8, 7 } };

What exactly is 2, 4, 8 and 7?
You have to remember. It's a bad design.

Instead you could use the built-in Rectangle struct or reinvent the wheel - write your own type.
In the latter case, it makes sense to move processing methods into your type.

---

Naming

I personally think that a method name should describe what the method do and what it returns.

So my suggestion is to rename methods Overlapping → IsOverlapping and GetOverlappingArea → PrintOverlappingArea.
Alternatively you could keep the name GetOverlappingArea (or Overlap, OverlapWith) and modify its code to create and return a new Rectangle instance which contains data of overlapping area. This method could be useful in the future.

Local variables should be named using camelCase: xOverlapping, yOverlapping.

---

Other notes

Instead of

if (XOverlapping && YOverlapping) 
{
    return true;
}
else
{
    return false;
}

You could just

return XOverlapping && YOverlapping;

---

Summarizing

public class Rectangle
{
    public readonly int Left;
    public readonly int Right;
    public readonly int Top;
    public readonly int Bottom;

    public Rectangle(int left, int right, int top, int bottom)
    {
        Left = left;
        Right = right;
        Top = top;
        Bottom = bottom;
    }

    public bool IsOverlapping(Rectangle other)
    {
        bool xOverlapping = other.Left <= Right && Left <= other.Right;
        bool yOverlapping = other.Top <= Bottom && Top <= other.Bottom;
        return xOverlapping && yOverlapping;
    }

    public Rectangle OverlapWith(Rectangle other)
    {
        if (!IsOverlapping(other))
        {
            return null;
        }

        int left = Math.Max(Left, other.Left);
        int right = Math.Min(Right, other.Right);
        int top = Math.Max(Top, other.Top);
        int bottom = Math.Min(Bottom, other.Bottom);

        return new Rectangle(left, right, top, bottom);
    }

    public override string ToString()
    {
        return $"Left={Left}, Right={Right}, Top={Top}, Bottom={Bottom}";
    }
}

---

TODO

What else should be done?

• It always make sense to validate all input arguments in all public methods and constructors.
• If you plan to compare rectangles with each other, it makes sense to implement IEquatable<Rectangle> interface and override the GetHashCode() method and optionally define == and != operators.