Longest Square Streak in an Array - Practice Coding Problems

Longest Square Streak in an Array - Problem

You're given an integer array nums, and your task is to find the longest square streak within it!

A square streak is a special subsequence where:

It contains at least 2 elements
When sorted, each element (except the first) is the perfect square of the previous element

For example, in the sequence [2, 4, 16], we have: 2 → 4 (2²) → 16 (4²)

Goal: Return the length of the longest square streak, or -1 if no valid streak exists.

Note: A subsequence can be formed by removing some elements without changing the order of remaining elements.

Input & Output

example_1.py — Perfect Square Chain

$ Input: [4, 3, 6, 16, 8, 2]

› Output: 3

💡 Note: The longest square streak is [2, 4, 16] with length 3. Chain: 2 → 4 (2²) → 16 (4²)

example_2.py — No Valid Chain

$ Input: [2, 3, 5, 6, 7]

› Output: -1

💡 Note: No number in the array is a perfect square of another number, so no square streak exists

example_3.py — Single Valid Pair

$ Input: [4, 16, 256, 65536]

› Output: 4

💡 Note: Complete chain: 4 → 16 (4²) → 256 (16²) → 65536 (256²) has length 4

Constraints

2 ≤ nums.length ≤ 10⁵
2 ≤ nums[i] ≤ 10⁵
All values in nums are unique
A subsequence can be formed by removing elements without changing order

Visualization

Tap to expand

Understanding the Visualization

Identify Building Blocks

We have blocks: [4, 3, 6, 16, 8, 2]

Find Foundation Blocks

Only start from blocks that aren't squares of others: 2 and 3 are foundations

Build from Foundation 2

2 → 4 (2²=4) → 16 (4²=16). Tower height: 3

Try Foundation 3

3 → ? (3²=9, not available). Tower height: 1

Key Takeaway

🎯 Key Insight: Start building only from 'foundation' numbers - those that aren't perfect squares of existing numbers. This finds each tower exactly once and gives us the optimal solution!

Asked in

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

The optimal approach uses a hash set for O(1) lookups and only starts building chains from 'root' numbers - numbers that aren't perfect squares of other numbers in the set. This eliminates duplicate work and achieves O(n × log(max_value)) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Combinations)	O(n² × log(max_value))	O(1)	Try every possible starting number and manually search for its squares
Optimized Hash Set (Smart Starting Points)	O(n × log(max_value))	O(n)	Only start chains from numbers that aren't perfect squares of existing numbers
Two-Pass Hash Set	O(n × log(max_value))	O(n)	Build hash set first, then efficiently search for square chains

Brute Force (Check All Combinations) — Algorithm Steps

For each number in the array, treat it as a potential start of a square streak
Starting from this number, repeatedly search the array for its square
If found, continue the streak; if not, record the current streak length
Keep track of the maximum streak length found

Visualization

Tap to expand

Step-by-Step Walkthrough

Pick Starting Number

Choose first number (4) as potential start of streak

Search for Square

Look through entire array for 4² = 16

Continue Chain

Found 16! Now search for 16² = 256 (not found)

Record Length

Streak length is 2, update maximum if needed

Code -

solution.c — C

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

int longestSquareStreak(int* nums, int numsSize) {
    if (numsSize < 2) return -1;
    
    int maxStreak = 0;
    
    for (int i = 0; i < numsSize; i++) {
        int currentStreak = 1;
        long long current = nums[i];
        
        while (1) {
            long long nextSquare = current * current;
            if (nextSquare > 100000) break;
            
            int found = 0;
            for (int j = 0; j < numsSize; j++) {
                if (nums[j] == nextSquare) {
                    found = 1;
                    break;
                }
            }
            
            if (found) {
                currentStreak++;
                current = nextSquare;
            } else {
                break;
            }
        }
        
        if (currentStreak > maxStreak) {
            maxStreak = currentStreak;
        }
    }
    
    return maxStreak >= 2 ? maxStreak : -1;
}

int main() {
    int nums[] = {4, 3, 6, 16, 8, 2};
    int size = 6;
    printf("%d\n", longestSquareStreak(nums, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² × log(max_value))

For each of n elements, we potentially search through n elements, and each square operation can be expensive

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables to track current and maximum streak lengths

✓ Linear Space

27.5K Views

Medium-High Frequency

~18 min Avg. Time

1.2K 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 Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler