Shifting Letters - Practice Coding Problems

Shifting Letters - Problem

Transform letters through cascading shifts!

You are given a string s of lowercase English letters and an integer array shifts of the same length. Your task is to perform a series of cascading shifts on the string.

How shifting works:
• Each letter shifts to the next letter in the alphabet (wrapping around: 'z' → 'a')
• shift('a') = 'b', shift('t') = 'u', shift('z') = 'a'

The Challenge:
For each shifts[i] = x, you need to shift the first i+1 letters of the string x times. This creates a cascading effect where earlier letters get shifted multiple times by later operations.

Goal: Return the final string after all shift operations are applied.

Example: If s = "abc" and shifts = [3,5,9]:
• First operation: shift first 1 letter 3 times: "abc" → "dbc"
• Second operation: shift first 2 letters 5 times: "dbc" → "igc"
• Third operation: shift first 3 letters 9 times: "igc" → "rpl"

Input & Output

example_1.py — Basic Case

$ Input: s = "abc", shifts = [3,5,9]

› Output: "rpl"

💡 Note: Position 0 ('a') gets shifted 3+5+9=17 times: 'a'→'r'. Position 1 ('b') gets shifted 5+9=14 times: 'b'→'p'. Position 2 ('c') gets shifted 9 times: 'c'→'l'.

example_2.py — Single Character

$ Input: s = "z", shifts = [25]

› Output: "y"

💡 Note: The character 'z' is shifted 25 times. Since there are 26 letters, 25 shifts brings 'z' to 'y' (wrapping around the alphabet).

example_3.py — Large Shifts

$ Input: s = "aaa", shifts = [1,2,3]

› Output: "gfd"

💡 Note: Position 0 gets 1+2+3=6 shifts: 'a'→'g'. Position 1 gets 2+3=5 shifts: 'a'→'f'. Position 2 gets 3 shifts: 'a'→'d'.

Constraints

1 ≤ s.length ≤ 10⁵
s consists of lowercase English letters
shifts.length == s.length
0 ≤ shifts[i] ≤ 10⁹
Note: Large shift values require modulo arithmetic to avoid overflow

Visualization

Tap to expand

Understanding the Visualization

Identify the Pattern

Each position gets affected by all shift operations from that position onwards

Calculate Cumulative Effect

Work backwards to efficiently compute total shifts per position

Apply Once

Apply the calculated total shifts to each character in a single pass

Key Takeaway

🎯 Key Insight: Instead of repeatedly applying shifts (domino effect), calculate the total shifts each position will receive by working backwards, then apply once. This transforms an O(n²) problem into an elegant O(n) solution using the prefix sum technique.

Asked in

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

The optimal solution uses prefix sum technique to calculate cumulative shifts efficiently. Instead of applying each shift operation individually (O(n²)), we work backwards through the shifts array to determine the total number of shifts each position receives, then apply all shifts in a single pass (O(n)). This eliminates redundant calculations and achieves optimal time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Prefix Sum (Optimal)	O(n)	O(n)	Calculate cumulative shifts for each position using prefix sum technique
Brute Force (Nested Loops)	O(n²)	O(n)	Apply each shift operation individually, shifting characters one by one

Prefix Sum (Optimal) — Algorithm Steps

Work backwards through shifts array to calculate cumulative shifts
Each position i gets affected by shifts[i], shifts[i+1], ..., shifts[n-1]
Use running sum to efficiently calculate total shifts per position
Apply all calculated shifts at once to get final result

Visualization

Tap to expand

Step-by-Step Walkthrough

Analyze Pattern

Position 0 gets shifts[0]+shifts[1]+shifts[2], Position 1 gets shifts[1]+shifts[2], etc.

Work Backwards

Start from the end and accumulate shifts: total_shift = 0, 9, 14, 17

Apply Once

Apply calculated total shifts to each position in single pass

Code -

solution.c — C

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

char* shiftingLetters(char* s, int* shifts, int shiftsSize) {
    int n = strlen(s);
    char* result = (char*)malloc((n + 1) * sizeof(char));
    strcpy(result, s);
    
    // Calculate cumulative shifts working backwards
    long long totalShift = 0;
    for (int i = n - 1; i >= 0; i--) {
        totalShift = (totalShift + shifts[i]) % 26;
        // Apply total shift to position i
        int charNum = result[i] - 'a';
        int newCharNum = (charNum + totalShift) % 26;
        result[i] = (char)(newCharNum + 'a');
    }
    
    return result;
}

int main() {
    char s[1001];
    scanf("%s", s);
    
    int len = strlen(s);
    if (s[0] == '"') {
        memmove(s, s + 1, len);
        s[len - 2] = '\0';
    }
    
    int shifts[1000];
    int count = 0;
    char c;
    while (scanf("%d%c", &shifts[count], &c)) {
        count++;
        if (c == ']') break;
    }
    
    char* result = shiftingLetters(s, shifts, count);
    printf("\"%s\"", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass to calculate cumulative shifts + single pass to apply shifts = O(n)

✓ Linear Growth

Space Complexity

O(n)

We need O(n) space to store the result string as a mutable array

⚡ Linearithmic Space

76.0K Views

Medium Frequency

~18 min Avg. Time

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

Prefix Sum (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler