索娜（Sona）和她10岁的女儿在她的房子里。她需要去学校带另一个孩子放学，因为下午2点学校结束了。外面很热，所以她想把年幼的孩子留在家中。

她给孩子们串了一串绳子，以使她不在的时候保持忙碌。她要求她扭转字符串中的单词。字符串很多，因此您需要帮助她的女儿解决这个艰巨的任务。

因此，给定包含以单个空格分隔的单词的字符串，请反转字符串中的单词。您可以假定那里没有前导或尾随空格。

该字符串仅包含[a-zA-z ]，因此您不需要处理标点符号。

将为您提供一个字符串作为输入，并且您应该输出一个字符串。

示例测试用例：

Input:
Man bites dog 

Output: 
dog bites Man


Input:
The quick brown fox jumps over the lazy dog

Output:
dog lazy the over jumps fox brown quick The


Input:
Hello world

Output:
world Hello

计分

这是代码高尔夫球。以字节为单位的最短答案将获胜。

视网膜，7字节

O$^`\w+

在线尝试！

匹配所有单词（\w+）并使用排序键空字符串（O$）对其进行排序，这意味着它们根本不会得到排序，然后颠倒其顺序（^）。

Haskell，21个字节

unwords.reverse.words

在线尝试！

Python 3，29个字节

print(*input().split()[::-1])

在线尝试！

JavaScript（ES6），31个字节

s=>s.split` `.reverse().join` `

试试吧

f=
s=>s.split` `.reverse().join` `
o.innerText=f(i.value="Man bites dog")
oninput=_=>o.innerText=f(i.value)

<input id=i><pre id=o>

Bash +通用Linux实用程序，21

printf "$1 "|tac -s\ 

在输出字符串中保留尾随空格-不确定是否可以。

R，19个字节

cat(rev(scan(,'')))

从标准输入中读取字符串。默认情况下，scan读取用空格/换行符分隔的标记，因此它将单词作为向量读取。rev反转并cat打印带有空格的元素。

在线尝试！

Brachylog，6个字节

ṇ₁↔~ṇ₁

在线尝试！

说明

ṇ₁        Split on spaces
  ↔       Reverse
   ~ṇ₁    Join with spaces

请注意，“在空间上分割”和“在空间上连接”都使用相同的内置函数ṇ₁，即仅在不同的“方向”上使用。

果冻，3个字节

ḲṚK

在线尝试！

说明：

Ḳ     Splits the input at spaces
Ṛ     Reverses the array
K     Joins the array, using spaces

C＃，58个字节

using System.Linq;s=>string.Join(" ",s.Split().Reverse());

brainfuck，74个字节

,[>++++[<-------->-],]<[>++++[->--------<]+>[[<]>[+>]<]<-[<]>[.>]<[[-]<]<]

在线尝试！

这段代码在两个不同的地方创建了数字-32，但是看起来比尝试维护单个-32的字节要少。

说明

,[                        input first character
  >++++[<-------->-]      subtract 32 from current character (so space becomes zero)
,]                        repeat for all characters in input
<                         go to last character of last word
[                         while there are more words to display:
 >++++[->--------<]       create -32 two cells right of last letter
 +>                       increment trailing space cell (1 right of last letter) so the next loop works
 [[<]>[+>]<]              add 32 to all cells in word and trailing space cell
 <-                       subtract the previously added 1 from the trailing space
 [<]>                     move pointer to beginning of word
 [.>]<                    output word (with trailing space)
 [[-]<]                   erase word
 <                        move to last character of previous word
]

C，54 48字节

使用参数作为输入，48个字节

main(c,v)char**v;{while(--c)printf("%s ",v[c]);}

在线尝试

> ./a.out man bites dog

使用指针，共84个字节

f(char*s){char*t=s;while(*t)t++;while(t-s){while(*t>32)t--;*t=0;printf("%s ",t+1);}}

使用

main(){ f("man bites dog"); }

贾普特，11 10 7 4字节

我第一次尝试Japt。

¸w ¸

在线尝试

• ETHproductions节省了3个字节

说明

    :Implicit input of string U
¸   :Split on <space>
w   :Reverse
¸   :Join with <space>

请在这里分享您的Japt提示。

Python 2，34个字节

lambda s:' '.join(s.split()[::-1])

在线尝试！

Pyth，4个字节

jd_c

在线尝试！

05AB1E，4个字节

#Rðý

注意：仅适用于2个或更多的单词。+1字节（如果这不正确）。

在线尝试！

PHP，47字节

<?=join(" ",array_reverse(explode(" ",$argn)));

在线尝试！

GNU Make，62个字节

$(if $1,$(call $0,$(wordlist 2,$(words $1),$1)) $(word 1,$1),)

Cubix，48个字节

几乎放弃了这一点，但终于到了。

oU_;SW;@?ABu>):tS-?;\0$q^s.$;;<$|1osU!(;;...<#(1

在线尝试！

这映射到边长为3的多维数据集，如下所示

      o U _
      ; S W
      ; @ ?
A B u > ) : t S - ? ; \
0 $ q ^ s . $ ; ; < $ |
1 o s U ! ( ; ; . . . <
      # ( 1
      . . .
      . . .

常规步骤是：

• 获取所有输入A和反向B堆栈
• 将底片q移到底部，0向堆栈添加一个计数器。在这里跳来跳去。
• 查找空间/结束循环，还将堆栈放置在正确的打印顺序中。
  • 递增计数器)并从堆栈中获取计数器项目t
  • 是空间还是EOI S-?
  • 如果没有，请重复
• 打印单词循环
  • 减量计数器 (
  • 如果计数器!U为0，则退出循环
  • 交换s具有字符堆栈的计数器
  • 打印o字符并从堆栈中弹出;
  • 重复循环
• 获取堆栈的长度 #并递减(
• 检查?是否为0并退出@是否为0
• 否则，请So清理空间;;并返回到第一个循环。

我已经跳过了许多多余的步骤，但是您可以逐步查看

Mathematica，35个字节

StringRiffle@Reverse@StringSplit@#&

在线尝试！

Röda，27 25字节

@fergusq节省了2个字节

{[[split()|reverse]&" "]}

在线尝试！

此功能从输入流中获取输入。

说明（过时）

{[[(_/" ")()|reverse]&" "]}           /* Anonymous function */
   (_/" ")                            /* Pull a value from the stream and split it on spaces */
          ()                          /* Push all the values in the resulting array to the stream */
            |reverse                  /* And reverse it */
  [                 ]                 /* Wrap the result into an array*/
                     &" "             /* Concatenate each of the strings in the array with a space */
 [                       ]            /* And push this result to the output stream */

欧姆，4个字节

z]Qù

在线尝试！

说明

z     Split the input on spaces.
 ]    Dump it onto the stack.
  Q   Reverse the stack.
   ù  Join the stack with spaces. Implicit output.

CJam，7个字节

qS/W%S*

在线尝试！

说明

q        e# Read input
 S/      e# Split on spaces
   W%    e# Reverse
     S*  e# Join with spaces

k，9个字节

" "/|" "\

在各种网络的浏览器中尝试一下！

     " "\ /split on spaces
    |     /reverse
" "/      /join with spaces

J，6个字节

|.&.;:

在线尝试！|.在（&.）字词（;:）下是反向（）。也就是说，将句子拆分为单词，将其反转，然后再次加入句子。

Gema，29个字符

<W><s>=@set{o;$1 ${o;}}
\Z=$o

样品运行：

bash-4.4$ gema '<W><s>=@set{o;$1 ${o;}};\Z=$o' <<< 'Man bites dog'
dog bites Man 

Java 8，62字节

s->{String r="";for(String x:s.split(" "))r=x+" "+r;return r;}

在这里尝试。

Java 7，77字节

String c(String s){String r="";for(String x:s.split(" "))r=x+" "+r;return r;}

在这里尝试。

Perl 6、14个字节

{~[R,] .words}

试试吧

展开：

{              # lambda with implicit param $_

  ~            # stringify following (joins a list using spaces)

   [R,]        # reduce the following using the Reverse meta operator

        .words # call the words method on $_
}

Java 8，53 57字节

Lambda +流API

s->Stream.of(s.split(" ")).reduce("",(a,b)->b+" "+a)

根据Selim的建议，我们只删除了4个字节

Vim，20个字节

:s/ /\r/g|g/^/m0<cr>vGJ

这比其他vim答案要短。

在线尝试！

Pyth，3个字节

_cw

我的第一个Pyth答案，比@notjagan的答案短一个字节！

解释：

 cw # Split the input by space (same as Python's string.split())
_   # Reverses the array
    # Pyth prints implicitly.