Unique Substrings in Wraparound String - Practice Coding Problems

Unique Substrings in Wraparound String - Problem

Imagine an infinite wraparound string containing the alphabet repeated endlessly:

"...zabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcd..."

This magical string has a special property: it wraps around from 'z' back to 'a', creating an endless cycle of alphabetical characters.

Given a string s, your task is to determine how many unique non-empty substrings of s can be found within this infinite wraparound string.

Key Points:

A substring is valid if it appears consecutively in the wraparound pattern
Characters must be in alphabetical order (with 'z' followed by 'a')
We only count unique substrings - duplicates don't add to the count
Examples of valid sequences: "abc", "xyz", "zabc", "xyza"

Input & Output

example_1.py — Basic Case

$ Input: s = "a"

› Output: 1

💡 Note: Only one substring "a" exists, and it's present in the wraparound string.

example_2.py — Sequential Characters

$ Input: s = "caba"

› Output: 6

💡 Note: Valid substrings are: "c", "a", "b", "a", "ca", "ab". Note that "a" appears twice but we only count unique substrings, so the unique ones are: "c", "a", "b", "ca", "ab", "aba" = 6 total.

example_3.py — Wraparound Case

$ Input: s = "zabc"

› Output: 10

💡 Note: All substrings are valid: "z", "a", "b", "c", "za", "ab", "bc", "zab", "abc", "zabc". The sequence wraps from 'z' to 'a' correctly.

Visualization

Tap to expand

Understanding the Visualization

Walk the Track

Move through the string, extending your path when possible

Mark Positions

At each letter, record the longest valid sequence ending there

Count Paths

Sum all maximum lengths - this gives total unique substrings

Key Takeaway

🎯 Key Insight: Instead of generating substrings, track the maximum valid sequence length ending at each character - this automatically counts all unique substrings without duplicates!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the input string

✓ Linear Growth

Space Complexity

O(1)

Only need array of size 26 for alphabet characters

✓ Linear Space

Constraints

1 ≤ s.length ≤ 10⁵
s consists of lowercase English letters only
Time limit: 1 second per test case

Asked in

G Google 15 f Meta 12 a Amazon 8 ⊞ Microsoft 6

The optimal solution uses dynamic programming by tracking the maximum length of valid wraparound sequences ending at each character. The key insight is that if a character can end sequences of length k, then there are exactly k unique substrings ending at that character. This eliminates the need to generate actual substrings and automatically handles duplicates, achieving O(n) time and O(1) space complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Substrings)	O(n³)	O(n³)	Generate all substrings and check if each one is valid in the wraparound pattern
Dynamic Programming with Character Mapping (Optimal)	O(n)	O(1)	Track maximum length of valid sequences ending at each character

Brute Force (Check All Substrings) — Algorithm Steps

Generate all possible substrings of the input string
For each substring, check if it forms a valid wraparound sequence
Use a set to store valid substrings to avoid counting duplicates
Return the size of the set

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Substrings

Create all possible substrings using nested loops

Validate Each

Check if each substring follows wraparound pattern

Store Unique

Use set to store only unique valid substrings

Code -

solution.c — C

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

#define MAX_LEN 10000

bool isValidSequence(char* s, int start, int end) {
    for (int i = start + 1; i < end; i++) {
        if ((s[i] - s[i-1] + 26) % 26 != 1) {
            return false;
        }
    }
    return true;
}

int findSubstringInWraproundString(char* s) {
    int n = strlen(s);
    if (n == 0) return 0;
    
    char validSubstrings[MAX_LEN][MAX_LEN];
    int count = 0;
    
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j <= n; j++) {
            if (isValidSequence(s, i, j)) {
                strncpy(validSubstrings[count], s + i, j - i);
                validSubstrings[count][j - i] = '\0';
                
                // Check for duplicates
                bool isDuplicate = false;
                for (int k = 0; k < count; k++) {
                    if (strcmp(validSubstrings[k], validSubstrings[count]) == 0) {
                        isDuplicate = true;
                        break;
                    }
                }
                
                if (!isDuplicate) {
                    count++;
                }
            }
        }
    }
    
    return count;
}

int main() {
    char s[MAX_LEN];
    fgets(s, sizeof(s), stdin);
    
    // Remove newline and quotes
    int len = strlen(s);
    if (s[len-1] == '\n') s[len-1] = '\0';
    if (s[0] == '"') {
        memmove(s, s+1, strlen(s));
        s[strlen(s)-1] = '\0';
    }
    
    printf("%d\n", findSubstringInWraproundString(s));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) substrings × O(n) validation for each substring

⚠ Quadratic Growth

Space Complexity

O(n³)

Potentially storing all O(n²) substrings, each taking O(n) space

⚠ Quadratic Space

Constraints

1 ≤ s.length ≤ 10⁵
s consists of lowercase English letters only
Time limit: 1 second per test case

28.5K Views

Medium Frequency

~25 min Avg. Time

892 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 (Check All Substrings) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler