Reverse String II - Practice Coding Problems

Reverse String II - Problem

Given a string s and an integer k, reverse the first k characters for every 2k characters counting from the start of the string.

Rules:

If there are fewer than k characters left, reverse all of them.
If there are less than 2k but greater than or equal to k characters, then reverse the first k characters and leave the other as original.

Return the modified string.

Input & Output

Example 1 — Basic Case

$ Input: s = "abcdefg", k = 2

› Output: "bacdfeg"

💡 Note: First 2k=4 chars: reverse "ab" → "ba", keep "cd". Next chunk: reverse "ef" → "fe", keep "g". Result: "bacdfeg"

Example 2 — Exact Multiple

$ Input: s = "abcd", k = 2

› Output: "bacd"

💡 Note: String length equals 2k=4. Reverse first k=2 characters "ab" → "ba", keep remaining "cd". Result: "bacd"

Example 3 — Short String

$ Input: s = "a", k = 2

› Output: "a"

💡 Note: String length (1) is less than k=2, so reverse all characters. Single character "a" reversed is still "a"

Constraints

1 ≤ s.length ≤ 10⁴
s consists of only lowercase English letters
1 ≤ k ≤ 10⁴

Visualization

Tap to expand

Understanding the Visualization

Input

String s and integer k define the reversal pattern

Process

Divide into 2k chunks, reverse first k of each

Output

Modified string with selective reversals

Key Takeaway

🎯 Key Insight: Process string in 2k chunks, applying two pointers reversal only to the first k characters of each chunk

Asked in

G Google 25 a Amazon 30 f Facebook 15 Apple 10

The key insight is to process the string in chunks of 2k characters, reversing only the first k characters of each chunk. The two pointers approach is optimal, using left and right pointers to efficiently swap characters in-place. Time: O(n), Space: O(n).

Common Approaches

Approach	Time	Space	Notes
✓ Two Pointers Approach	O(n)	O(n)	Use two pointers to efficiently reverse k-character segments
Brute Force String Building	O(n)	O(n)	Build result string character by character with conditional reversal
Optimized Substring Processing	O(n)	O(n)	Process string by directly manipulating substrings with built-in reverse functions

Two Pointers Approach — Algorithm Steps

Step 1: Convert string to mutable character array
Step 2: Iterate through string in 2k steps
Step 3: Use two pointers to reverse first k characters of each chunk
Step 4: Join characters back into string

Code -

solution.c — C

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

void reverseSubstring(char* s, int left, int right) {
    while (left < right) {
        char temp = s[left];
        s[left] = s[right];
        s[right] = temp;
        left++;
        right--;
    }
}

char* solution(char* s, int k) {
    int n = strlen(s);
    char* result = malloc((n + 1) * sizeof(char));
    strcpy(result, s);
    
    for (int i = 0; i < n; i += 2 * k) {
        // Two pointers to reverse first k characters
        int left = i;
        int right = (i + k - 1 < n - 1) ? i + k - 1 : n - 1;
        reverseSubstring(result, left, right);
    }
    
    return result;
}

int main() {
    char s[10001];
    int k;
    
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    scanf("%d", &k);
    
    char* result = solution(s, k);
    printf("%s\n", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through string, each character processed once

✓ Linear Growth

Space Complexity

O(n)

Character array to store mutable version of string

⚡ Linearithmic Space

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