Shifting Letters II

Shifting Letters II - Problem

You are given a string s of lowercase English letters and a 2D integer array shifts where shifts[i] = [start_i, end_i, direction_i].

For every i, shift the characters in s from the index start_i to the index end_i (inclusive) forward if direction_i = 1, or shift the characters backward if direction_i = 0.

Shifting a character forward means replacing it with the next letter in the alphabet (wrapping around so that 'z' becomes 'a'). Similarly, shifting a character backward means replacing it with the previous letter in the alphabet (wrapping around so that 'a' becomes 'z').

Return the final string after all such shifts to s are applied.

Input & Output

Example 1 — Basic Case

$ Input: s = "abc", shifts = [[0,1,1],[1,2,0],[0,2,1]]

› Output: "ccc"

💡 Note: Using difference array: [0,1,1] adds +2 at pos 0, -1 at pos 1, -1 at pos 2. After [1,2,0]: +2 at pos 0, -2 at pos 1, -1 at pos 2, +1 at pos 3. After [0,2,1]: +3 at pos 0, -2 at pos 1, -2 at pos 2, +0 at pos 3. Prefix sums: [3,1,0] giving shifts of +3,+1,+0 → 'a'+3='d' but with modulo gives 'a'→'d', 'b'→'c', 'c'→'c'. Actually: net shifts are [+2,+1,+0] → 'c','c','c'.

Example 2 — Single Character

$ Input: s = "a", shifts = [[0,0,1]]

› Output: "b"

💡 Note: Single shift forward: 'a' becomes 'b'

Example 3 — Wrap Around

$ Input: s = "z", shifts = [[0,0,1]]

› Output: "a"

💡 Note: Forward shift from 'z' wraps around to 'a'

Constraints

1 ≤ s.length ≤ 5 × 10⁴
1 ≤ shifts.length ≤ 5 × 10⁴
shifts[i].length = 3
0 ≤ start_i ≤ end_i < s.length
direction_i is either 0 or 1

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 18 f Facebook 15

The key insight is using a difference array to efficiently handle multiple range updates. Instead of applying each shift operation individually (O(m×n)), we accumulate all changes in O(m) time and apply them once in O(n) time. Best approach is difference array with prefix sum. Time: O(n+m), Space: O(n)

Common Approaches

✓ Brute Force - Apply Each Shift

⏱️ Time: O(m × n) Space: O(1)

For each shift operation, iterate through the specified range and shift each character forward or backward one position. This approach directly simulates the problem statement.

Difference Array (Prefix Sum)

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

Instead of applying each shift individually, use a difference array to track net shift amount for each position. Then apply all shifts at once using prefix sum technique.

Brute Force - Apply Each Shift — Algorithm Steps

For each shift operation
Iterate through range [start, end]
Shift each character by +1 or -1 based on direction

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial String

Start with original string

Apply Shifts

Process each shift operation on the range

Final Result

String after all shifts applied

Code -

solution.c — C

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

char* solution(char* s, int** shifts, int shiftsSize) {
    int n = strlen(s);
    char* result = (char*)malloc((n + 1) * sizeof(char));
    strcpy(result, s);
    
    // Apply each shift operation one by one
    for (int i = 0; i < shiftsSize; i++) {
        int start = shifts[i][0];
        int end = shifts[i][1];
        int direction = shifts[i][2];
        
        // Shift each character in the range [start, end]
        for (int j = start; j <= end; j++) {
            if (direction == 1) {
                // Shift forward
                result[j] = ((result[j] - 'a' + 1) % 26) + 'a';
            } else {
                // Shift backward
                result[j] = ((result[j] - 'a' - 1 + 26) % 26) + 'a';
            }
        }
    }
    
    return result;
}

int main() {
    char line[500000];
    
    // Read s
    fgets(line, sizeof(line), stdin);
    // Remove whitespace, quotes, newlines
    char s[50001];
    int idx = 0;
    for (int i = 0; line[i] != '\0' && line[i] != '\n'; i++) {
        if (line[i] >= 'a' && line[i] <= 'z') {
            s[idx++] = line[i];
        }
    }
    s[idx] = '\0';
    
    // Read shifts array
    fgets(line, sizeof(line), stdin);
    
    // Count shifts
    int shiftsSize = 0;
    for (int i = 0; line[i] != '\0'; i++) {
        if (line[i] == '[' && i + 1 < strlen(line) && line[i+1] != '[' && line[i+1] != ']') {
            shiftsSize++;
        }
    }
    
    // Allocate shifts array
    int** shifts = (int**)malloc(shiftsSize * sizeof(int*));
    for (int i = 0; i < shiftsSize; i++) {
        shifts[i] = (int*)malloc(3 * sizeof(int));
    }
    
    // Parse shifts
    char* ptr = line;
    int shiftIdx = 0;
    
    while (*ptr && shiftIdx < shiftsSize) {
        if (*ptr == '[' && shiftIdx < shiftsSize) {
            ptr++;
            // Check if this is an inner bracket
            int hasDigit = 0;
            char* check = ptr;
            while (*check && *check != ']' && *check != '[') {
                if (*check >= '0' && *check <= '9') {
                    hasDigit = 1;
                    break;
                }
                check++;
            }
            
            if (hasDigit) {
                shifts[shiftIdx][0] = (int)strtol(ptr, &ptr, 10);
                while (*ptr && (*ptr == ',' || *ptr == ' ')) ptr++;
                shifts[shiftIdx][1] = (int)strtol(ptr, &ptr, 10);
                while (*ptr && (*ptr == ',' || *ptr == ' ')) ptr++;
                shifts[shiftIdx][2] = (int)strtol(ptr, &ptr, 10);
                shiftIdx++;
            }
        } else {
            ptr++;
        }
    }
    
    char* result = solution(s, shifts, shiftsSize);
    printf("%s\n", result);
    
    free(result);
    for (int i = 0; i < shiftsSize; i++) {
        free(shifts[i]);
    }
    free(shifts);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m × n)

m shifts × n average range size operations

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

28.0K Views

Medium Frequency

~25 min Avg. Time

890 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 - Apply Each Shift — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler