You are given a string s of length n made up of lowercase English letters.

You must perform exactly one operation. To do this, pick any integer k where 1 <= k <= n, and then do one of the following:

• Reverse the first k characters of s (the prefix of length k), or
• Reverse the last k characters of s (the suffix of length k).

After performing this single operation, return the lexicographically smallest string you can obtain.

A few important points to keep in mind:

• The operation is mandatory — you cannot skip it. However, choosing k = 1 reverses a single character, which leaves the string unchanged, so the original string is always achievable.
• You only reverse a prefix or a suffix, never a substring in the middle.
• "Lexicographically smallest" means the string that would come first in dictionary order. For example, "abc" is smaller than "acb" because at the first position where they differ, 'b' < 'c'.

For instance, if s = "dcab":

• Reversing the first k = 3 characters gives "acdb".
• Reversing the first k = 2 characters gives "cdab".
• Reversing the last k = 2 characters gives "dcba".

Among all possible choices of k and both directions (prefix or suffix), you need to find the smallest resulting string.

The first thing to notice is how limited the operation space actually is. For a string of length n, there are only n possible values of k, and for each k there are just two choices: reverse the prefix of length k or reverse the suffix of length k. That gives us at most 2n candidate strings in total.

When the number of possible outcomes is this small, the most natural idea is: why not just try them all? Instead of trying to be clever about predicting which reversal produces the smallest string, we can simply generate every candidate and compare them directly.

This brute-force mindset is justified here because:

• Each candidate string can be built in O(n) time using slicing and reversal.
• Comparing two strings lexicographically also takes O(n) time.
• With 2n candidates, the total work is O(n^2), which is perfectly acceptable for typical constraints on this problem.

One subtle point makes this approach airtight: the problem requires exactly one operation, but reversing a prefix or suffix of length k = 1 changes nothing. So the original string s itself is always among the reachable results — that's why we can safely initialize the answer as ans = s and only ever improve it.

Trying to reason analytically about which k is optimal (e.g., finding where the smallest character sits and reversing it to the front) is tempting, but it quickly gets messy with ties and edge cases. Exhaustive enumeration sidesteps all of that complexity: it is simple, obviously correct, and fast enough. When correctness is easy to guarantee and the input size permits it, enumeration is the right tool.

Pattern Learn more about Two Pointers and Binary Search patterns.

The solution uses enumeration (brute force) over all possible operations. We try every valid k from 1 to n, build both possible resulting strings for each k, and keep the smallest one seen so far.

Step-by-Step Walkthrough

Step 1: Initialize the answer.

ans = s

We start with ans = s because choosing k = 1 (reversing a single character) leaves the string unchanged, so s itself is always a valid outcome. This gives us a safe baseline to compare against.

Step 2: Enumerate every value of k.

for k in range(1, len(s) + 1):

We loop over all n possible choices of k. For each one, there are exactly two operations to consider.

Step 3: Build the candidate from reversing the prefix.

t1 = s[:k][::-1] + s[k:]

• s[:k] extracts the first k characters.
• [::-1] reverses that prefix.
• s[k:] keeps the rest of the string untouched.

Concatenating them gives the string after reversing the first k characters.

Step 4: Build the candidate from reversing the suffix.

t2 = s[:-k] + s[-k:][::-1]

• s[:-k] keeps the first n - k characters unchanged.
• s[-k:] extracts the last k characters, and [::-1] reverses them.

Concatenating them gives the string after reversing the last k characters.

Note: when k = n, the slice s[:-k] evaluates to the empty string, so t2 is simply the full reversal of s — Python's slicing handles this edge case cleanly without special treatment.

Step 5: Update the answer.

ans = min(ans, t1, t2)

Python's min compares strings lexicographically, which is exactly the ordering the problem asks for. After the loop ends, ans holds the smallest string among all 2n candidates (plus the original).

Full Code

class Solution:
    def lexSmallest(self, s: str) -> str:
        ans = s
        for k in range(1, len(s) + 1):
            t1 = s[:k][::-1] + s[k:]
            t2 = s[:-k] + s[-k:][::-1]
            ans = min(ans, t1, t2)
        return ans

Complexity Analysis

Let n be the length of s.

• Time complexity: O(n^2). The loop runs n times, and each iteration performs slicing, reversal, concatenation, and string comparison — each of these is O(n).
• Space complexity: O(n). At any moment we only hold a constant number of temporary strings (t1, t2, ans), each of length n.

Why This Works

The operation space is exhaustively covered: every legal move is "reverse a prefix of length k" or "reverse a suffix of length k" for some k in [1, n]. Since we generate all of these outcomes and take the minimum, the result is guaranteed to be optimal — there is no reachable string we could have missed.