挑战的目标是接收输入并输出该输入，但句子顺序相反。输入示例：

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.

从示例中可以看出，您的程序必须处理问号，感叹号和句点。您可以假设每个句子都有标点符号，而下一个句子之前没有空格。只要可读即可，尾随空格/换行符就可以。最短的代码获胜。

祝好运！

编辑：您可以假定句子中没有引号或括号，但是如果您使代码能够处理这两个词，则将得到-5字节 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.

朱莉娅，45 42字节-5奖励= 37

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

这将创建一个匿名函数，该函数接受字符串作为输入并返回其句子颠倒的字符串。尽管双引号和美元符号必须转义，但这可以适当地处理任何特殊字符，否则它们在Julia中不是有效的字符串。

取消+说明：

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

例子：

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

如果您不喜欢查看输出中的转义引号：

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.

感谢MartinBüttner，在正则表达式上节省了3个字节！以前，此操作使用了回首：(?<=[.?!])。

CJam，23 22字节

我不确定这是否符合赠金条件，但是解决方法如下：

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

代码扩展（位已过期）：

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

在这里在线尝试

J，35 32

它几乎可以处理奖金输入，除了我必须转义单个撇号之外，因此我认为它不算在内。（也是我在这里的第一次提交）

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

用法：

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

或从命令行：

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

PHP，60

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

Bash + coreutils，40个字节

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

这是从STDIN读取的，因此输入可以从文件重定向或直接通过管道输入，例如：

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

点，25字节

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

追加一个空格输入字符串后，我们发现所有的指标.，?和!，加2，并使用^@分在运营商打破字符串转换成句子（每一个空格）。反转列表，它将在程序末尾自动打印。瞧！

显示带有输入的主要计算阶段的示例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! 

视网膜，61 34 33 30字节

感谢nutki将其缩减了24个字节。

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

凡<empty>代表空行。假设这#不是输入的一部分，但是如果这是不合法的，我可以将其换成其他任何字符，包括"（我只需要处理这笔奖金）或一些无法打印的字符。如果您使用以下代码，则可以在单个文件中运行类似的代码-s标志，，也可以将每一行放在单独的文件中，然后将它们全部传递给Retina。

可以用一次正则表达式替换来扭转这种情况，但是确实很麻烦。即使使用.NET平衡组，我也需要大约90个字节，因此我尝试分多个步骤进行。

在视网膜中，每对线都是一个替换阶段，其中第一行是图案，第二行是替换。

^
#

此阶段仅准备字符串以进行进一步处理。它以a #作为标记。此标记表明它前面的所有内容都已经放置在正确的位置，并且仍然需要对其进行处理。

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

这个阶段通过重复移动最后一个句子#（在过程中向前移动字符串）来交换句子。该+`指示视网膜直到输出停止变化重复这个阶段。例如，以下是输入的foo. bar! blah?处理方式：

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

最后，我们只需删除标记：

#
<empty>

爪哇，113

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

JavaScript（ES6）47 45

如前所述，这是一个简单的正则表达式练习。在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!"))
 

Python 2，62

奖金不会提高，因为这可能不值得字节成本。

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

Matlab（93字节）

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

• 假设输入不包含前导或尾随空格
• 使用标准输入和输出
• 在Matlab 2014b中测试

红宝石41

其他的Ruby答案没有足够的WTF。

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

这至少在Ruby 2中有效。如果aand F开关在1.8.7中有效，我想您可以删除$_=以保存三个字符。

反转标准输入上的每一行并打印到标准输出：

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

Ruby，48（不包含puts）的42个字节

reverse_sentence.rb

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

用法：

ruby reverse_sentence.rb '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.

批评超过欢迎。

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字节

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

C＃控制台应用程序189-5 = 184字节

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

regex从Alex A毫不知情地散布。:)

Clojure-44 71个字符

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

改进并简化了RE，消除了不必要的空白。

输出是原始字符串中句子的序列，句子的顺序相反：

输入：“你好朋友。你在做什么？我敢打赌，这也是我想做的事！” 输出：（“我敢打赌这也是我想做的事！”“你在做什么？”“你好朋友。”）

Ruby，47岁

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

学分马丁布特内尔，保存一些字符。

CJam，21个字节

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

通过将!s，.s和?s 之后的空格变为数字1（而不是字符 1或代码点为1的字符，因此输入仍可以包含这些字符），在1处进行拆分，反转结果块的顺序并进行连接，可以起作用按空格。

在中在线尝试 CJam解释器中。

怎么运行的

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)