> For the complete documentation index, see [llms.txt](https://joshualbarb.gitbook.io/leetcode-problems/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://joshualbarb.gitbook.io/leetcode-problems/strings/string-simulation/reverse-string.md).

# Reverse String

String Simulation

## Problem

Write a function that reverses a string. The input string is given as an array of characters `char[]`.

Do not allocate extra space for another array, you must do this by **modifying the input array** [**in-place**](https://en.wikipedia.org/wiki/In-place_algorithm)with O(1) extra memory.

You may assume all the characters consist of [printable ascii characters](https://en.wikipedia.org/wiki/ASCII#Printable_characters).

{% hint style="info" %}
For example:

```
Input: ["h","e","l","l","o"]
Output: ["o","l","l","e","h"]
```

```
Input: ["H","a","n","n","a","h"]
Output: ["h","a","n","n","a","H"]
```

{% endhint %}

### Thought Process

* You can use 2 pointer approach
* You can also do recursive approach but this will take more space

## Solution

{% tabs %}
{% tab title="2-pointer approach" %}

```
class Solution:
    def reverseString(self, s: List[str]) -> None:
        """
        Do not return anything, modify s in-place instead.
        """
        left, right = 0, len(s)-1
        while(left<right):
            s[left], s[right] = s[right], s[left]
            left+=1
            right-=1
        return s
        
```

{% endtab %}

{% tab title="Recursive Approach" %}

```
class Solution:
    def reverseString(self, s: List[str]) -> None:
        """
        Do not return anything, modify s in-place instead.
        """
        self.revString(s, 0)
        
    def revString(self, s, i):
        
        n = len(s)
        
        if i == n//2:
            return 
        s[i], s[n-i-1] = s[n-i-1], s[i]
        self.revString(s, i+1)
```

{% endtab %}
{% endtabs %}

## Time Complexity

* **Time:** O(n) for both 2 pointer and recursive
* **Space:** O(1) for 2 pointer but O(n) for recursive because of call stack