The problem requires reversing the first k characters for every 2k characters in a string. If there are fewer than k characters left, reverse all of them. If there are between k and 2k characters left, reverse the first k and leave the rest as is.
Steps
- Convert the string into a character array (if needed).
- Iterate over the array in steps of
2k. - At each step, reverse the next
kcharacters if available. - Join or return the modified string.
Dry Run
Input: s = "abcdefg", k = 2
- First 2k = 4 chars: reverse first 2 →
"bacd" - Remaining = “efg”: reverse first 2 →
"fe", keep “g” - Output:
"bacdfeg"
Time & Space Complexity
- Time Complexity: O(n), where n = length of the string
- Space Complexity: O(1) if in-place, else O(n)
var reverseStr = function (s, k) {
s = s.split("")
for (let x = 0; x < s.length; x = x + (2 * k)) {
let n = Math.min(k, s.length - x)
let mid = Math.floor(n / 2)
for (let i = 0; i < mid; i++) {
let temp = s[x + i]
s[x + i] = s[x + n - 1 - i]
s[x + n - 1 - i] = temp
}
}
return s.join("")
};
#include <iostream>
#include <string>
#include <algorithm>
using namespace std;
string reverseStr(string s, int k) {
for (int i = 0; i < s.length(); i += 2 * k) {
int end = min(i + k, (int)s.length());
reverse(s.begin() + i, s.begin() + end);
}
return s;
}
#include <stdio.h>
#include <string.h>
void reverse(char* s, int start, int end) {
while (start < end) {
char temp = s[start];
s[start] = s[end];
s[end] = temp;
start++;
end--;
}
}
void reverseStr(char* s, int k) {
int len = strlen(s);
for (int i = 0; i < len; i += 2 * k) {
int end = (i + k < len) ? i + k - 1 : len - 1;
reverse(s, i, end);
}
}
public class Solution {
public String reverseStr(String s, int k) {
char[] arr = s.toCharArray();
for (int i = 0; i < arr.length; i += 2 * k) {
int left = i;
int right = Math.min(i + k - 1, arr.length - 1);
while (left < right) {
char temp = arr[left];
arr[left] = arr[right];
arr[right] = temp;
left++;
right--;
}
}
return new String(arr);
}
}
def reverseStr(s: str, k: int) -> str:
s = list(s)
for i in range(0, len(s), 2 * k):
s[i:i + k] = reversed(s[i:i + k])
return ''.join(s)
