Codestin Search App

Convex Polygon - Problem

Convex Polygon Detection

Given an array of points on the X-Y plane points where points[i] = [xi, yi], determine if these points form a convex polygon when connected in the given order.

A polygon is convex if all interior angles are less than 180 degrees (π radians). Equivalently, when traversing the boundary, you should always turn in the same direction (either always left or always right).

Key Properties:
• The polygon is formed by connecting consecutive points
• The polygon is guaranteed to be simple (no self-intersections)
• Exactly two edges meet at each vertex

Goal: Return true if the polygon is convex, false otherwise.

Example: Points forming a square [[0,0], [1,0], [1,1], [0,1]] create a convex polygon, while an L-shape would not be convex.

Input & Output

example_1.py — Convex Square

$ Input: points = [[0,0],[1,0],[1,1],[0,1]]

› Output: true

💡 Note: The points form a square. All turns are 90-degree right turns, making it convex.

example_2.py — Non-convex L-shape

$ Input: points = [[0,0],[0,10],[10,10],[10,5],[5,5],[5,0]]

› Output: false

💡 Note: This forms an L-shape with both left and right turns, making it non-convex (concave).

example_3.py — Triangle

$ Input: points = [[0,0],[1,1],[0,2]]

› Output: true

💡 Note: Any triangle is always convex as all interior angles are less than 180 degrees.

Constraints

3 ≤ points.length ≤ 10⁴
points[i].length == 2
-10⁴ ≤ xi, yi ≤ 10⁴
All the given points are unique
The polygon formed by the points is always a simple polygon

Visualization

Tap to expand

Understanding the Visualization

Form vectors

Create two consecutive edge vectors at each vertex

Calculate cross product

Cross product sign indicates left (+) or right (-) turn

Track consistency

All cross products must have the same sign for convexity

Handle collinear

Zero cross products (collinear points) are allowed and ignored

Key Takeaway

🎯 Key Insight: The cross product of consecutive edge vectors reveals turn direction. A polygon is convex if and only if all turns are in the same direction (all cross products have the same sign).

Asked in

G Google 23 f Meta 18 a Amazon 15 ⊞ Microsoft 12

The optimal solution uses cross product calculations to determine turn direction at each vertex. By checking that all turns are consistent (either all clockwise or all counter-clockwise), we can detect convexity in O(n) time and O(1) space. The key insight is that the cross product sign indicates turn direction, and a convex polygon maintains the same turn direction throughout.

Common Approaches

Approach	Time	Space	Notes
✓ Optimized Cross Product (Optimal)	O(n)	O(1)	Single pass with optimized cross product calculation and early termination
Brute Force Cross Product Check	O(n)	O(1)	Check all consecutive triplets of points inefficiently with redundant calculations

Optimized Cross Product (Optimal) — Algorithm Steps

Initialize sign tracker to determine turn direction
Iterate through all vertices in a single pass
For each triplet of consecutive points, compute cross product
On first non-zero cross product, establish reference direction
For subsequent cross products, verify consistent direction
Return false immediately if direction changes

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Set expected_sign = 0, start traversal

First non-zero cross product

Establish reference direction (left or right)

Verify consistency

Check each subsequent turn matches reference

Early exit

Return false immediately if any turn differs

Code -

solution.c — C

bool isConvex(int** points, int pointsSize, int* pointsColSize) {
    if (pointsSize < 3) return false;
    
    int expectedSign = 0;
    
    for (int i = 0; i < pointsSize; i++) {
        int* p1 = points[i];
        int* p2 = points[(i + 1) % pointsSize];
        int* p3 = points[(i + 2) % pointsSize];
        
        long long cross = (long long)(p2[0] - p1[0]) * (p3[1] - p2[1]) - 
                          (long long)(p2[1] - p1[1]) * (p3[0] - p2[0]);
        
        if (cross == 0) continue;
        
        int sign = cross > 0 ? 1 : -1;
        
        if (expectedSign == 0) {
            expectedSign = sign;
        } else if (sign != expectedSign) {
            return false;
        }
    }
    
    return true;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through all n vertices with constant time per vertex

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables regardless of input size

✓ Linear Space

28.9K Views

Medium Frequency

~25 min Avg. Time

847 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Optimized Cross Product (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler