DEV Community

Daily Challenge #263 - Reverse Words

dev.to staff on June 25, 2020

Complete the function that accepts a string parameter, and reverses each word in the string. All spaces in the string should be retained. Examples...

Read full post

Amin • Jun 25 '20 • Edited

Haskell

import Data.List.Split (split, oneOf)


reverseWords :: String -> String
reverseWords = concatMap reverse . split (oneOf " ")


main :: IO ()
main = do
    print $ reverseWords "One space"        -- "enO ecaps"
    print $ reverseWords "Two  spaces"      -- "owT  secaps"
    print $ reverseWords "Three   spaces"   -- "eerhT   secaps"

Oleksandr Riabukha • Jul 4 '20

Without libraries:
reverseWords = unwords . map reverse . words

Amin • Jul 4 '20 • Edited

This looks very clean, well done. I think I would have gone for that one if keeping spaces wasn't an issue, but it is in this challenge.

The second code example from this post is wrong in the sense that spaces must be kept, and only a few provided solutions here are working because the example was not clear enough on what was expected.

- "double spaces" ==> "elbuod secaps"
+ "double  spaces" ==> "elbuod  secaps"

I always lookup for the original challenge in Codewars to get a better specification to what I'm supposed to provide as a valid solution.

Original challenge specification.

Olek Ria • Jun 28 '20

Very elegant.

Andrea Stagi • Jun 25 '20

For Python, one line

def reverse_words(sentence: str) -> str:
    return ' '.join(sentence.split(' ')[::-1])[::-1]

Rafael Acioly • Jun 25 '20

Well done! It could also be

return ' '.join(word[::-1] for word in sentence.split() if not word.isspace())

Andrea Stagi • Jun 26 '20

Looks great :)

agtoever • Jun 30 '20

I think this would fail with doubles spaces in a sentence...

Andrea Stagi • Jun 30 '20 • Edited

That's true :( looks like the right implementation is

def reverse_words(sentence: str) -> str:
    return ' '.join(word[::-1] for word in sentence.split())

Rafael Acioly • Jun 30 '20

you don't need to use (' ') to split by spaces :)

Hayden Mankin • Jun 25 '20

Javascript

let reverseWords = (str) => str.replace(/\S+/g, word => [...word].reverse().join(""));

console.log(reverseWords("The quick brown fox jumps over the lazy dog.")); // ehT kciuq nworb xof spmuj revo eht yzal .god
console.log(reverseWords("double spaced words")); // elbuod decaps sdrow
console.log(reverseWords("🞀🞁🞂🞃")); // 🞃🞂🞁🞀

I avoided split("") as it breaks with non BMP characters. The spread operator works just as well for splitting strings into individual characters and won't break astral characters.

Notice how if I use split the output is messed up on my last test case.

let reverseWords = (str) => str.replace(/\S+/g, word => word.split("").reverse().join(""));

console.log(reverseWords("The quick brown fox jumps over the lazy dog.")); // ehT kciuq nworb xof spmuj revo eht yzal .god
console.log(reverseWords("double spaced words")); // elbuod decaps sdrow
console.log(reverseWords("🞀🞁🞂🞃")); // �🞂🞁🞀�

Thai Nguyen Hung • Jun 26 '20

For php

function reverseWords($words) {
    $pattern = '/\S+/';
    return preg_replace_callback(
        $pattern,
        function ($word) {
            return strrev($word[0]);
        },
        $words
    );
}

echo reverseWords('The quick brown fox jumps over the lazy dog.');
echo reverseWords('double spaced words');

peter279k • Jul 2 '20 • Edited

Here are the PHP codes about using foreach and for loops to complete:

function reverseWords($str) {
  $strArray = explode(' ', $str);
  $reveresedArray = [];

  foreach($strArray as $string) {
    $reversedStr = '';
    for($index=strlen($string)-1; $index>=0; $index--) {
       $reversedStr .= $string[$index];
    }

    $reversedArray[] = $reversedStr;
  }

  return implode(' ', $reversedArray);
}

Boris Quiroz • Jun 25 '20

More python:

def reverseWords(words):
    r = ""
    for word in words.split():
        r += "{} ".format(word[::-1])

    print(r)

reverseWords("The quick brown fox jumps over the lazy dog.")
reverseWords("double spaced words")

Sam Ferree • Jun 25 '20

Befunge-93

This version current works if the end of input pushes -1 on the stack (due to the interpreter I used), change 3 characters and it works for a carriage return

0v
 >~:01--!#v_:84*-!   #v_
 ^        >$84*>,:#v_@>,:#v_
               ^   <  ^   <

Kieran Pilkington • Jun 25 '20

Or more simply:

def reverse_words(str)
  str.split.map(&:reverse).join(" ")
end

Dan Couper • Jun 26 '20 • Edited

JavaScript (imperative & linear):

function reverseWords(str) {
  let wordbuf = "";
  let outbuf = "";

  for (let char of str) {
    // NOTE replace with `if (/\s/.test(char))`
    // if anything other than ASCII whitespace
    // char expected
    if (char === " ") {
      outbuf += (wordbuf + char);
      wordbuf = "";
    } else {
      wordbuf = char + wordbuf;
    }
  }
  outbuf += wordbuf;

  return outbuf;
}

Hans5958 • Jun 29 '20 • Edited

JavaScript (ES6) (golf)

const reverseWords = i=>i.split` `.map(w=>w.split``.sort(_=>1).join``).join` `

const reverseWords = i=>i.replace(/\w+/g,w=>[...w].sort(_=>1).join``)

Chris Garrett • Jun 26 '20

ES6:

const reverseWords = (sentence) =>
  sentence
    .split(" ")
    .map((word) => [...word].reverse().join(""))
    .join(" ");

console.log(reverseWords("This is an example!"));
console.log(reverseWords("double  spaces"));

Dom Hastings • Jun 26 '20

Perl:

#!perl -040pl
$_=reverse

Try it online!

Shivam Gupta • Jun 29 '20

For Java

public static String reverseWords(final String original)
  {
     String[] arr=original.split(" ");
     if(arr.length==0)
       return original;
     String result="";
     for(String word:arr){
         StringBuilder input = new StringBuilder();
         result+=input.append(word).reverse().toString()+" ";
     }

     return result.trim();
  }

Dave Hackett • Jun 25 '20

For Elixir

defmodule Challenge do
  def reverse_words(words) do
    words
    |> String.split(" ", trim: false)
    |> Enum.map(&String.reverse/1)
    |> Enum.join(" ")
  end
end

agtoever • Jun 30 '20

Another Python:

def reverse_words(s):
 for word in s.split():
  s = s.replace(word, word[::-1])
 return s

Try it online!

Mike Talbot ⭐ • Jun 25 '20

function reverseWords(str) {
    return str.replace(/[^\s]+/g, v=>v.split('').reverse().join(''))
}

saswat • Jun 25 '20

Simple python example:

Shriji • Jun 25 '20

Java Script

let reverseWords = (str) => str.split('').reverse().join('');
console.log(reverseWords(`This is an example!`)); // sihT si na !elpmaxe

Prashant Chaudhari • Jun 25 '20

JavaScript :

function reverseWords(str) {
  return str.split(" ").map(word => word.split("").reverse().join("")).join(" ")
}

vebss • Jun 25 '20

Python one-liner:

def reverse_words(text):
  return ' '.join(word[::-1] for word in text.split(" "))

jp3492 • Jun 26 '20

JS:
str.split(" ").map(w => w.split("").reverse().join("")).join(" ")

Imran Shaikh • Jun 25 '20 • Edited

// JavaScript
function reverseWord(word){
return word.split("").reverse().join('');
}

Imran Shaikh • Jun 25 '20

// JavaScript
const reverseWord = word => word.split("").reverse().join('');