在聊天时，我们往往快typers和真的不看顺序的字母发布消息前。由于我们很懒，因此我们需要一个程序来自动交换单词中的最后两个字母，但是由于我们不想响应太晚，因此代码必须简短。

您的任务（如果希望接受它）是编写一个程序，该程序翻转给定字符串中每个单词的最后两个字母（因此单词Thansk变成Thanks）。一个字是在英文字母的分隔的两个或多个字母序列的单一空间。

• 您确保输入的字符串/ 字符列表仅包含字母字符和空格（ASCII [97-122]，[65-90]和32）。

• 您可以使用任何编程语言，通过任何标准方法输入和提供输出，同时请注意，默认情况下，这些漏洞是禁止的。

• 输出可能有一个尾随空格和/或一个尾随换行符。

• 输入将始终仅包含单词（和相应的空格），并将至少包含一个单词。

这是代码高尔夫，因此每种语言的最短提交（以字节计）将获胜！

测试用例

请注意，字符串用引号引起来，以提高可读性。

输入->输出

“谢谢”->“谢谢”
“ Youer welcoem”->“不客气”
“这是一个苹果”->“这是苹果”
“ Flippign Lettesr Aroudn”->“翻转字母”
“具有可互换字母的奇制”->“具有可互换字母的奇制”

或者，为了方便测试套件，以下分别是输入及其对应的输出：

坦斯克
Youer welcoem
这是一个苹果
Flippign Lettesr Aroudn
带有可替换字母的胆小包

谢谢
别客气
思娜娜·阿佩尔
翻转字母
交换字母的奇特挑战

感谢DJMcMayhem的标题。这最初是CMC。

V，4 5字节

òeXp

在线尝试！

|| 表示光标

缓冲区以开头，|w|ord and more words光标位于第一个字符上。

递归地 ò

去到e一个单词的第二

wor|d| and more words

删除X光标左侧的字符

wo|d| and more words

p把它放在下一个字符上

wod|r| and more words

隐式结束ò，对其他单词重复相同的过程，直到到达缓冲区的末尾

果冻，7 个字节

Ḳœ?@€2K

单子链接，用于获取和返回字符列表

在线尝试！

怎么样？

Ḳœ?@€2K - Link: list of characters
Ḳ       - split at spaces
     2  - literal two
    €   - for €ach:
   @    -   with sw@pped arguments:
 œ?     -     nth permutation (the 2nd permutation has the rightmost elements swapped)
      K - join with spaces

Brain-Flak，122字节

{(({})[((((()()){}){}){}){}])((){[()](<{}>)}{}){{}<>(({}({}))[({}[{}])])(<>)}{}({}<>)<>}<>(({}({}))[({}[{}])]){({}<>)<>}<>

在线尝试！

最糟糕的工作语言：)

可读稍微更可读的版本：

{
    (({})[((((()()){}){}){}){}])((){[()](<{}>)}{})

    {
        {}
        <>

        (({}({}))[({}[{}])])

        (<>)
    }
    {}

    ({}<>)<>

}<>

(({}({}))[({}[{}])])

{

    ({}<>)
    <>
}<>

Haskell，40个字节

(f=<<).words
f[a,b]=b:a:" "
f(x:r)=x:f r

在线尝试！用法示例：(f=<<).words $ "abc xyz"yields "acb xzy "。

视网膜，13字节

(.)(.)\b
$2$1

在线尝试！链接包括测试用例。

Python 3，50个字节

print(*(w[:-2]+w[:-3:-1]for w in input().split()))

在线尝试！

这个答案滥用了Python 3的打印行为：打印了多个参数，它们之间有一个空格。当然，我们不能只给它多个参数，因为我们不知道输入中将有多少个单词。因此，我们使用splat运算符。基本上

print(*[a,b,c])

与...完全一样

print(a,b,c)

滥用使得完整的程序比我们必须使用的函数/ lambda ' '.join或类似函数短。

Matlab（R2016b），51 50字节

@Giuseppe 节省了49个 50（！）字节。

function s(a),regexprep(a,'(\w)(\w)( |$)','$2$1 ')

和我以前的答案：

Matlab（R2016b），100字节

（只是为了乐趣：P）

function s(a),a=regexp(a,' ','split');for i=1:length(a),fprintf('%s ',a{i}([1:end-2 end end-1])),end

说明：

function s(a) % Defining as a function...
a=regexp(a,' ','split'); % Splits the input string at the spaces
for i=1:length(a) % Loops through each word
    fprintf('%s ',a{i}([1:end-2 end end-1])) % And prints everything with the last two characters swapped.
end

C， 62   58  54字节

感谢@Dennis节省了 四个 八个字节！

f(char*s){s[1]>32||(*s^=s[-1]^=*s^=s[-1]);*++s&&f(s);}

在线尝试！

Prolog（SWI），60字节

[A,B]+[B,A].
[A,B,32|U]+[B,A,32|Y]:-U+Y,!.
[A|U]+[A|Y]:-U+Y.

在线尝试！

说明

首先，我们定义基本情况：

p([A,B],[B,A]).

这意味着最后两个字母将始终被交换。

然后定义如果我们紧挨一个空格会发生什么：

p([A,B,32|U],[B,A,32|Y]):-p(U,Y),!.

如果两个字符串恰好在空格之前匹配，则交换该空格之前的字母，如果字符串匹配，则其余部分互换。然后!，我们使用削减。

最后一种情况是，如果我们不在空格旁边，则前两个字母需要匹配。

p([A|U],[A|Y]):-p(U,Y).

Wolfram语言，117字节

StringReplace[RegularExpression["\\b[[:alpha:]]{2,}\\b"]:>StringDrop[StringInsert["$0",StringTake["$0",{-1}],-3],-1]]

在线尝试！

应用于测试字符串。

StringReplace[
  RegularExpression["\\b[[:alpha:]]{2,}\\b"] :> 
   StringDrop[StringInsert["$0", StringTake["$0", {-1}], -3], -1]] /@
 {"Thansk", "Youer welcoem", "This is an apple", 
  "Flippign Lettesr Aroudn", "tHe oDd chALlEneg wiht swappde lettesR"} // Column

Thanks
Youre welcome
Thsi si na appel
Flipping Letters Around
teH odD chALlEnge with swapped letteRs

R，111 51 41字节

由@Giuseppe提供，这是一种正则表达式方法，可将我的旧方法彻底抛弃。

cat(gsub("(.)(.)\\b",'\\2\\1',scan(,"")))

APL（Dyalog Classic），28字节

1↓∊((¯2↓⊢),2↑⌽)¨' '(,⊂⍨⊣=,)⍞

⎕ML而且⎕IO都是1，

在线尝试！

说明

• ... (,⊂⍨⊣=,) ... 拆分（同时保留边框，并在开始处添加边框）...
• ... ⍞ ...输入...
• ... ' ' ... ...在太空。
• ... ( ... )¨ ... 然后，对每个元素：
  • ... , ... 连接...
  • ... (¯2↓⊢) ... ...除了最后两个以外的所有项目...
  • ... 2↑⌽ ... ...与最后两个元素相反。
• 1↓∊ ... 最后，返回除拼合结果的第一个元素以外的所有元素。

时髦，34字节

s=>s::gsub("(.)(.)( |$)","$2$1$3")

在线尝试！

哈斯克尔，45个字节

-2个字节，感谢H.PWiz。

(r.g.r=<<).words
g(x:y:z)=' ':y:x:z
r=reverse

在线尝试！

J，20 19 11字节

归功于@Bolce Bussiere

1&A.&.>&.;:

在线尝试！

       &.;:      on words
    &.>          on each
  A.             apply the permutation
1&               number 1, swap the last two elements

爱丽丝，24字节

/0RR'.%$1\' o
\ix*o ne@/

在线尝试！

说明

/...\' o
\.../

这形成一个循环，其中循环主体是线性序数片段，我们执行 ' o在每两次循环迭代之间以Cardinal模式。后者只是打印一个空格。

展开顺序代码的之字形结构，线性循环主体实际上如下所示：

iR*' %e10xRo.n$@

分解如下：

i     Read all input. On subsequent iterations, this will push an empty string.
R     Reverse.
*     Join. On the first iteration, this joins the input to an implicit empty string,
      which does nothing. On subsequent iterations, it will join the empty string to
      the word on top of the string, thereby getting rid of the empty string.
' %   Split around spaces. On the first iteration, this will split the input
      into individual words. On subsequent iterations, this does nothing.
e10   Push "10".
x     Use this to permute the (reversed) word on top of the stack. In
      particular, the word is rearranged with the same permutation that is
      required to sort the string "10", which means the first two letters
      get swapped (which correspond to the last two letters of the actual
      word).
R     Reverse the swapped word.
o     Print it.
.n$@  If there are no words left on the stack, terminate the program.

brainfuck，109 100字节

编辑：不必处理一个字母的单词

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

在线尝试！

打印尾随空格

怎么运行的

,[>++++[-<-------->],] Puts input on the tape and subtracts 32 from each character
                       This separates each word

>+[- Start the loop
   <[>++++[<++++++++>-]<[->>+<<]<] Add 32 to each letter of the word
                                   Skip this on the first iteration for the last word

   <<[->>+<<]>[[-<+>]>] Swaps the last two letters of the word
   <<[>+>+>]- If there is another word to the left continue loop
              Also set up to add a space to the end of the word
 <] End loop
 >>>>>>>[.>] Print the modified string

先前版本，109字节

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

在线尝试！

QuadR，8字节

..\b
⌽⍵M

在线尝试！

PHP，119107字节

编辑：感谢totalhuman

<?php foreach(explode(" ",trim(fgets(STDIN)))as$w)echo substr($w,0,strlen($w)-2).strrev(substr($w,-2))," ";

在线尝试！

Haskell，41个字节

foldr(%)" "
a%(b:' ':r)=b:a:' ':r
a%s=a:s

在线尝试！

输出带有尾随空格。

重复' ':r看起来很浪费。但是a%(b:t@(' ':r))=b:a:t长度是一样的，并且长a%(b:t)|' ':_<-t=b:a:t一个字节。

Haskell，41个字节

f(a:b:t)|t<"A"=b:a:f t|1>0=a:f(b:t)
f e=e

在线尝试！

sed，20 17 + 1（-r）= 18个字节

s/(.)(.)\b/\2\1/g

在线尝试！

PHP，65字节

需要PHP 7.1（或更高版本）

for(;$s=$argv[++$i];$s[-1]=$s[-2],$s[-2]=$c,print"$s ")$c=$s[-1];

将句子作为单独的命令行参数。用运行-nr。

在单个字符串上工作， 77 + 1个字节：

foreach(explode(" ",$argn)as$s){$c=$s[-1];$s[-1]=$s[-2];$s[-2]=$c;echo"$s ";}

与一起作为管道运行-nR。

...或在线尝试。

Java 8，35字节

s->s.replaceAll("(.)(.)\\b","$2$1")

我打完两个字节后，@ TaylorScott的Google表格答案的端口。编辑：在我打完两个字节之后，我现在看到的是Neil的Retina应答端口。

说明：

在线尝试。

s->                           // Method with String as both parameter and return-type
   s.replaceAll("(.)(.)       //  Replace any two characters,
                       \\b",  //  with a word-boundary after it (space or end of String)
                "$2$1")       //  With the two characters swapped

Google Sheets, 33 Bytes

Anonymous worksheet function that takes input from cell A1 and outputs to the calling cell

=RegExReplace(A1,"(.)(.)\b","$2$1

-2 Bytes Thanks to @KevinCruijssen for the use of (.) over (\w)

JavaScript (Node.js), 38 36 32 bytes

s=>s.replace(/(.)(.)( |$)/g,"$2$1 ") 

s=>s.replace(/(.)(.)\b/g,"$2$1")

Try it online!

RegExp approach courtesy @Giuseppe (although I thought of this independently), assuming words separated by only one space

-2 for only considering 1 space and add trailing space

-4 Thanks @Shaggy

K (oK), 23 22 bytes

" "/{x@prm[!#x]1}'" "\

Try it online!

Example:

" "/{x@prm[!#x]1}'" "\"Hello World"
"Helol Wordl"

Explanation:

Port of FrownyFrog's solution to save 1 byte.

I'll come back to this.

" "/{prm[x]1}'" "\ / the solution
              " "\ / split input on " "
    {       }'     / apply lambda to each
     prm[x]        / permute input x
           1       / and take the 2nd result
" "/               / join with " "

Previous solution:

• " "/-2{(x_y),|x#y}'" "\ 23 bytes

05AB1E, 7 bytes

#vy`sðJ

Try it online!

-1 thanks to Magic Octopus Urn.

Prints one trailing space.

Jelly, 10 bytes

ḲṪ,¥\€Ḋ€UK

Try it online!

SNOBOL4 (CSNOBOL4), 136 119 bytes

	I =INPUT
B	I SPAN(&LCASE &UCASE) . Y ARBNO(' ') =:F(O)
	Y RPOS(2) REM . Z =REVERSE(Z)
	O =O Y ' '	:(B)
O	OUTPUT =O
END

Try it online!

Prints with a trailing space. You know you've done something wrong when a language is a backronym for StriNg Oriented and symBOlic Language and your code is longer than Brain-Flak :( now it's slightly better.

Line B takes I and replaces (alphabetic characters saved as Y)(some number of spaces) with the empty string.

The following line extracts the last 2 characters of Y as Z and replaces them as Z reversed, then the next line concatenates O, Y, and a single space character.

Finally, it prints when I no longer matches the required pattern in line B.

Perl 5, 19 + 1 (-p) = 20 bytes

s/(\w)(\w)\b/$2$1/g

Try it online!