En el chat, a menudo somos personas que escriben rápido y realmente no miramos el orden de las letras antes de publicar un mensaje. Como somos flojos, necesitamos un programa que intercambie automáticamente las dos últimas letras de nuestras palabras, pero como no queremos responder demasiado tarde, el código debe ser corto.

Su tarea, si desea aceptarla, es escribir un programa que invierta las dos últimas letras de cada palabra en una cadena dada (de modo que la palabra se Thanskconvierta en Thanks). Una palabra es una secuencia de dos o más letras en el alfabeto inglés delimitadas por un solo espacio.

• Se garantiza que la cadena / lista de caracteres que recibe como entrada solo contiene caracteres alfabéticos y espacios (ASCII [97 - 122], [65 - 90] y 32).

• Puede tomar entradas y proporcionar salidas a través de cualquier método estándar , en cualquier lenguaje de programación , mientras toma nota de que estas lagunas están prohibidas de forma predeterminada.

• La salida puede tener un espacio final y / o una nueva línea final.

• La entrada siempre contendrá solo palabras (y el espacio en blanco correspondiente) y consistirá en al menos una palabra.

Este es el código de golf, por lo que gana la presentación más corta (puntuada en bytes) en cada idioma.

Casos de prueba

Tenga en cuenta que las cadenas están entre comillas para facilitar la lectura.

Entrada -> Salida

"Thansk" -> "Gracias"
"Youer welcoem" -> "De nada"
"Esto es una manzana" -> "Thsi si na appel"
"Flippign Lettesr Aroudn" -> "Voltear letras alrededor"
"EL ANTIGUO RETO CON LAS LETRAS DE INTERCAMBIO" -> "EL RETO EXTRAÑO CON LAS LETRAS CAMBIADAS"

O, para conveniencia del conjunto de pruebas, aquí están las entradas y sus salidas correspondientes por separado:

Thansk
Youer welcoem
Esto es una manzana
Flippign Lettesr Aroudn
EL ANTIGUO RETO CON CAMBIO DE LETRAS

Gracias
De nada
Este si na appel
Voltear letras alrededor
EL RETO EXTRAÑO CON LETRAS CAMBIADAS

Gracias a DJMcMayhem por el título. Este fue originalmente un CMC .

V , 4 5 bytes

òeXp

Pruébalo en línea!

|| denota el cursor

El búfer comienza con |w|ord and more wordsy el cursor está en el primer carácter.

Recursivamente ò

ir al final ede una palabra

wor|d| and more words

eliminar Xel caracter a la izquierda del cursor

wo|d| and more words

pmira sobre el siguiente personaje

wod|r| and more words

Final implícito ò, repita el mismo proceso para otras palabras hasta llegar al final del búfer

Jalea , 7 bytes

Ḳœ?@€2K

Un enlace monádico que toma y devuelve listas de personajes

Pruébalo en línea!

¿Cómo?

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

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

Pruébalo en línea!

El peor idioma para el trabajo :)

Legible Versión ligeramente más legible:

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

    {
        {}
        <>

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

        (<>)
    }
    {}

    ({}<>)<>

}<>

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

{

    ({}<>)
    <>
}<>

Haskell , 40 bytes

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

Pruébalo en línea! Ejemplo de uso: (f=<<).words $ "abc xyz"rendimientos "acb xzy ".

Retina , 13 bytes

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

Pruébalo en línea! El enlace incluye casos de prueba.

Python 3 , 50 bytes

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

Pruébalo en línea!

Esta respuesta abusa del comportamiento de impresión de Python 3: se imprimen varios argumentos con un solo espacio entre ellos. Por supuesto, no podemos simplemente darle múltiples argumentos porque no sabemos cuántas palabras habrá en la entrada. Entonces usamos el operador splat . Básicamente

print(*[a,b,c])

es exactamente lo mismo que

print(a,b,c)

El abuso que hace que un programa completo resulte más corto que una función / lambda donde tendríamos que usar ' '.joino algo similar.

Matlab (R2016b), 51 50 bytes

Ahorró 49 50 (!) Bytes gracias a @Giuseppe.

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

Y mi respuesta anterior:

Matlab (R2016b), 100 bytes

(Solo por diversión: P)

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

Explicación:

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

¡Gracias a @Dennis por guardar  cuatro  ocho bytes!

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

Pruébalo en línea!

Prólogo (SWI) , 60 bytes

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

Pruébalo en línea!

Explicación

Primero definimos el caso base:

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

Esto significa que las dos últimas letras siempre se intercambiarán.

Luego definimos qué sucede si estamos justo al lado de un espacio:

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

Dos cadenas coinciden si justo antes de un espacio se intercambian las letras antes del espacio y el resto si las cadenas coinciden. Luego usamos !para cortar.

Nuestro último caso es si no estamos al lado de un espacio, las dos primeras letras deben coincidir.

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]]

Pruébalo en línea!

Aplicado a las cadenas de prueba.

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

Cortesía de @Giuseppe, un enfoque de expresiones regulares que elimina mi antiguo método del agua.

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

APL (Dyalog Classic) , 28 bytes

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

⎕MLy ⎕IOson a la vez 1,

Pruébalo en línea!

Explicación

• ... (,⊂⍨⊣=,) ... Dividir (manteniendo los bordes y agregando un borde al principio) ...
• ... ⍞ ... la entrada ...
• ... ' ' ... ... en los espacios.
• ... ( ... )¨ ... Luego, a cada elemento de eso:
  • ... , ... Concatenar ...
  • ... (¯2↓⊢) ... ... cada artículo excepto los dos últimos ...
  • ... 2↑⌽ ... ... con el reverso de los dos últimos elementos.
• 1↓∊ ... Finalmente, devuelva todos menos el primer elemento del resultado aplanado.

Funky , 34 bytes

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

Pruébalo en línea!

Haskell , 45 bytes

-2 bytes gracias a H.PWiz.

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

Pruébalo en línea!

J , 20 19 11 bytes

Crédito a @Bolce Bussiere

1&A.&.>&.;:

Pruébalo en línea!

       &.;:      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@/

Pruébalo en línea!

Explicación

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

Esto forma un bucle donde el cuerpo del bucle es un fragmento ordinal lineal y ejecutamos ' o en modo Cardinal entre cada dos iteraciones del bucle. Este último solo imprime un espacio.

Al desplegar la estructura en zigzag del código ordinal, el cuerpo del bucle lineal realmente se ve así:

iR*' %e10xRo.n$@

Desglosando esto:

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.

cerebro , 109 100 bytes

Editar: no tiene que manejar palabras de una letra

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

Pruébalo en línea!

Imprime un espacio final

Cómo 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

Versión anterior, 109 bytes

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

Pruébalo en línea!

QuadR , 8 bytes

..\b
⌽⍵M

Pruébalo en línea!

PHP , 119107 bytes

Editar: gracias a totalmente humano

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

Pruébalo en línea!

Haskell , 41 bytes

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

Pruébalo en línea!

Salidas con un espacio final.

La repetida ' ':rparece un derroche. Pero a%(b:t@(' ':r))=b:a:ttiene la misma longitud y a%(b:t)|' ':_<-t=b:a:tes un byte más largo.

Haskell , 41 bytes

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

Pruébalo en línea!

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

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

Pruébalo en línea!

PHP, 65 bytes

requiere PHP 7.1 (o posterior)

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

toma la oración como argumentos de línea de comando separados. Corre con -nr.

trabajando en una sola cadena, 77 + 1 bytes :

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

Ejecutar como tubería con -nR.

... o pruébalos en línea .

Java 8, 35 bytes

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

Puerto de la respuesta de Google Sheets de @TaylorScott, después de jugar dos bytes. EDITAR: veo que ahora es un puerto de respuesta Retina de Neil después de mis dos bytes de golf.

Explicación:

Pruébalo en línea.

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

Hojas de cálculo de Google, 33 bytes

Función de hoja de trabajo anónima que toma la entrada de la celda A1y las salidas a la celda que llama

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

-2 Bytes Gracias a @KevinCruijssen por el uso de (.)over(\w)

JavaScript (Node.js) , 38 36 32 bytes

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

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

Pruébalo en línea!

Enfoque de RegExp cortesía de @Giuseppe (aunque pensé en esto de forma independiente), suponiendo que las palabras estén separadas por un solo espacio

-2 por solo considerar 1 espacio y agregar espacio final

-4 Gracias @Shaggy

K (oK) , 23 22 bytes

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

Pruébalo en línea!

Ejemplo:

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

Explicación:

La solución del puerto de FrownyFrog para ahorrar 1 byte .

Volveré a esto.

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

Solución previa:

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

05AB1E , 7 bytes

#vy`sðJ

Pruébalo en línea!

-1 gracias a Magic Octopus Urn .

Imprime un espacio final.

Jalea , 10 bytes

ḲṪ,¥\€Ḋ€UK

Pruébalo en línea!

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

Pruébalo en línea!

Imprime con un espacio final. Sabes que has hecho algo mal cuando un idioma es un backronym para StriNg Oriented and symBOlic Language y tu código es más largo que Brain-Flak :( ahora es un poco mejor.

La línea Btoma Iy reemplaza(alphabetic characters saved as Y)(some number of spaces) con la cadena vacía.

La siguiente línea extrae los últimos 2 caracteres de Yas Zy los reemplaza como Zinvertidos, luego la siguiente línea concatena O,Y y un único carácter de espacio.

Finalmente, imprime cuando Iya no coincide con el patrón requerido en línea B.

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

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

Pruébalo en línea!