1028EasyMathGeometry

Do the Two Plots Share Any Ground

Tracked in this browser only

Trains the technique from

This is an original problem, written from a brief that listed the technique, the difficulty, the topics, the function shape and the input bounds — none of that problem's wording, examples, hints or editorials. The link is there so you can map your practice onto the standard set.

Same function shape, different story and different numbers.

A plot is given as [x1, y1, x2, y2]: the coordinates of its bottom-left corner followed by those of its top-right corner, with its sides parallel to the axes. Both plots enclose a positive area.

Two plots share ground when the region they have in common encloses a positive area. Merely touching along an edge or at a corner does not count.

Return whether plot1 and plot2 share ground.

Examples

Example 1

Input: plot1 = [0, 0, 5, 5], plot2 = [1, 1, 2, 2]
Output: true

The second plot sits wholly inside the first, so the region they share is the whole of the second plot.

Example 2

Input: plot1 = [0, 0, 1, 1], plot2 = [0, 1, 1, 2]
Output: false

The two plots meet along a horizontal edge but neither reaches into the other, so the region they share is a line with no area.

Example 3

Input: plot1 = [0, 0, 3, 1], plot2 = [1, 2, 2, 5]
Output: false

Their horizontal spans do overlap, but the first plot stops at height one and the second starts at height two, so there is no vertical overlap at all.

Constraints

plot1.length == 4
plot2.length == 4
-10^9 <= plot1[i] <= 10^9
-10^9 <= plot2[i] <= 10^9
Each plot encloses a positive area.

The signature

The editor is preloaded with this. It matches the parent problem's shape, so a solution that works here transfers to a judge unchanged.

Python

def is_rectangle_overlap(plot1: list[int], plot2: list[int]) -> bool:

Java

public boolean isRectangleOverlap(int[] plot1, int[] plot2)

The intended approach

Time O(1).Space O(1).

Since the sides run along the axes, the plots come apart into a horizontal span and a vertical span each, and the region they share is just the overlap of the horizontal spans crossed with the overlap of the vertical ones. So the shared region has a positive area exactly when both overlaps have a positive length. Two spans on a line overlap with room to spare when each one starts strictly before the other ends. If either fails, the spans are apart or merely touching, and the overlap has no length. Check that for the horizontal spans and again for the vertical ones, and both must hold. Four comparisons and no arithmetic, which also means nothing can overflow however large the coordinates are.

Pythonentry point: is_rectangle_overlap

def is_rectangle_overlap(plot1, plot2):
    if plot1[0] >= plot2[2] or plot2[0] >= plot1[2]:
        return False
    if plot1[1] >= plot2[3] or plot2[1] >= plot1[3]:
        return False
    return True

The obvious version

Work the shared region out as a plot of its own: its left edge is the rightmost of the two left edges, its right edge the leftmost of the two right edges, and likewise up and down. Then measure its width and height and report whether the area they give is above nothing. Builds the region and measures it rather than comparing spans.

This is not filler. It was written independently of the fast solution and the two were run against thousands of random inputs to confirm they agree — which is how the answer above is known to be right. Read it when the intended approach feels like a rabbit pulled out of a hat.

Python

def bf_is_rectangle_overlap(plot1, plot2):
    left = plot1[0] if plot1[0] > plot2[0] else plot2[0]
    right = plot1[2] if plot1[2] < plot2[2] else plot2[2]
    low = plot1[1] if plot1[1] > plot2[1] else plot2[1]
    high = plot1[3] if plot1[3] < plot2[3] else plot2[3]
    width = right - left
    height = high - low
    if width <= 0 or height <= 0:
        return False
    return width * height > 0

How this problem was checked

Reference solution executed against 15 test cases — 15 passed
3 worked examples confirmed by running the code
0 eight-word sequences shared with the parent problem's text
Agrees with an independent brute-force implementation on random inputs
Test set proven to catch deliberately broken solutions
Reviewed by a separate quality pass
Function arity matches the parent problem's

Create a free account to unlock the solution

See the step-by-step animation, the intuition, and clean code in every language — free, no credit card.

Create a free account Already have an account? Sign in