Longest Square Streak in an Array

Longest Square Streak in an Array - Problem

You are given an integer array nums. A subsequence of nums is called a square streak if:

The length of the subsequence is at least 2, and
after sorting the subsequence, each element (except the first element) is the square of the previous number.

Return the length of the longest square streak in nums, or return -1 if there is no square streak.

A subsequence is an array that can be derived from another array by deleting some or no elements without changing the order of the remaining elements.

Input & Output

Example 1 — Perfect Square Chain

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

› Output: 3

💡 Note: We can form the square streak [2,4,16]: 2² = 4, 4² = 16. The longest streak has length 3.

Example 2 — No Valid Streak

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

› Output: -1

💡 Note: No number in the array has its square also in the array, so no square streak can be formed.

Example 3 — Multiple Short Streaks

$ Input: nums = [2,4,8,16]

› Output: 3

💡 Note: We can form the square streak [2,4,16]: 2² = 4, 4² = 16. The longest streak has length 3.

Constraints

2 ≤ nums.length ≤ 10⁵
-10⁵ ≤ nums[i] ≤ 10⁵

Visualization

Tap to expand

Asked in

f Meta 15 G Google 12 a Amazon 8

The key insight is to use a hash set for O(1) lookups and build chains by repeatedly squaring numbers. The optimal approach uses memoization to avoid recalculating chain lengths. Time: O(n), Space: O(n).

Common Approaches

✓ Brute Force - Check All Subsequences

⏱️ Time: O(n × 2^n) Space: O(n)

For each possible subsequence of the array, sort it and verify if each element is the square of the previous one. Track the maximum length found.

Dynamic Programming with Memoization

⏱️ Time: O(n) Space: O(n)

Build a hash map where each number maps to the length of the longest chain starting from that number. Use recursive approach with memoization to avoid redundant calculations.

Hash Set Optimization

⏱️ Time: O(n × k) Space: O(n)

Store all numbers in a hash set for O(1) lookup. For each number, try to build the longest chain by repeatedly squaring and checking if the result exists in the set.

Brute Force - Check All Subsequences — Algorithm Steps

Generate all 2^n possible subsequences
For each subsequence, sort and validate square pattern
Return maximum length found or -1

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate

Create all possible subsequences

Sort & Check

Sort each and verify square pattern

Track Max

Keep track of longest valid streak

Code -

solution.c — C

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

static int uniqueNums[100000];
static long long subsequence[20];

int solution(int* nums, int numsSize) {
    // Get unique values
    int uniqueCount = 0;
    for (int i = 0; i < numsSize; i++) {
        int found = 0;
        for (int j = 0; j < uniqueCount; j++) {
            if (uniqueNums[j] == nums[i]) {
                found = 1;
                break;
            }
        }
        if (!found) {
            uniqueNums[uniqueCount++] = nums[i];
        }
    }
    
    int maxLength = -1;
    
    // Check all possible subsequences of unique numbers
    for (int mask = 0; mask < (1 << uniqueCount); mask++) {
        int subSize = 0;
        
        for (int i = 0; i < uniqueCount; i++) {
            if (mask & (1 << i)) {
                subsequence[subSize++] = uniqueNums[i];
            }
        }
        
        if (subSize < 2) continue;
        
        // Sort subsequence
        for (int i = 0; i < subSize - 1; i++) {
            for (int j = i + 1; j < subSize; j++) {
                if (subsequence[i] > subsequence[j]) {
                    long long temp = subsequence[i];
                    subsequence[i] = subsequence[j];
                    subsequence[j] = temp;
                }
            }
        }
        
        // Check if it's a square streak
        int isSquareStreak = 1;
        for (int i = 1; i < subSize; i++) {
            if (subsequence[i] != subsequence[i-1] * subsequence[i-1]) {
                isSquareStreak = 0;
                break;
            }
        }
        
        if (isSquareStreak && subSize > maxLength) {
            maxLength = subSize;
        }
    }
    
    return maxLength;
}

int main() {
    char line[10000];
    if (!fgets(line, sizeof(line), stdin)) {
        printf("-1\n");
        return 0;
    }
    
    // Parse JSON array manually
    int nums[100000];
    int numsSize = 0;
    char* p = line;
    
    // Skip to first number
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    while (*p && *p != ']') {
        // Skip whitespace and commas
        while (*p == ' ' || *p == ',' || *p == '\n' || *p == '\r') p++;
        if (*p == ']' || *p == '\0') break;
        
        // Parse number
        char* endp;
        long val = strtol(p, &endp, 10);
        if (endp != p) {
            nums[numsSize++] = (int)val;
            p = endp;
        } else {
            break;
        }
    }
    
    int result = solution(nums, numsSize);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × 2^n)

Generate 2^n subsequences, each taking O(n) to validate

✓ Linear Growth

Space Complexity

O(n)

Space for storing current subsequence and sorting

⚡ Linearithmic Space

32.0K Views

Medium Frequency

~25 min Avg. Time

850 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 Subsequences — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler