El objetivo de este desafío es recibir una entrada y salida de esa entrada pero con el orden de las oraciones invertido. Entrada de ejemplo:

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

Salida de ejemplo:

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

Como puede ver en los ejemplos, su programa tiene que lidiar con signos de interrogación, signos de exclamación y puntos. Puede suponer que cada oración tiene una puntuación y un espacio antes de la siguiente oración. Los espacios finales / líneas nuevas están bien, siempre y cuando sea legible. El código más corto gana.

¡Buena suerte!

EDITAR: puede suponer que las oraciones no tienen comillas ni paréntesis, pero si hace que su código sea capaz de lidiar con ambos, obtendrá -5 bytes Salida de ejemplo para 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.

Julia, 45 42 bytes - 5 bonus = 37

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

Esto crea una función anónima que acepta una cadena como entrada y devuelve la cadena con sus oraciones invertidas. Esto maneja cualquier carácter especial de manera apropiada, aunque se deben escapar las comillas dobles y los signos de dólar, de lo contrario no son cadenas válidas en Julia.

Ungolfed + explicación:

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

Ejemplos:

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."

Y si no le gusta mirar las comillas escapadas en la salida:

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.

¡Ahorré 3 bytes en la expresión regular gracias a Martin Büttner! Anteriormente, esta utiliza una búsqueda hacia atrás: (?<=[.?!]).

CJam, 23 22 bytes

No estoy seguro de si esto califica para el bono o no, pero aquí está la solución:

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

Expansión de código (poco anticuado) :

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

Pruébalo en línea aquí

J, 35 32

Casi maneja la entrada de bonificación, excepto que tengo que escapar de apóstrofes individuales, por lo que supongo que no cuenta. (Además, mi primera presentación aquí)

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

Uso:

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

Perl, 27/25

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

O desde la línea de comando:

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

PHP, 60

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

Bash + coreutils, 40 bytes

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

Esto se lee desde STDIN, por lo que la entrada puede redirigirse desde un archivo o simplemente canalizarse, por ejemplo:

$ 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. 
$ 

Pip , 25 bytes

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

Después de agregar un espacio a la cadena de entrada, encontramos todos los índices de ., ?y !, sumamos 2, y usamos el ^@operador de división para dividir la cadena en oraciones (cada una con un espacio final). Invierta la lista y se imprimirá automáticamente al final del programa. Voilà!

Ejemplo que muestra las etapas del cálculo principal con entrada 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! 

Retina , 61 34 33 30 bytes

Créditos a nutki por reducir esto en 24 bytes.

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

Donde se <empty>encuentra una línea vacía. Esto supone que #no es parte de la entrada, pero si eso no es legítimo, podría cambiarlo por cualquier otro personaje, incluido "(que solo tendría que manejar para la bonificación) o algo no imprimible. Puede ejecutar el código de esa manera en un solo archivo si usa la -sbandera, o puede poner cada línea en un archivo separado y pasarlas todas a Retina.

Revertir esto con un solo reemplazo de expresiones regulares es posible, pero realmente engorroso. Incluso con los grupos de equilibrio de .NET, necesitaba algo de alrededor de 90 bytes, así que intenté hacerlo en varios pasos.

En Retina, cada par de líneas es una etapa de reemplazo, donde la primera línea es el patrón y la segunda línea es el reemplazo.

^
#

Esta etapa simplemente prepara la cadena para su posterior procesamiento. Precede a #como un marcador. Este marcador indica que todo lo que está frente a él ya se ha colocado en el lugar correcto, y todo lo que queda después aún debe procesarse.

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

Esta etapa intercambia las oraciones, moviendo repetidamente la última oración frente a la #(que se mueve hacia adelante a través de la cadena en el proceso). Le +`indica a Retina que repita esta etapa hasta que la salida deje de cambiar. Como ejemplo, así es como foo. bar! blah?se procesaría la entrada :

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

Y finalmente simplemente eliminamos el marcador:

#
<empty>

Java, 113

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

JavaScript (ES6) 47 45

Como se dijo, es un simple ejercicio de expresiones regulares. En 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!"))
 

Pitón 2, 62

No va a mejorar la bonificación, ya que probablemente no valga la pena el costo del byte.

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

Matlab (93 bytes)

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

• Esto supone que la entrada no contiene espacios iniciales o finales
• Utiliza entrada y salida estándar
• Probado en Matlab 2014b

Rubí 41

Las otras respuestas de Ruby no tienen suficiente WTF.

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

Esto al menos funciona en Ruby 2. Si el interruptor ay Ffunciona en 1.8.7, supongo que podría caer$_= para guardar tres caracteres.

Invierte cada línea en stdin e imprime en stdout:

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

Ruby, 48 (42 sin los put) bytes

reverse_sentence.rb

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

Uso:

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

Salida:

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

Críticas más que bienvenidas.

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."

C # - LINQPAD - 93 - 5 = 88 bytes

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

Aplicación de consola C # 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()));}}

expresión regular descaradamente azotado de Alex A. :)

Clojure - 44 71 caracteres

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

RE mejorada y simplificada, elimina espacios en blanco innecesarios.

La salida es una secuencia de las oraciones en la cadena original, con el orden de las oraciones invertidas:

Entrada: "Hola amigo. ¿Qué estás haciendo? ¡Apuesto a que es algo que también quiero hacer!" Salida: ("¡Apuesto a que es algo que también quiero hacer!", "¿Qué estás haciendo?", "Hola amigo").

Ruby, 47

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

Créditos a Martin Büttner , por salvar algunos personajes.

CJam, 21 bytes

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

Esto funciona girando espacios después de !s, .sy? s en el número 1 (no el carácter 1 ni el carácter con el punto de código 1, por lo que la entrada aún puede contener esos), dividiendo en 1, invirtiendo el orden de los fragmentos resultantes y uniendo por espacios.

Pruébelo en línea en intérprete de CJam .

Cómo funciona

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)