Perform String Shifts - Practice Coding Problems

Perform String Shifts - Problem

String Shifting Challenge

You're tasked with implementing a string rotation system! Given a string s containing lowercase English letters and a series of shift operations, you need to perform all the transformations and return the final result.

Each shift operation is defined by a direction and amount:
• Left shift (0): Remove characters from the beginning and append them to the end
• Right shift (1): Remove characters from the end and prepend them to the beginning

For example, left shifting "abcde" by 2 gives "cdeab", while right shifting by 2 gives "deabc".

Think of it like a circular array where characters wrap around!

Input & Output

example_1.py — Basic Left and Right Shifts

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

› Output: "cab"

💡 Note: Left shift by 1: "abc" → "bca". Then right shift by 2: "bca" → "abc" → "cab". Alternatively, net shift = 1 - 2 = -1 (right shift by 1), so "abc" → "cab".

example_2.py — Multiple Operations

$ Input: s = "abcdefg", shift = [[1,1],[1,1],[0,2],[1,3]]

› Output: "efgabcd"

💡 Note: Net shift calculation: right(-1) + right(-1) + left(+2) + right(-3) = -1-1+2-3 = -3. Right shift by 3 is equivalent to left shift by 4. So we get s[4:] + s[:4] = "efg" + "abcd" = "efgabcd".

example_3.py — Large Shifts with Modulo

$ Input: s = "xqgwkiqpif", shift = [[1,4],[0,7],[0,8],[0,7],[0,6],[1,3],[0,1],[1,7],[0,5],[0,6]]

› Output: "qpifxqgwki"

💡 Note: With large shift amounts, we use modulo arithmetic. Net shift = -4+7+8+7+6-3+1-7+5+6 = 26. Since string length is 10, effective shift = 26 % 10 = 6. Result: s[6:] + s[:6].

Constraints

1 ≤ s.length ≤ 100
s only contains lower case English letters
1 ≤ shift.length ≤ 100
shift[i].length = 2
0 ≤ shift[i][0] ≤ 1
0 ≤ shift[i][1] ≤ 100

Visualization

Tap to expand

Understanding the Visualization

Circular Layout

Visualize string characters arranged in a circle

Calculate Net Movement

Combine all left/right operations into single rotation

Efficient Slicing

Use string slicing to achieve rotation in O(n) time

Key Takeaway

🎯 Key Insight: Instead of performing each shift operation individually, calculate the total net shift and perform one efficient string slicing operation, reducing complexity from O(n × shifts) to O(n + operations).

Asked in

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

The optimal solution uses mathematical optimization by calculating the net shift amount from all operations, then performing a single string rotation. This reduces time complexity from O(n × total_shifts) to O(n + m) where n is string length and m is number of operations.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Step by Step)	O(n × total_shift_amount)	O(n)	Perform each shift operation one character at a time
Optimized Single Calculation	O(n + m)	O(n)	Calculate net shift amount and perform one efficient rotation

Brute Force (Step by Step) — Algorithm Steps

Iterate through each shift operation
For left shifts: repeatedly move first character to end
For right shifts: repeatedly move last character to beginning
Continue until all operations are complete

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial String

Start with the original string

First Shift

Move characters according to first operation

Continue Shifts

Repeat for each remaining operation

Code -

solution.c — C

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

void leftShift(char* s) {
    int len = strlen(s);
    char first = s[0];
    for (int i = 0; i < len - 1; i++) {
        s[i] = s[i + 1];
    }
    s[len - 1] = first;
}

void rightShift(char* s) {
    int len = strlen(s);
    char last = s[len - 1];
    for (int i = len - 1; i > 0; i--) {
        s[i] = s[i - 1];
    }
    s[0] = last;
}

char* stringShift(char* s, int** shift, int shiftSize) {
    for (int i = 0; i < shiftSize; i++) {
        int direction = shift[i][0];
        int amount = shift[i][1];
        for (int j = 0; j < amount; j++) {
            if (direction == 0) {
                leftShift(s);
            } else {
                rightShift(s);
            }
        }
    }
    return s;
}

int main() {
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × total_shift_amount)

For each unit shift, we need O(n) time to move characters, and we might have many shifts

✓ Linear Growth

Space Complexity

O(n)

We create new strings for each operation

⚡ Linearithmic Space

28.4K Views

Medium Frequency

~15 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 (Step by Step) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler