Reverse String II

Updated on 04 July, 2025
Reverse String II header image

Problem Statement

The task is to manipulate a given string s based on an integer k. The string manipulation involves reversing specific parts of the string. Specifically, for every segment of 2k characters in the string:

  1. Reverse the first k characters.
  2. The next k characters remain unchanged.

However, if the length of the remaining part of the string is less than 2k but at least k, only the first k characters are reversed and the rest are left as they are. If the remaining characters are fewer than k, all of them are reversed. This procedure provides a new version of the string based on the specified rules.

Examples

Example 1

Input:

s = "abcdefg", k = 2

Output:

"bacdfeg"

Example 2

Input:

s = "abcd", k = 2

Output:

"bacd"

Constraints

  • 1 <= s.length <= 104
  • s consists of only lowercase English letters.
  • 1 <= k <= 104

Approach and Intuition

The solution to this problem involves repeated segments of the string based on the value of k. Here's a step-by-step approach:

  1. Initialize an empty string to collect the result.
  2. Use a loop to process each segment of up to 2k characters:
    • For the first half (k characters) of any complete 2k segment:
      • Reverse these k characters.
      • Append this reversed section to the result string.
    • For the second half (k characters) of the segment (if it exists):
      • Append these characters as they are to the result string.
  3. If a segment is less than 2k but at least k:
    • Reverse only the first k characters and leave the rest as original.
  4. If the segment is less than k:
    • Reverse all the characters in this segment.
  5. Continue this until the entire string has been processed.

This systematic approach allows the string to be manipulated exactly as specified, by treating it in discrete chunks and applying different rules based on the chunk's size relative to k.

Solutions

  • Java
java
class Solution {
    public String reverseStringK(String str, int k) {
        char[] charArray = str.toCharArray();
        for (int start = 0; start < charArray.length; start += 2 * k) {
            int left = start, right = Math.min(start + k - 1, charArray.length - 1);
            while (left < right) {
                char temp = charArray[left];
                charArray[left++] = charArray[right];
                charArray[right--] = temp;
            }
        }
        return new String(charArray);
    }
}

The provided Java solution defines a method reverseStringK that takes a string and an integer k as parameters. This method reverses every k characters in the string at alternately spaced intervals. Here's a brief rundown on how the function operates:

  • Convert the input string into a character array for mutable operations.
  • Iterate through the character array using a loop. The loop steps are set to 2 * k to ensure that every alternate block of k characters is reversed.
  • Inside the loop, use two pointers, left and right, initialized to frame the current block of characters to reverse (left at the starting position of the block and right at the minimum of start + k - 1 and the last index of the array).
  • A nested while loop swaps characters between the left and right pointers, effectively reversing the portion of the array between these pointers.
  • Convert the modified character array back to a string before returning it.

The method is efficient in reversing the specified portions of the string and preserves the order of characters outside of the specified boundaries. Make sure to use this function to handle strings where specific segments need to be reversed, seamlessly integrating into broader string manipulation tasks.

Comments

No comments yet.