Squares of a Sorted Array - Practice Coding Problems

Squares of a Sorted Array - Problem

Given an integer array nums sorted in non-decreasing order, return an array of the squares of each number sorted in non-decreasing order.

The challenge lies in the fact that negative numbers, when squared, become positive and can potentially be larger than the squares of positive numbers. For example, (-4)² = 16 while 3² = 9, so -4 squared is actually larger than 3 squared!

Goal: Transform each element to its square while maintaining sorted order in the result.

Example: [-4, -1, 0, 3, 10] → [0, 1, 9, 16, 100]

Input & Output

example_1.py — Basic Case

$ Input: nums = [-4,-1,0,3,10]

› Output: [0,1,9,16,100]

💡 Note: After squaring, we get [16,1,0,9,100]. After sorting, we get [0,1,9,16,100].

example_2.py — All Negative

$ Input: nums = [-7,-3,-2,-1]

› Output: [1,4,9,49]

💡 Note: After squaring, we get [49,9,4,1]. After sorting, we get [1,4,9,49].

example_3.py — All Positive

$ Input: nums = [1,2,3,4,5]

› Output: [1,4,9,16,25]

💡 Note: Since all numbers are positive and already sorted, their squares remain in sorted order.

Constraints

1 ≤ nums.length ≤ 10⁴
-10⁴ ≤ nums[i] ≤ 10⁴
nums is sorted in non-decreasing order

Visualization

Tap to expand

Understanding the Visualization

Set Up Battle Arena

Place pointers at both ends - these represent our 'competitors'

Square Off

Calculate squares of both competitors

Winner Takes Position

The larger square wins and gets placed in the result

Next Round

Move the winning pointer inward and repeat

Key Takeaway

🎯 Key Insight: In a sorted array, the largest absolute values (and thus largest squares) are always at the ends. The two-pointer approach leverages this property to build the result efficiently in O(n) time.

Asked in

G Google 45 a Amazon 38 f Meta 28 ⊞ Microsoft 22

The optimal solution uses the two pointers technique in O(n) time. Since the input is sorted, the largest absolute values (and thus largest squares) are at the ends. We compare squares from both ends and fill the result array from largest to smallest, achieving optimal performance without additional sorting.

Common Approaches

Approach	Time	Space	Notes
✓ Two Pointers (Optimal)	O(n)	O(1)	Use two pointers from both ends, comparing absolute values
Square and Sort	O(n log n)	O(1)	Square all elements first, then sort the result

Two Pointers (Optimal) — Algorithm Steps

Initialize two pointers: left at start, right at end
Create result array and fill from right to left (largest to smallest)
Compare squares of elements at both pointers
Place the larger square at current position in result
Move the corresponding pointer inward
Continue until pointers meet

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Pointers

Set left at start, right at end, position at last index

Compare Squares

Compare squares of elements at both pointers

Place Larger Square

Place larger square in result and move corresponding pointer

Continue Until Done

Repeat until all elements are processed

Code -

solution.c — C

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

int* sortedSquares(int* nums, int numsSize, int* returnSize) {
    *returnSize = numsSize;
    int* result = (int*)malloc(numsSize * sizeof(int));
    int left = 0, right = numsSize - 1;
    int pos = numsSize - 1; // Fill from right to left
    
    while (left <= right) {
        int leftSquare = nums[left] * nums[left];
        int rightSquare = nums[right] * nums[right];
        
        if (leftSquare > rightSquare) {
            result[pos] = leftSquare;
            left++;
        } else {
            result[pos] = rightSquare;
            right--;
        }
        pos--;
    }
    
    return result;
}

int main() {
    int nums[] = {-4, -1, 0, 3, 10};
    int size = 5;
    int returnSize;
    int* result = sortedSquares(nums, size, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array with two pointers

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space (excluding output array)

✓ Linear Space

42.0K Views

High Frequency

~15 min Avg. Time

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

Two Pointers (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler