Im Chat tippen wir oft schnell und sehen uns die Reihenfolge der Buchstaben nicht genau an , bevor wir eine Nachricht posten . Da wir faul sind, brauchen wir ein Programm, das die letzten beiden Buchstaben in unseren Wörtern automatisch vertauscht, aber da wir nicht zu spät antworten möchten, muss der Code kurz sein.

Wenn Sie es akzeptieren möchten, müssen Sie ein Programm schreiben, das die letzten beiden Buchstaben jedes Wortes in einer bestimmten Zeichenfolge umblättert (so wird das Wort Thanskzu Thanks). Ein Wort ist eine Folge von zwei oder mehr Buchstaben im englischen Alphabet, die durch ein einzelnes Leerzeichen getrennt sind.

• Die Zeichenfolge / Liste der Zeichen, die Sie als Eingabe erhalten, enthält garantiert nur alphabetische Zeichen und Leerzeichen (ASCII [97 - 122], [65 - 90] und 32).

• Sie können Eingaben und Ausgaben mit jeder Standardmethode und in jeder Programmiersprache vornehmen. Beachten Sie dabei, dass diese Lücken standardmäßig verboten sind.

• Die Ausgabe kann ein nachgestelltes Leerzeichen und / oder eine nachgestellte Newline enthalten.

• Die Eingabe enthält immer nur Wörter (und das entsprechende Leerzeichen) und besteht aus mindestens einem Wort.

Das ist Code-Golf, also gewinnt die kürzeste Einsendung (in Bytes) in jeder Sprache!

Testfälle

Beachten Sie, dass die Zeichenfolgen aus Gründen der Lesbarkeit in Anführungszeichen gesetzt sind.

Eingabe -> Ausgabe

"Thansk" -> "Danke"
"Youer welcoem" -> "Du bist willkommen"
"Das ist ein Apfel" -> "Thsi si na appel"
"Flippign Lettesr Aroudn" -> "Briefe umdrehen"
"DER ANDERE CHALLENEG MIT AUSTAUSCH VON BRIEFEN" -> "DER ANDERE CHALLENGE MIT AUSTAUSCH VON BRIEFEN"

Zur Vereinfachung der Testsuite sind hier die Eingänge und die entsprechenden Ausgänge separat aufgeführt:

Thansk
Herzlich willkommen
Das ist ein Apfel
Flippign Lettesr Aroudn
Der alte chaleNeg mit austauschbaren Briefen

Vielen Dank
Bitte
Dies ist ein Appell
Briefe umdrehen
teH odD chALleNge mit getauschten Briefen

Vielen Dank an DJMcMayhem für den Titel. Dies war ursprünglich ein CMC .

V , 4,5 Bytes

òeXp

Probieren Sie es online!

|| bezeichnet den Cursor

Der Puffer beginnt mit |w|ord and more wordsund der Cursor steht auf dem ersten Zeichen.

Rekursiv ò

Gehe auf den ePunkt

wor|d| and more words

Entfernen Sie Xdas Zeichen links vom Cursor

wo|d| and more words

paste es über das nächste Zeichen

wod|r| and more words

Implizites Ende ò, wiederholen Sie den gleichen Vorgang für andere Wörter, bis das Ende des Puffers erreicht ist

Gelee , 7 Bytes

Ḳœ?@€2K

Eine monadische Verknüpfung, die Listen von Zeichen aufnimmt und zurückgibt

Probieren Sie es online!

Wie?

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

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

Probieren Sie es online!

Die schlechteste Sprache für den Job :)

Lesbar Etwas besser lesbare Version:

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

    {
        {}
        <>

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

        (<>)
    }
    {}

    ({}<>)<>

}<>

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

{

    ({}<>)
    <>
}<>

Haskell , 40 Bytes

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

Probieren Sie es online! Anwendungsbeispiel: (f=<<).words $ "abc xyz"Erträge "acb xzy ".

Retina , 13 Bytes

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

Probieren Sie es online! Link enthält Testfälle.

Python 3 , 50 Bytes

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

Probieren Sie es online!

Diese Antwort missbraucht das Druckverhalten von Python 3: Mehrere Argumente werden mit einem Leerzeichen dazwischen gedruckt. Natürlich können wir nicht einfach mehrere Argumente angeben, da wir nicht wissen, wie viele Wörter in der Eingabe enthalten sein werden. Also benutzen wir den splat Operator . Grundsätzlich gilt

print(*[a,b,c])

ist genau das gleiche wie

print(a,b,c)

Missbrauch macht ein volles Programm kürzer als eine Funktion / Lambda, die wir verwenden müssten, ' '.joinoder ähnliches.

Matlab (R2016b), 51 50 Bytes

Gespeichert 49 50 (!) Bytes dank @Giuseppe.

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

Und meine bisherige Antwort:

Matlab (R2016b), 100 Byte

(Nur zum Spaß: P)

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

Erläuterung:

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

Vielen Dank an @Dennis für das Speichern von  vier  acht Bytes!

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

Probieren Sie es 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.

Probieren Sie es online!

Erläuterung

Zuerst definieren wir den Basisfall:

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

Dies bedeutet, dass die letzten beiden Buchstaben immer vertauscht werden.

Dann definieren wir, was passiert, wenn wir uns direkt neben einem Leerzeichen befinden:

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

Zwei Zeichenfolgen stimmen überein, wenn unmittelbar vor einem Leerzeichen die Buchstaben vor dem Leerzeichen vertauscht sind, und der Rest, wenn die Zeichenfolgen übereinstimmen. Wir verwenden dann !zu schneiden.

Unser letzter Fall ist, wenn wir nicht neben einem Leerzeichen stehen, müssen die ersten beiden Buchstaben übereinstimmen.

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

Wolfram-Sprache , 117 Bytes

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

Probieren Sie es online!

Auf die Teststrings angewendet.

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

Mit freundlicher Genehmigung von @ Giuseppe, einem Regex-Ansatz, der meine alte Methode aus dem Wasser bläst.

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

APL (Dyalog Classic) , 28 Byte

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

⎕MLund ⎕IOsind beide 1,

Probieren Sie es online!

Erläuterung

• ... (,⊂⍨⊣=,) ... Teilen (unter Beibehaltung der Rahmen und Anhängen eines Rahmens an den Anfang) ...
• ... ⍞ ... die Eingabe ...
• ... ' ' ... ... in Räumen.
• ... ( ... )¨ ... Dann zu jedem Element davon:
  • ... , ... Verketten ...
  • ... (¯2↓⊢) ... ... jeder Gegenstand außer den letzten beiden ...
  • ... 2↑⌽ ... ... mit der Umkehrung der letzten beiden Elemente.
• 1↓∊ ... Geben Sie zum Schluss alle Elemente außer dem ersten Element des reduzierten Ergebnisses zurück.

Funky , 34 Bytes

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

Probieren Sie es online!

Haskell , 45 Bytes

-2 Bytes dank H.PWiz.

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

Probieren Sie es online!

J , 20 - 19 - 11 Bytes

Dank an @Bolce Bussiere

1&A.&.>&.;:

Probieren Sie es 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@/

Probieren Sie es online!

Erläuterung

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

Dies bildet eine Schleife, in der der Schleifenkörper ein lineares Ordinal-Snippet ist und ' ozwischen jeweils zwei Schleifeniterationen im Kardinal-Modus ausgeführt wird. Letzteres druckt nur ein Leerzeichen.

Wenn Sie die Zick-Zack-Struktur des Ordinal-Codes aufklappen, sieht der Körper der linearen Schleife tatsächlich so aus:

iR*' %e10xRo.n$@

Aufschlüsselung:

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

Bearbeiten: Es müssen keine Wörter mit einem Buchstaben behandelt werden

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

Probieren Sie es online!

Druckt ein Leerzeichen nach

Wie es funktioniert

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

Vorherige Version, 109 Bytes

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

Probieren Sie es online!

QuadR , 8 Bytes

..\b
⌽⍵M

Probieren Sie es online!

PHP , 119 107 Bytes

Edit: danke an totalhuman

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

Probieren Sie es online!

Haskell , 41 Bytes

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

Probieren Sie es online!

Ausgaben mit einem Leerzeichen am Ende.

Das wiederholte ' ':rsieht verschwenderisch aus. Ist a%(b:t@(' ':r))=b:a:taber gleich lang und a%(b:t)|' ':_<-t=b:a:tist ein Byte länger.

Haskell , 41 Bytes

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

Probieren Sie es online!

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

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

Probieren Sie es online!

PHP, 65 Bytes

benötigt PHP 7.1 (oder neuer)

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

Nimmt den Satz als separate Befehlszeilenargumente. Laufen Sie mit -nr.

Arbeiten an einer einzelnen Zeichenfolge, 77 + 1 Byte :

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

Als Rohr mit laufen lassen -nR.

... oder online ausprobieren .

Java 8, 35 Bytes

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

Port von @TaylorScotts Google Sheets antwortet , nachdem ich zwei Bytes golfen habe. EDIT: Ich sehe, es ist jetzt eine Portierung von Neils Retina-Antwort nach meinen zwei Golf-Bytes.

Erläuterung:

Probieren Sie es online aus.

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

Anonyme Arbeitsblattfunktion, die Eingaben aus der Zelle A1und Ausgaben in die aufrufende Zelle übernimmt

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

-2 Bytes Danke an @KevinCruijssen für die Verwendung von (.)über(\w)

JavaScript (Node.js) , 38 36 32 Bytes

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

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

Probieren Sie es online!

RegExp-Annäherung mit freundlicher Genehmigung von @ Giuseppe (obwohl ich unabhängig davon darüber nachgedacht habe), unter der Annahme von Wörtern, die nur durch ein Leerzeichen getrennt sind

-2 für die Berücksichtigung von nur 1 Leerzeichen und das Hinzufügen von Leerzeichen am Ende

-4 Danke @Shaggy

K (OK) , 23 22 Bytes

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

Probieren Sie es online!

Beispiel:

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

Erläuterung:

Portierung der FrownyFrog -Lösung, um 1 Byte zu sparen .

Ich werde darauf zurückkommen.

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

Vorherige Lösung:

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

05AB1E , 7 Bytes

#vy`sðJ

Probieren Sie es online!

-1 dank Magic Octopus Urn .

Druckt ein Leerzeichen nach.

Gelee , 10 Bytes

ḲṪ,¥\€Ḋ€UK

Probieren Sie es 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

Probieren Sie es online!

Druckt mit einem Leerzeichen nach. Sie wissen, dass Sie etwas falsch gemacht haben, wenn eine Sprache ein Backronym für ist StriNg Oriented und symBOlic Language ist und Ihr Code länger als Brain-Flak ist :( Jetzt ist es etwas besser.

Linie B nimmt Iund ersetzt (alphabetic characters saved as Y)(some number of spaces)durch die leere Zeichenfolge.

Die folgende Zeile extrahiert die letzten 2 Zeichen von Yas Zund ersetzt sie alsZ umgekehrt, dann die nächste Zeile verkettet O, Yund ein einzelnes Leerzeichen.

Schließlich wird gedruckt, wenn Idas erforderliche Muster in der Zeile nicht mehr übereinstimmt B.

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

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

Probieren Sie es online!