Construct the Rectangle - Practice Coding Problems

Construct the Rectangle - Problem

Math Easy

Design the Perfect Rectangle

As a web developer, you need to design a rectangular web page with specific dimensions. Given the total area of the page, find the length L and width W that create the most square-like rectangle possible.

Requirements:
• The area must exactly equal the given target area
• Width W ≤ Length L (width cannot exceed length)
• The difference |L - W| should be minimized

Goal: Return [L, W] where L and W are the optimal dimensions.

Example: For area = 4, return [2, 2] (a perfect square). For area = 6, return [3, 2] (closest to square while satisfying L ≥ W).

Input & Output

example_1.py — Basic Square

$ Input: area = 4

› Output: [2, 2]

💡 Note: Area 4 can form a perfect square 2×2. Since L=W=2, this satisfies L≥W and minimizes |L-W|=0.

example_2.py — Near-Square Rectangle

$ Input: area = 6

› Output: [3, 2]

💡 Note: Area 6 has factors: 1×6 and 2×3. Between [6,1] (diff=5) and [3,2] (diff=1), we choose [3,2] as it's closest to square.

example_3.py — Prime Number

$ Input: area = 7

› Output: [7, 1]

💡 Note: Area 7 is prime, so only factors are 1×7. Result is [7,1] - the only valid rectangle.

Constraints

1 ≤ area ≤ 10⁷
area is always a positive integer
The returned length L must be ≥ width W

Visualization

Tap to expand

Understanding the Visualization

Calculate Target

Find √area as our ideal starting point for a square

Test Divisibility

Check if current width divides area evenly

Adjust if Needed

If not divisible, decrease width by 1 and try again

Found Solution

First valid width gives us the optimal rectangle

Key Takeaway

🎯 Key Insight: The optimal rectangle always has its width as the largest factor ≤ √area, making the search efficient and the result closest to a square.

Asked in

G Google 23 a Amazon 18 f Meta 15 Apple 12

The optimal solution uses square root optimization with O(√n) time complexity. Start from floor(√area) and work downward to find the largest width that divides the area evenly. This gives us the most square-like rectangle immediately, as the optimal width is always the largest factor ≤ √area.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Factors)	O(n)	O(1)	Check every possible width from 1 to area, find valid rectangles
Square Root Optimization (Optimal)	O(√n)	O(1)	Start from √area and search downward for the largest valid width

Brute Force (Check All Factors) — Algorithm Steps

Initialize best length and width as area and 1
Loop through all possible widths from 1 to area
For each width, check if area % width == 0
If divisible, calculate length = area / width
If length - width < best difference, update best rectangle
Return [length, width] of the best rectangle found

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with width = 1

Check if area is divisible by 1 (always true), calculate length = area

Increment width

Try width = 2, 3, 4... checking divisibility each time

Track best rectangle

Keep the rectangle with smallest difference |L - W|

Continue until area

Check all possible widths up to the area value

Code -

solution.c — C

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

int* constructRectangle(int area, int* returnSize) {
    int* result = (int*)malloc(2 * sizeof(int));
    *returnSize = 2;
    
    int bestLength = area;
    int bestWidth = 1;
    
    for (int width = 1; width <= area; width++) {
        if (area % width == 0) {
            int length = area / width;
            if (length >= width) {
                if (length - width < bestLength - bestWidth) {
                    bestLength = length;
                    bestWidth = width;
                }
            }
        }
    }
    
    result[0] = bestLength;
    result[1] = bestWidth;
    return result;
}

int main() {
    int area;
    scanf("%d", &area);
    int returnSize;
    int* result = constructRectangle(area, &returnSize);
    printf("[%d, %d]\n", result[0], result[1]);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

We iterate through all numbers from 1 to n (area) to find factors

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to track the best rectangle dimensions

✓ Linear Space

28.4K Views

Medium Frequency

~12 min Avg. Time

886 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

Brute Force (Check All Factors) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler