304 North Cardinal St.
Dorchester Center, MA 02124

# Reverse Words in a String LeetCode Solution

## Problem – Reverse Words in a String

Given an input string `s`, reverse the order of the words.

word is defined as a sequence of non-space characters. The words in `s` will be separated by at least one space.

Return a string of the words in reverse order concatenated by a single space.

Note that `s` may contain leading or trailing spaces or multiple spaces between two words. The returned string should only have a single space separating the words. Do not include any extra spaces.

Example 1:

``````Input: s = "the sky is blue"
Output: "blue is sky the"``````

Example 2:

``````Input: s = "  hello world  "
Output: "world hello"

Example 3:

``````Input: s = "a good   example"
Output: "example good a"
Explanation: You need to reduce multiple spaces between two words to a single space in the reversed string.``````

Constraints:

• `1 <= s.length <= 104`
• `s` contains English letters (upper-case and lower-case), digits, and spaces `' '`.
• There is at least one word in `s`.

Follow-up: If the string data type is mutable in your language, can you solve it in-place with `O(1)` extra space?

### Reverse Words in a String LeetCode Solution in Java

``````public class Solution {

public String reverseWords(String s) {
if (s == null) return null;

char[] a = s.toCharArray();
int n = a.length;

// step 1. reverse the whole string
reverse(a, 0, n - 1);
// step 2. reverse each word
reverseWords(a, n);
// step 3. clean up spaces
return cleanSpaces(a, n);
}

void reverseWords(char[] a, int n) {
int i = 0, j = 0;

while (i < n) {
while (i < j || i < n && a[i] == ' ') i++; // skip spaces
while (j < i || j < n && a[j] != ' ') j++; // skip non spaces
reverse(a, i, j - 1);                      // reverse the word
}
}

// trim leading, trailing and multiple spaces
String cleanSpaces(char[] a, int n) {
int i = 0, j = 0;

while (j < n) {
while (j < n && a[j] == ' ') j++;             // skip spaces
while (j < n && a[j] != ' ') a[i++] = a[j++]; // keep non spaces
while (j < n && a[j] == ' ') j++;             // skip spaces
if (j < n) a[i++] = ' ';                      // keep only one space
}

return new String(a).substring(0, i);
}

// reverse a[] from a[i] to a[j]
private void reverse(char[] a, int i, int j) {
while (i < j) {
char t = a[i];
a[i++] = a[j];
a[j--] = t;
}
}

}
``````

### Reverse Words in a String LeetCode Solution in C++

``````class Solution {
public:

// function to reverse any part of string from i to j (just one word or entire string)
void reverseword(string &s, int i, int j){
while(i<j){
char t=s[i];
s[i++]=s[j];
s[j--]=t;
}
}

void reverseWords(string &s) {

int i=0, j=0;
int l=0;
int len=s.length();
int wordcount=0;

while(true){
while(i<len && s[i] == ' ') i++;  // skip spaces in front of the word
if(i==len) break;
if(wordcount) s[j++]=' ';
l=j;
while(i<len && s[i] != ' ') {s[j]=s[i]; j++; i++;}
reverseword(s,l,j-1);                // reverse word in place
wordcount++;

}

s.resize(j);                           // resize result string
reverseword(s,0,j-1);                  // reverse whole string
}
};
``````

### Reverse Words in a String LeetCode Solution in Python

``````class Solution(object):
def reverseWords(self, s):
arr = list(s)
self.reverse_string(arr, 0, len(arr)-1)
self.reverse_word(arr)
word = self.trim_sides(arr)
res = self.trim_space(word)
return ''.join(res)

def reverse_string(self, arr, l, r):
'''reverse a given string'''
while l < r:
arr[l], arr[r] = arr[r], arr[l]
l += 1 ; r -= 1
return arr

def reverse_word(self, arr):
'''reverse every words in a string'''
l, r = 0 , 0
while r < len(arr):
while r < len(arr) and not arr[r].isspace(): r += 1
self.reverse_string(arr, l, r-1)
r += 1; l = r
return arr

def trim_sides(self, arr):
'''str.strip() basically'''
if ''.join(arr).isspace(): return []
l , r = 0, len(arr) - 1
while l < r and arr[l].isspace(): l += 1
while l < r and arr[r].isspace(): r -= 1
return arr[l:r+1]

def trim_space(self, word):
'''remove duplicating space in a word'''
if not word: return []
res = [word[0]]
for i in range(1, len(word)):
if res[-1].isspace() and word[i].isspace(): continue
res.append(word[i])
return res
``````
##### Reverse Words in a String LeetCode Solution Review:

In our experience, we suggest you solve this Reverse Words in a String LeetCode Solution and gain some new skills from Professionals completely free and we assure you will be worth it.

If you are stuck anywhere between any coding problem, just visit Queslers to get the Reverse Words in a String LeetCode Solution

Find on LeetCode

##### Conclusion:

I hope this Reverse Words in a String LeetCode Solution would be useful for you to learn something new from this problem. If it helped you then don’t forget to bookmark our site for more Coding Solutions.

This Problem is intended for audiences of all experiences who are interested in learning about Data Science in a business context; there are no prerequisites.

Keep Learning!

More Coding Solutions >>

LeetCode Solutions

Hacker Rank Solutions

CodeChef Solutions