Magical String - Practice Coding Problems

Magical String - Problem

Imagine a self-describing string that's so magical, it contains the blueprint for its own construction! 🎩✨

A magical string s consists only of characters '1' and '2' and follows a fascinating rule: when you group consecutive identical characters and count their lengths, those counts recreate the original string itself!

The magical string begins: "1221121221221121122..."

Let's see the magic in action:

Grouping: "1 | 22 | 11 | 2 | 1 | 22 | 1 | 22 | 11 | 2 | 11 | 22 | ..."
Group lengths: [1, 2, 2, 1, 1, 2, 1, 2, 2, 1, 2, 2, ...]
Concatenating lengths: "122112122122..." = original string!

Your task: Given an integer n, return the number of '1's in the first n characters of the magical string.

Input & Output

example_1.py — Basic Case

$ Input: n = 6

› Output: 3

💡 Note: The magical string starts as '122112...'. The first 6 characters are '122112', which contains three 1's at positions 0, 3, and 4.

example_2.py — Single Character

$ Input: n = 1

› Output: 1

💡 Note: The first character of the magical string is '1', so there is exactly one '1' in the first 1 character.

example_3.py — Edge Case

$ Input: n = 0

› Output: 0

💡 Note: When n = 0, we don't consider any characters, so the count of 1's is 0.

Constraints

1 ≤ n ≤ 10⁵
The magical string is uniquely defined
Only characters '1' and '2' appear in the string

Visualization

Tap to expand

Understanding the Visualization

Foundation

Start with '122' - the seed that grows into the infinite pattern

Self-Reference

Position 2 contains '2', telling us the next group has 2 characters

Alternation

Groups alternate between 1's and 2's, with sizes from the string itself

Infinite Growth

The pattern continues indefinitely, always self-consistent

Key Takeaway

🎯 Key Insight: The magical string is self-describing - it contains its own construction blueprint, allowing us to generate it efficiently with minimal memory while counting 1's on the fly.

Asked in

G Google 25 a Amazon 18 ⊞ Microsoft 12 f Meta 8

The optimal solution uses two pointers to generate the magical string on-demand while counting 1's. Key insight: we don't need to store the entire string - just enough characters to read group sizes. This achieves O(n) time and O(1) space complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Optimized Generation (Single Pass)	O(n)	O(1)	Generate the magical string on-demand while counting 1's in a single pass
Generate Full String Then Count	O(n)	O(n)	Build the entire magical string up to length n, then count all 1's

Optimized Generation (Single Pass) — Algorithm Steps

Initialize count of 1's and start with the first few characters
Use one pointer (i) for current generation position
Use another pointer (j) for reading group sizes from earlier positions
For each position, determine if it should be 1 or 2 based on alternating groups
If current character is 1, increment our count
Continue until we've processed n characters

Visualization

Tap to expand

Step-by-Step Walkthrough

Setup Pointers

Generation pointer at pos 3, group reader at pos 2

Generate & Count

Add character based on group info, count if it's 1

Update State

Move pointers, track remaining chars in current group

Continue

Repeat until n characters processed

Code -

solution.c — C

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

int magicalString(int n) {
    if (n <= 0) return 0;
    if (n == 1) return 1;
    if (n <= 3) return 1;
    
    int onesCount = 1;
    int* chars = (int*)malloc(n * sizeof(int));
    chars[0] = 1; chars[1] = 2; chars[2] = 2;
    int charsLen = 3;
    
    int i = 3;
    int groupIdx = 2;
    int currentChar = 1;
    int remainingInGroup = chars[groupIdx] - 1;
    
    while (i < n) {
        if (remainingInGroup == 0) {
            groupIdx++;
            currentChar = 3 - currentChar;
            if (groupIdx >= charsLen) {
                chars[charsLen++] = currentChar;
            }
            remainingInGroup = chars[groupIdx];
        }
        
        if (i < n && currentChar == 1) {
            onesCount++;
        }
        
        if (groupIdx + 1 >= charsLen) {
            chars[charsLen++] = currentChar;
        }
        
        remainingInGroup--;
        i++;
    }
    
    free(chars);
    return onesCount;
}

int main() {
    int n;
    scanf("%d", &n);
    printf("%d\n", magicalString(n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

We process exactly n characters once

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables regardless of input size

✓ Linear Space

23.4K Views

Medium Frequency

~15 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

Constraints

Visualization

Related Problems

Common Approaches

Optimized Generation (Single Pass) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler