No bate-papo, geralmente somos rápidos em digitar e realmente não olhamos a ordem das letras antes de postar uma mensagem. Como somos preguiçosos, precisamos de um programa que troque automaticamente as duas últimas letras em nossas palavras, mas como não queremos responder tarde demais, o código deve ser curto.

Sua tarefa, se você deseja aceitá-la, é escrever um programa que vire as duas últimas letras de cada palavra em uma determinada sequência (para que a palavra Thanskse transforme Thanks). Uma palavra é uma sequência de duas ou mais letras no alfabeto inglês delimitada por um único espaço.

• A sequência / lista de caracteres que você recebe como entrada é garantida para conter apenas caracteres e espaços alfabéticos (ASCII [97 - 122], [65 - 90] e 32).

• Você pode receber e fornecer saída através de qualquer método padrão , em qualquer linguagem de programação , observando que essas brechas são proibidas por padrão.

• A saída pode ter um espaço à direita e / ou uma nova linha à direita.

• A entrada sempre conterá apenas palavras (e o espaço em branco correspondente) e consistirá em pelo menos uma palavra.

Este é o código-golfe, então a submissão mais curta (pontuada em bytes), em cada idioma, vence!

Casos de teste

Observe que as seqüências de caracteres estão entre aspas para facilitar a leitura.

Entrada -> Saída

"Thansk" -> "Obrigado"
"Você é bem-vindo" -> "Você é bem-vindo"
"Esta é uma maçã" -> "Thsi si na appel"
"Flippign Lettesr Aroudn" -> "Invertendo letras"
"O CHALLENEG ANTIGO COM LETRAS RÁPIDAS" -> "O CHALLENGE ANTIGO COM LETRAS TRANSFERIDAS"

Ou, para conveniência do conjunto de testes, aqui estão as entradas e suas saídas correspondentes separadamente:

Thansk
Youer welcoem
Isto é uma maçã
Flippign Lettesr Aroudn
O CIDADÃO CHALLENEG COM LETRAS RÁPIDAS

obrigado
De nada
Thsi si na appel
Virando letras ao redor
O estranho problema com letras trocadas

Obrigado a DJMcMayhem pelo título. Este era originalmente um CMC .

V , 4 5 bytes

òeXp

Experimente online!

|| denota o cursor

O buffer começa com |w|ord and more wordse o cursor está no primeiro caractere.

Recursivamente ò

vá para o end de uma palavra

wor|d| and more words

remova Xo caractere à esquerda do cursor

wo|d| and more words

paste sobre o próximo caractere

wod|r| and more words

òFinal implícito , repita o mesmo processo para outras palavras até o final do buffer ser alcançado

Geléia , 7 bytes

Ḳœ?@€2K

Um link monádico que recebe e retorna listas de caracteres

Experimente online!

Quão?

Ḳœ?@€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

Flacidez Cerebral , 122 bytes

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

Experimente online!

A pior linguagem para o trabalho :)

Legível Versão ligeiramente mais legível:

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

    {
        {}
        <>

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

        (<>)
    }
    {}

    ({}<>)<>

}<>

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

{

    ({}<>)
    <>
}<>

Haskell , 40 bytes

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

Experimente online! Exemplo de uso: (f=<<).words $ "abc xyz"rendimentos "acb xzy ".

Retina , 13 bytes

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

Experimente online! O link inclui casos de teste.

Python 3 , 50 bytes

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

Experimente online!

Esta resposta abusa do comportamento de impressão do Python 3: vários argumentos são impressos com um único espaço entre eles. Obviamente, não podemos apenas apresentar vários argumentos, porque não sabemos quantas palavras estarão na entrada. Então, usamos o operador splat . Basicamente

print(*[a,b,c])

é exatamente a mesma coisa que

print(a,b,c)

O abuso que faz com que um programa completo se torne mais curto que uma função / lambda, onde teríamos que usar ' '.joinou algo semelhante.

Matlab (R2016b), 51 50 bytes

Economizou 49 50 (!) Bytes graças a @Giuseppe.

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

E minha resposta anterior:

Matlab (R2016b), 100 bytes

(Apenas por diversão: P)

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

Explicação:

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 bytes

Agradecemos ao @Dennis por salvar  quatro  oito bytes!

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

Experimente online!

Prolog (SWI) , 60 bytes

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

Experimente online!

Explicação

Primeiro, definimos o caso base:

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

Isso significa que as duas últimas letras serão sempre trocadas.

Em seguida, definimos o que acontece se estivermos ao lado de um espaço:

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

Duas cadeias coincidem se logo antes de um espaço, as letras anteriores ao espaço são trocadas e o restante se as cadeias coincidem. Nós então usamos !para cortar.

Nosso último caso é que, se não estamos próximos a um espaço, as duas primeiras letras precisam corresponder.

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

Wolfram Language , 117 bytes

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

Experimente online!

Aplicado às seqüências de teste.

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 bytes

Cortesia de Giuseppe, uma abordagem regex que explode meu método antigo fora da água.

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

APL (Dyalog Classic) , 28 bytes

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

⎕MLe ⎕IOsão ambos 1,

Experimente online!

Explicação

• ... (,⊂⍨⊣=,) ... Dividir (mantendo as bordas e anexando uma borda ao início) ...
• ... ⍞ ... a entrada ...
• ... ' ' ... ... em espaços.
• ... ( ... )¨ ... Então, para cada elemento disso:
  • ... , ... Concatenar ...
  • ... (¯2↓⊢) ... ... todos os itens, exceto os dois últimos ...
  • ... 2↑⌽ ... ... com o inverso dos dois últimos elementos.
• 1↓∊ ... Por fim, retorne todos, exceto o primeiro elemento do resultado nivelado.

Funky , 34 bytes

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

Experimente online!

Haskell , 45 bytes

-2 bytes graças a H.PWiz.

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

Experimente online!

J , 20 19 11 bytes

Crédito para @Bolce Bussiere

1&A.&.>&.;:

Experimente online!

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

Alice , 24 bytes

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

Experimente online!

Explicação

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

Isso forma um loop em que o corpo do loop é um snippet Ordinal linear e executamos ' ono modo Cardinal entre cada duas iterações do loop. Este último apenas imprime um espaço.

Desdobrando a estrutura em zigue-zague do código Ordinal, o corpo do loop linear fica assim:

iR*' %e10xRo.n$@

Quebrando isso:

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 bytes

Editar: não precisa lidar com palavras de uma letra

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

Experimente online!

Imprime um espaço à direita

Como funciona

,[>++++[-<-------->],] 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

Versão anterior, 109 bytes

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

Experimente online!

QuadR , 8 bytes

..\b
⌽⍵M

Experimente online!

PHP , 119 107 bytes

Edit: graças a totallyhuman

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

Experimente online!

Haskell , 41 bytes

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

Experimente online!

Saídas com um espaço à direita.

O repetido ' ':rparece um desperdício. Mas a%(b:t@(' ':r))=b:a:ttem o mesmo comprimento e a%(b:t)|' ':_<-t=b:a:tum byte a mais.

Haskell , 41 bytes

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

Experimente online!

sed , 20 17 + 1 (-r) = 18 bytes

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

Experimente online!

PHP, 65 bytes

requer PHP 7.1 (ou posterior)

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

toma sentença como argumentos de linha de comando separados. Corra com -nr.

trabalhando em uma única sequência, 77 + 1 bytes :

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

Corra como cano com -nR.

... ou experimentá-los online .

Java 8, 35 bytes

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

A porta do Google Sheets do @TaylorScott responde , depois de jogar dois bytes. EDIT: Vejo que agora é uma resposta da porta Retina de Neil após meus dois bytes de golfe.

Explicação:

Experimente online.

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

Planilhas Google, 33 bytes

Função de planilha anônima que leva a entrada da célula A1e sai para a célula de chamada

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

-2 Bytes Obrigado a @KevinCruijssen pelo uso de (.)mais de(\w)

JavaScript (Node.js) , 38 36 32 bytes

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

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

Experimente online!

A abordagem RegExp é cortesia de @ Giuseppe (embora eu tenha pensado nisso de forma independente), assumindo palavras separadas por apenas um espaço

-2 por considerar apenas 1 espaço e adicionar espaço à direita

-4 Obrigado @Shaggy

K (oK) , 23 22 bytes

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

Experimente online!

Exemplo:

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

Explicação:

Solução do Porto da FrownyFrog para economizar 1 byte .

Eu voltarei a isso.

" "/{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 " "

Solução anterior:

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

05AB1E , 7 bytes

#vy`sðJ

Experimente online!

-1 graças a Magic Octopus Urn .

Imprime um espaço à direita.

Gelatina , 10 bytes

ḲṪ,¥\€Ḋ€UK

Experimente 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

Experimente online!

Imprime com um espaço à direita. Você sabe que fez algo errado quando um idioma é um backronym para StriNg Oriented e symBOlic Language e seu código é mais longo que o Brain-Flak :( agora está um pouco melhor.

A linha Bpega Ie substitui (alphabetic characters saved as Y)(some number of spaces)pela string vazia.

A linha a seguir extrai os últimos 2 caracteres de Ycomo Ze substitui-los como Zrevertida, então os concatena próxima linha O, Ye um único caractere de espaço.

Por fim, imprime quando Inão corresponde mais ao padrão necessário na linha B.

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

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

Experimente online!