Pitfall: Off-by-One When Reversing "Up To" a Character

The most frequent mistake comes from confusing the two framings of this problem. In the index-based version, k tells you how many characters to reverse, so you slice s[:k]. But in the character-based version (the actual LeetCode 2000 variant), you reverse the segment up to and including the first occurrence of a target character ch.

A very common bug is writing word[:idx] instead of word[:idx + 1]:

# WRONG: this excludes the target character from the reversal
idx = word.find(ch)
return word[:idx][::-1] + word[idx:]

For word = "abcdefd" and ch = "d", idx = 3. The correct answer reverses "abcd" to get "dcba" + "efd" = "dcbaefd". The buggy version reverses only "abc" and produces "cbadefd", silently giving the wrong result.

Solution: Always include the + 1 so the target character is part of the reversed prefix:

return word[:idx + 1][::-1] + word[idx + 1:]

Pitfall: Forgetting the "Character Not Found" Case

When using str.find, if ch does not exist in word, find returns -1. Plugging -1 directly into slicing leads to a subtle, hard-to-spot bug rather than a crash:

idx = word.find(ch)            # idx == -1 when not found
return word[:idx + 1][::-1] + word[idx + 1:]

Here idx + 1 becomes 0, so word[:0][::-1] is "" and word[0:] is the whole word — which happens to return the word unchanged by luck. However, relying on this accidental behavior is fragile, and if you ever wrote word[:idx] (without the +1), word[:-1] would chop off the last character incorrectly.

Solution: Handle the not-found case explicitly so the intent is clear and the code stays robust:

idx = word.find(ch)
if idx == -1:
    return word
return word[:idx + 1][::-1] + word[idx + 1:]

Pitfall: Assuming Negative k Behaves Like the Positive Case

For the index-based version, the code assumes k is non-negative. A negative k silently produces incorrect output because Python interprets it as an index from the end:

s = "abcdefg"
k = -2
# s[:-2] -> "abcde", s[-2:] -> "fg"
# result -> "edcbafg"  (not what "reverse first k" implies)

Solution: If negative or out-of-range input is possible in your context, clamp k before slicing:

k = max(0, min(k, len(s)))
return s[:k][::-1] + s[k:]

Pitfall: Trying to Reverse In-Place on a Python str

Coming from languages like C++ or Java, you might attempt to swap characters in place:

s[0], s[k-1] = s[k-1], s[0]   # TypeError: 'str' object does not support item assignment

Python strings are immutable, so this raises a TypeError.

Solution: Either use slicing as shown in the main solution, or convert to a list first if you truly need a two-pointer swap approach:

chars = list(s)
left, right = 0, k - 1
while left < right:
    chars[left], chars[right] = chars[right], chars[left]
    left, right = left + 1, right - 1
return "".join(chars)

This still runs in O(n) time and O(n) space, but makes the in-place mutation explicit and avoids the immutability trap.