Matchsticks to Square - Practice Coding Problems

Matchsticks to Square - Problem

Imagine you have a collection of matchsticks of different lengths, and you want to arrange them to form a perfect square! 🔥

Given an integer array matchsticks where matchsticks[i] represents the length of the i-th matchstick, your task is to determine whether you can use all the matchsticks to construct exactly one square.

Rules:

You must use every single matchstick exactly once
You cannot break or cut any matchstick
You can connect matchsticks end-to-end to form longer sides
All four sides of the square must have equal length

Goal: Return true if it's possible to form a square, false otherwise.

Example: If you have matchsticks [1,1,2,2,2], you can form a square with sides of length 2 each: [1+1], [2], [2], [2] ✅

Input & Output

example_1.py — Basic Square Formation

$ Input: [1,1,2,2,2]

› Output: true

💡 Note: You can form a square with perimeter 8: each side has length 2. Arrange as [1+1], [2], [2], [2] for the four sides.

example_2.py — Impossible Configuration

$ Input: [3,3,3,3,4]

› Output: false

💡 Note: Total length is 16, so each side should be 4. But we have four sticks of length 3 and one of length 4, making it impossible to form equal sides.

example_3.py — Perfect Match

$ Input: [5,5,5,5,4,4,4,4,3,3,3,3]

› Output: true

💡 Note: Total is 48, each side should be 12. We can arrange as [5+4+3], [5+4+3], [5+4+3], [5+4+3] to form a perfect square.

Visualization

Tap to expand

Understanding the Visualization

Calculate Target

Add up all matchstick lengths and divide by 4 - this is your target side length

Sort Strategy

Sort matchsticks from longest to shortest - try big pieces first for faster failure detection

Backtrack & Assign

Try placing each matchstick on any side that has room, backtrack when stuck

Optimize & Prune

Skip equivalent empty sides and impossible configurations to speed up search

Key Takeaway

🎯 Key Insight: Sort matchsticks in descending order and use backtracking with aggressive pruning - this transforms an exponential problem into something manageable by failing fast on impossible configurations!

Time & Space Complexity

Time Complexity

⏱️

O(4^n)

For each of n matchsticks, we try placing it on any of 4 sides

✓ Linear Growth

Space Complexity

O(n)

Recursion stack depth equals number of matchsticks

⚡ Linearithmic Space

Constraints

1 ≤ matchsticks.length ≤ 15
1 ≤ matchsticks[i] ≤ 10⁸
Key insight: Total sum must be divisible by 4
All matchsticks must be used exactly once

Asked in

G Google 85 a Amazon 72 f Meta 68 ⊞ Microsoft 45

The optimal solution uses backtracking with smart optimizations: sort matchsticks in descending order, try larger sticks first for early pruning, skip equivalent side configurations, and terminate early on impossible branches. Key insight: if the largest matchstick can't fit on an empty side, no arrangement will work.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force Backtracking	O(4^n)	O(n)	Try all possible ways to assign matchsticks to 4 sides
Optimized Backtracking	O(4^n)	O(n)	Smart backtracking with sorting and pruning optimizations

Brute Force Backtracking — Algorithm Steps

Calculate target side length (total sum ÷ 4)
Use backtracking to try assigning each matchstick to one of 4 sides
For each matchstick, try placing it on each side that has enough space
If all matchsticks are placed and all sides equal target, return true
Backtrack and try different assignments if current path fails

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with 4 empty sides and first matchstick

Try Assignment

Try placing current matchstick on each available side

Recurse

Move to next matchstick and repeat the process

Backtrack

If path fails, remove matchstick and try next option

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

bool backtrack(int* matchsticks, int matchsticksSize, int* sides, int index, int target) {
    if (index == matchsticksSize) {
        return sides[0] == target && sides[1] == target && sides[2] == target && sides[3] == target;
    }
    
    for (int i = 0; i < 4; i++) {
        if (sides[i] + matchsticks[index] <= target) {
            sides[i] += matchsticks[index];
            if (backtrack(matchsticks, matchsticksSize, sides, index + 1, target)) {
                return true;
            }
            sides[i] -= matchsticks[index];
        }
    }
    
    return false;
}

bool makesquare(int* matchsticks, int matchsticksSize) {
    if (matchsticksSize < 4) return false;
    
    int total = 0;
    for (int i = 0; i < matchsticksSize; i++) {
        total += matchsticks[i];
    }
    
    if (total % 4 != 0) return false;
    
    int target = total / 4;
    int sides[4] = {0, 0, 0, 0};
    
    return backtrack(matchsticks, matchsticksSize, sides, 0, target);
}

int main() {
    char input[1000];
    fgets(input, sizeof(input), stdin);
    
    int matchsticks[20];
    int size = 0;
    
    char* token = strtok(input, "[],");
    while (token != NULL && size < 20) {
        matchsticks[size++] = atoi(token);
        token = strtok(NULL, "[],");
    }
    
    printf("%s\n", makesquare(matchsticks, size) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(4^n)

For each of n matchsticks, we try placing it on any of 4 sides

✓ Linear Growth

Space Complexity

O(n)

Recursion stack depth equals number of matchsticks

⚡ Linearithmic Space

Constraints

1 ≤ matchsticks.length ≤ 15
1 ≤ matchsticks[i] ≤ 10⁸
Key insight: Total sum must be divisible by 4
All matchsticks must be used exactly once

62.3K Views

Medium-High Frequency

~25 min Avg. Time

1.8K 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force Backtracking — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler