Reverse sentences

Question

The goal of this challenge is to receive an input and output that input but with sentence order reversed. Example Input:

Hello friend. What are you doing? I bet it is something I want to do too!

Example Output:

I bet it is something I want to do too! What are you doing? Hello friend.

As you can tell from the examples, your program has to deal with question marks, exclamation points, and periods. You can assume each sentence has a punctuation and than a space before the next sentence. Trailing spaces/newlines are ok, as long as it is readable. Shortest code wins.

Good luck!

EDIT: You can assume the sentences has no quotes or parentheses, but if you make your code be able to deal with both of those then you get -5 bytes Example output for parens/quotes:

"Hello, " she said. (I didn't know what she was talking about.) --> (I didn't know what she was talking about.) "Hello, " she said.

Answer 1

Julia, 45 42 bytes - 5 bonus = 37

s->join(reverse(split(s,r"[.?!]\K "))," ")

This creates an anonymous function that accepts a string as input and returns the string with its sentences reversed. This handles any special character appropriately, though double quotes and dollar signs must be escaped, otherwise they aren't valid strings in Julia.

Ungolfed + explanation:

function f(s)
    # Get individual sentences by splitting on the spaces that
    # separate them. Spaces are identified by matching punctuation
    # then moving the position beyond that match and matching a
    # space. This is accomplished using \K.

    sentences = split(s, r"[.?!]\K ")

    # Reverse the order of the array of sentences.

    reversed_order = reverse(sentences)

    # Join the array elements into a string, separated by a space.

    join(reversed_order, " ")
end

Examples:

julia> f("Hello friend. What are you doing? I bet it is something I want to do too!")
"I bet it is something I want to do too! What are you doing? Hello friend."

julia> f("\"Hello, \" she said. (I didn't know what she was talking about.)")
"(I didn't know what she was talking about.) \"Hello, \" she said."

And if you don't like looking at the escaped quotes in the output:

julia> println(f("\"Hello, \" she said. (I didn't know what she was talking about.)"))
(I didn't know what she was talking about.) "Hello, " she said.

Saved 3 bytes on the regular expression thanks to Martin Büttner! Previously this used a lookbehind: (?<=[.?!]).

Answer 2

CJam, 23 22 bytes

I am not sure if this qualifies for the bonus or not, but here goes the solution:

Sq{1$".?!"-{])[}|}%]W%

Code Expansion (bit outdated):

Sq+                      e# Read the input and prepend with a space
   {            }%       e# For each input character
    _".?!"&              e# Copy and check if its one of ., ? and !
           {][}&         e# If it is one of the above, wrap everything till now in an array
                         e# and start a new array to be wrapped next time we get one of those
                         e# three characters. We now have an array of strings, each having
                         e# a single sentence
                  W%     e# Reverse the ordering of these sentences
                    s(   e# Convert to string and remove the first space

Try it online here

Answer 3

J, 35 32

It almost handles bonus input, except I have to escape single apostrophes, so I guess it doesn't count. (Also, my first submission here)

f=.;@|.@(]<;.2~'.?!'e.~])@,~&' '

Usage:

f 'Hello friend. What are you doing? I bet it is something I want to do too!'

Answer 4

Perl, 27/25

#!perl -n
print reverse/ |[^.!?]*./g

Or from the command line:

$perl -nE'say reverse/ |[^.!?]*./g'

Answer 5

PHP, 60

echo join(' ',array_reverse(preg_split('/(?<=[?!.])/',$s)));

Answer 6

Bash + coreutils, 40 bytes

sed 's/\([?.!]\) */\1\n/g'|tac|tr \\n \ 

This reads from STDIN so input may me redirected in from a file, or simply piped in, e.g.:

$ printf 'Hello friend. What are you doing? I bet it is something I want to do too!' | sed 's/\([?.!]\) */\1\n/g'|tac|tr \\n \ 
I bet it is something I want to do too! What are you doing? Hello friend. 
$ 

Answer 7

Pip, 25 bytes

a.:sRV(a^@2+$ALa@*^".?!")

After appending a space to the input string, we find all indices of ., ?, and !, add 2, and use the ^@ split-at operator to break the string into sentences (each with a trailing space). Reverse the list, and it's auto-printed at the end of the program. Voilà!

Example showing the stages of the main computation with input A! B? C. D!:

              ^".?!"     ["." "?" "!"]
           a@*           [[7] [4] [1 10]]
        $AL              [7 4 1 10]
      2+                 [9 6 3 12]
   a^@                   ["A! " "B? " "C. " "D! "]
RV(                 )    ["D! " "C. " "B? " "A! "]

                         D! C. B? A! 

Answer 8

Retina, 61 34 33 30 bytes

Credits to nutki for cutting this down by 24 bytes.

^
#
+`(#.*[.!?]) (.+)
$2 $1
#
<empty>

Where <empty> stands for an empty line. This assumes that # is not part of the input, but if that's not legitimate, I could swap it out for any other character, including " (which I'd only need to handle for the bonus) or something unprintable. You can run the code like that in a single file if you use the -s flag, or you can put each line in a separate file and pass them all to Retina.

Reversing this with a single regex replacement is possible, but really cumbersome. Even with .NET balancing groups I needed something around 90 bytes, so instead I tried doing it in multiple steps.

In Retina, every pair of lines is one replacement stage, where the first line is the pattern and the second line is the replacement.

^
#

This stage simply prepares the string for further processing. It prepends a # as a marker. This marker indicates that everything in front of it has already been put in the right place, and everything after it still needs to be processed.

+`(#.*[.!?]) (.+)
$2 $1

This stage swaps the sentences, by repeatedly moving the last sentence in front of the # (which moves forwards through the string in the process). The +` instructs Retina to repeat this stage until the output stops changing. As an example, here is how the input foo. bar! blah? would be processed:

#foo. bar! blah?
blah? #foo. bar!
blah? bar! #foo.

And finally we simply remove the marker:

#
<empty>

Answer 9

Java, 113

s->{String t[]=s.split("(?<=[\\.?!]) "),u="";for(int i=t.length;i-->0;)u+=t[i]+" ";return u.replaceAll(".$","");}

Answer 10

JavaScript (ES6) 47 45

As it's stated, it's a simple regex exercise. In javascript:

// ES6 - FireFox only
F=t=>t.match(/\S[^.!?]+./g).reverse().join(' ')

// ES5 - so much longer
function G(t){return t.match(/\S[^.!?]+./g).reverse().join(' ')}

// TEST

alert(G("Hello friend. What are you doing? I bet it is something I want to do too!"))
 

Answer 11

Python 2, 62

Not going to improve for the bonus, as it's probably not worth the byte cost.

import re
print' '.join(re.split('(?<=[?!.]).',input())[::-1])

Answer 12

Matlab (93 bytes)

y=[32 input('','s')];y=sortrows([cumsum(ismember(y,'?!.'),'reverse');y]',1)';disp(y(4:2:end))

• This assumes the input doesn't contain leading or trailing spaces
• Uses standard input and output
• Tested in Matlab 2014b

Answer 13

Ruby 41

The other Ruby answers don't have enough WTF.

#!ruby -apF(?<=[.!?])\s
$_=$F.reverse*" "

This at least works in Ruby 2. If the a and F switch works in 1.8.7, I guess you could drop $_= to save three characters.

Reverses every line on stdin and print to stdout:

$ ruby foo.rb <<< "Hello. Hi. How are you? Good, you? fine, thanks."
fine, thanks. Good, you? How are you? Hi. Hello.

Answer 14

Ruby, 48(42 without the puts) bytes

reverse_sentence.rb

puts $*[0].scan(/\S[^.!?]+./).reverse.join(" ")

Usage:

ruby reverse_sentence.rb 'Hello friend. What are you doing? I bet it is something I want to do too!'

Output:

I bet it is something I want to do too! What are you doing? Hello friend.

Criticism more than welcome.

Answer 15

k, 31

{1_,/|(0,1+&x in"?!.")_x:" ",x}

.

k){1_,/|(0,1+&x in"?!.")_x:" ",x} "Hello friend. What are you doing? I bet it is something I want to do too!"
"I bet it is something I want to do too! What are you doing? Hello friend."

Answer 16

C# - LINQPAD - 93 - 5 = 88 bytes

void Main(){string.Join(" ",Regex.Split(Console.ReadLine(),"(?<=[.?!]) ").Reverse()).Dump();}

C# Console App 189 - 5 = 184 bytes

using System;using System.Linq;using System.Text.RegularExpressions;class P{static void Main(){Console.WriteLine(string.Join(" ",Regex.Split(Console.ReadLine(), "(?<=[.?!]) ").Reverse()));}}

regex shamelessly flogged from Alex A. :)

Answer 17

Clojure - 44 71 chars

(defn rs[s](reverse(re-seq #"\S.+?[.!?]"s)))

Improved and simplified RE, eliminated unnecessary whitespace.

Output is a sequence of the sentences in the original string, with the order of the sentences reversed:

Input: "Hello friend. What are you doing? I bet it is something I want to do too!" Output: ("I bet it is something I want to do too!" "What are you doing?" "Hello friend.")

Answer 18

Ruby, 47

$><<gets.strip.split(/(?<=[.?!]) /).reverse*' '

credits to Martin Büttner, for saving some characters.

Answer 19

CJam, 21 bytes

1q{1?_"!.?"-}%1a/W%S*

This works by turning spaces after !s, .s and ?s into the number 1 (not the character 1 nor the character with code point 1, so the input can still contain those), splitting at 1's, reversing the order of the resulting chunks and joining by spaces.

Try it online in the CJam interpreter.

How it works

1                     e# B := 1
 q                    e# Q := input()
  {         }%        e# for each C in Q (map):
   1?                 e#   C := B ? C : 1
     _"!.?"-          e#   B := string(C).strip("!.?")
              1a/     e# Q := Q.split([1])
                 W%   e# Q := reverse(Q)
                   S* e# Q := Q.join(" ")
                      e# print(Q)