Oder: "Tauschen Sie den ersten und den letzten Buchstaben jedes Wortes aus."

Ihre Herausforderung besteht darin, die ersten und letzten Buchstaben jedes Wortes zu tauschen, indem Sie eine Folge von alphabetischen ASCII-Zeichen sowie ein weiteres Zeichen als Trennzeichen verwenden. Wenn ein Wort aus einem Zeichen besteht, lassen Sie es in Ruhe.

In den Beispielen / Testfällen werden die Kleinbuchstaben und das Leerzeichen als Begrenzer verwendet.

Sie müssen nicht mit Interpunktion umgehen. Alle Eingaben bestehen nur aus den Buchstaben a bis z, die durch ein Trennzeichen voneinander getrennt sind. Dies ist ein einheitlicher Fall.

Zum Beispiel mit der Zeichenfolge "Hallo Welt":

Input string: "hello world"
Identify each word: "[hello] [world]"
Identify the first and last letters of each word: "[[h]ell[o]] [[w]orl[d]]"
Swap the first letters of each word: "[[o]ell[h]] [[d]orl[w]]"
Final string: "oellh dorlw"

HINWEIS: Das Trennzeichen muss nicht separat eingegeben werden. Das Trennzeichen ist nur das Zeichen, das zum Trennen von Wörtern verwendet wird. Es kann alles sein. Ich wollte kreativen Golfern Optionen offen lassen, also wollte ich mich nicht nur auf Leerzeichen oder neue Linien beschränken. Das Trennzeichen ist nur ein Zeichen, das Wörter in der Eingabezeichenfolge trennt.

Testfälle:

"swap the first and last letters of each word" -> "pwas eht tirsf dna tasl setterl fo hace dorw"
"hello world" -> "oellh dorlw"
"test cases" -> "test sasec"
"programming puzzles and code golf" -> "grogramminp suzzlep dna eodc folg"
"in a green meadow" -> "ni a nreeg weadom"
"yay racecar" -> "yay racecar"

TeX, 216 Bytes (4 Zeilen à 54 Zeichen)

Da es nicht um die Anzahl der Bytes geht, geht es um die Qualität der gesetzten Ausgabe :-)

{\let~\catcode~`A13 \defA#1{~`#113\gdef}AGG#1{~`#1 13%
\global\let}GFF\elseGHH\fiAQQ{Q}AII{\ifxQ}AEE#1#2#3|{%
I#3#2#1FE{#1#2}#3|H}ADD#1#2|{I#1FE{}#1#2|H}ACC#1#2|{D%
#2Q|#1 }ABBH#1 {HI#1FC#1|BH}\gdef\S#1{\iftrueBH#1 Q }}

Probieren Sie es online! (Umseitig; nicht sicher, wie es funktioniert)

Vollständige Testdatei:

{\let~\catcode~`A13 \defA#1{~`#113\gdef}AGG#1{~`#1 13%
\global\let}GFF\elseGHH\fiAQQ{Q}AII{\ifxQ}AEE#1#2#3|{%
I#3#2#1FE{#1#2}#3|H}ADD#1#2|{I#1FE{}#1#2|H}ACC#1#2|{D%
#2Q|#1 }ABBH#1 {HI#1FC#1|BH}\gdef\S#1{\iftrueBH#1 Q }}

\S{swap the a first and last letters of each word}

pwas eht a tirsf dna tasl setterl fo hace dorw

\S{SWAP THE A FIRST AND LAST LETTERS OF EACH WORD}

\bye

Ausgabe:

Für LaTeX benötigen Sie nur das Boilerplate:

\documentclass{article}
\begin{document}

{\let~\catcode~`A13 \defA#1{~`#113\gdef}AGG#1{~`#1 13%
\global\let}GFF\elseGHH\fiAQQ{Q}AII{\ifxQ}AEE#1#2#3|{%
I#3#2#1FE{#1#2}#3|H}ADD#1#2|{I#1FE{}#1#2|H}ACC#1#2|{D%
#2Q|#1 }ABBH#1 {HI#1FC#1|BH}\gdef\S#1{\iftrueBH#1 Q }}

\S{swap the a first and last letters of each word}

pwas eht a tirsf dna tasl setterl fo hace dorw

\S{SWAP THE A FIRST AND LAST LETTERS OF EACH WORD}

\end{document}

Erläuterung

TeX ist ein seltsames Biest. Normalen Code zu lesen und zu verstehen, ist eine Selbstverständlichkeit. Das Verständnis von verschleiertem TeX-Code geht noch ein paar Schritte weiter. Ich werde versuchen, dies für Leute verständlich zu machen, die sich mit TeX nicht so gut auskennen. Bevor wir also anfangen, hier ein paar Konzepte zu TeX, damit die Dinge leichter zu befolgen sind:

Für (nicht so) absolute TeX-Anfänger

• Erster und wichtigster Punkt in dieser Liste: Der Code muss nicht rechteckig sein, auch wenn die Popkultur Sie dazu veranlasst .

• TeX ist eine Makro-Erweiterungssprache. Sie können beispielsweise definieren \def\sayhello#1{Hello, #1!}und dann schreiben \sayhello{Code Golfists}, um TeX zum Drucken zu bringen Hello, Code Golfists!. Dies wird als „nicht begrenztes Makro“ bezeichnet. Um den ersten (und in diesem Fall einzigen) Parameter einzugeben, setzen Sie ihn in geschweifte Klammern. TeX entfernt diese Klammern, wenn das Makro das Argument erfasst. Sie können bis zu 9 Parameter verwenden: \def\say#1#2{#1, #2!}dann \say{Good news}{everyone}.

• Das Gegenstück zu undefinierten oder unzureichend abgegrenzten Makros sind, wenig überraschend, diejenigen begrenzt :) Sie könnten die vorherige Definition mehr ein bisschen machen semantischer : \def\say #1 to #2.{#1, #2!}. In diesem Fall folgt auf die Parameter ein sogenannter Parametertext . Solcher Parametertext begrenzt das Argument des Makros ( #1wird durch ␣to␣Leerzeichen eingeschlossen und #2durch begrenzt .). Nach dieser Definition können Sie schreiben \say Good news to everyone., was zu erweitern wird Good news, everyone!. Schön, nicht wahr? :) Ein abgegrenztes Argument ist jedoch (unter Bezugnahme auf das TeXbook ) "die kürzeste (möglicherweise leere) Sequenz von Tokens mit richtig verschachtelten {...}Gruppen, der in der Eingabe diese spezielle Liste von Tokens ohne Parameter folgt". Dies bedeutet, dass die Expansion von\say Let's go to the mall to Martinwird einen seltsamen Satz produzieren. In diesem Fall müssten Sie zu „verstecken“ die erste ␣to␣mit {...}: \say {Let's go to the mall} to Martin.

• So weit, ist es gut. Jetzt wird es merkwürdig. Wenn TeX ein Zeichen liest (das durch einen „Zeichencode“ definiert ist), weist es diesem Zeichen einen „Kategoriecode“ (Catcode für Freunde) zu, der definiert, was dieses Zeichen bedeutet. Diese Kombination aus Zeichen- und Kategoriecode ergibt ein Token (mehr dazu hier zum Beispiel). Diejenigen, die für uns hier von Interesse sind, sind im Grunde:

  • catcode 11 , der Token definiert, die eine Kontrollsequenz bilden können (ein vornehmer Name für ein Makro). Standardmäßig sind alle Buchstaben [a-zA-Z] Kat.-Code 11, sodass ich schreiben kann. Dies \helloist eine einzelne Kontrollsequenz, während \he11odie Kontrollsequenz \hevon zwei Zeichen 1gefolgt wird, gefolgt von dem Buchstaben o, da 1es sich nicht um Kat.-Code 11 handelt. Wenn ich tat \catcode`1=11diesem Punkt aus auf \he11oeine Steuersequenz sein würde. Eine wichtige Sache ist, dass Catcodes gesetzt werden, wenn TeX das erste Mal das betreffende Zeichen sieht und dieser Catcode eingefroren wird ... FÜR IMMER! (Bedingungen können zutreffen)

  • Kat.-Code 12 , der die meisten anderen Zeichen enthält, wie z. B. 0"!@*(?,.-+/und so weiter. Sie sind die am wenigsten speziellen Arten von Katcodes, da sie nur zum Schreiben von Gegenständen auf Papier dienen. Aber hey, wer benutzt TeX zum Schreiben?!? (Auch hier gelten möglicherweise die allgemeinen Geschäftsbedingungen.)

  • Catcode 13 , das ist die Hölle :) Wirklich. Hör auf zu lesen und mach etwas aus deinem Leben. Sie möchten nicht wissen, was Catcode 13 ist. Schon mal was von Freitag, den 13. gehört? Ratet mal, woher es seinen Namen hat! Weiter auf eigene Gefahr! Ein Catcode-13-Zeichen, auch als "aktives" Zeichen bezeichnet, ist nicht mehr nur ein Zeichen, sondern selbst ein Makro! Sie können es definieren, um Parameter zu haben und es auf etwas zu erweitern, wie wir es oben gesehen haben. Nachdem du es getan \catcode`e=13hast, glaubst du es zu können \def e{I am the letter e!}, ABER. SIE. KANN NICHT! eist nicht mehr ein Brief, so \defist nicht das \defwissen Sie, es ist \d e f! Oh, wählst du einen anderen Buchstaben, den du sagst? Okay! \catcode`R=13 \def R{I am an ARRR!}. Sehr gut, Jimmy, probier es aus! Ich wage es, dass Sie das tun und einen RCode in Ihren Code schreiben ! Das ist ein Catcode 13. ICH BIN RUHIG! Lass uns weitermachen.

• Okay, jetzt zur Gruppierung. Das ist ziemlich einfach. Alle Zuweisungen ( \defeine Zuweisungsoperation, auf die \letwir noch näher eingehen), die in einer Gruppe ausgeführt wurden, werden auf den Stand vor dem Start dieser Gruppe zurückgesetzt, es sei denn, diese Zuweisung ist global. Es gibt verschiedene Möglichkeiten, Gruppen zu starten. Eine davon besteht aus den Zeichen Catcode 1 und 2 (oh, wieder Catcodes). Standardmäßig {ist Kat.-Code 1 oder }Anfangsgruppe und Kat.-Code 2 oder Endgruppe. Ein Beispiel: \def\a{1} \a{\def\a{2} \a} \aDies wird gedruckt 1 2 1. Außerhalb der Gruppe \awar 1, dann innerhalb wurde es neu definiert 2, und als die Gruppe endete, wurde es wiederhergestellt 1.

• Die \letOperation ist eine andere Zuweisungsoperation \def, die jedoch anders ist. Mit definieren\def Sie Makros, die sich zu Dingen erweitern, mit denen Sie Kopien von bereits vorhandenen Dingen erstellen. Nach (das ist optional) können Sie den Start des Beispiels von dem obigen Punkt mit dem Kat.-Code 13 auf ändern und Spaß damit haben. Oder besser, anstatt Sachen brechen Sie können beheben (würden Sie sich das an!) , Um das Beispiel: . Kurze Frage: Könnten Sie umbenennen ?\let\let\blub=\def=e\blub e{...R\let\newr=R \catcode`R=13 \def R{I am an A\newr\newr\newr!}\newR

• Schließlich die sogenannten "Störräume". Dies ist eine Art Tabuthema, da es Leute gibt, die behaupten, dass der Ruf, der durch die Beantwortung von „unechten Leerzeichen“ -Fragen im TeX - LaTeX Stack Exchange erworben wurde, nicht berücksichtigt werden sollte, während andere dies ausdrücklich ablehnen. Mit wem sind Sie einverstanden? Platzieren Sie Ihre Wetten! Unterdessen: TeX versteht einen Zeilenumbruch als Leerzeichen. Versuchen Sie, mehrere Wörter mit einem Zeilenumbruch (keine Leerzeile ) dazwischen zu schreiben . Fügen Sie nun %am Ende dieser Zeilen ein hinzu. Es ist, als ob Sie diese Zeilenende-Leerzeichen „auskommentiert“ hätten. Das ist es :)

(Art von) den Code Unolfing

Lassen Sie uns aus diesem Rechteck etwas machen, dem (wohl) leichter zu folgen ist:

{
\let~\catcode
~`A13
\defA#1{~`#113\gdef}
AGG#1{~`#113\global\let}
GFF\else
GHH\fi
AQQ{Q}
AII{\ifxQ}
AEE#1#2#3|{I#3#2#1FE{#1#2}#3|H}
ADD#1#2#3|{I#2FE{#1}#2#3|H}
ACC#1#2|{D{}#2Q|#1 }
ABBH#1 {HI#1FC#1|BH}
\gdef\S#1{\iftrueBH#1 Q }
}

Erklärung der einzelnen Schritte

Jede Zeile enthält eine einzelne Anweisung. Gehen wir nacheinander und sezieren sie:

{
Zuerst starten wir eine Gruppe, um einige Änderungen (nämlich Änderungen am Catcode) lokal zu halten, damit sie den eingegebenen Text nicht durcheinander bringen.

\let~\catcode
Grundsätzlich beginnen alle TeX-Verschleierungscodes mit dieser Anweisung. Standardmäßig ist sowohl in TeX als auch in LaTeX das ~Zeichen das einzige aktive Zeichen, das zur weiteren Verwendung in ein Makro umgewandelt werden kann. Und das beste Werkzeug zur Verrückung von TeX-Code sind Catcode-Änderungen. Daher ist dies im Allgemeinen die beste Wahl. Jetzt \catcode`A=13können wir statt schreiben ~`A13(das =ist optional):

~`A13
Jetzt ist der Buchstabe Aein aktiver Charakter und wir können ihn definieren, um etwas zu tun:

\defA#1{~`#113\gdef}
Aist jetzt ein Makro, das ein Argument akzeptiert (das ein anderes Zeichen sein sollte). Zuerst wird der Catcode des Arguments in 13 geändert, um es zu aktivieren: ~`#113(Ersetzen Sie das Argument ~durch \catcodeund fügen Sie ein hinzu, =und Sie haben :) \catcode`#1=13. Schließlich verbleibt ein \gdef(global \def) im Eingabestream. Kurz gesagt, Amacht ein anderes Zeichen aktiv und beginnt mit seiner Definition. Lass es uns versuchen:

AGG#1{~`#113\global\let}
AGfirst “activates” Gund does \gdef, woraufhin next Gdie Definition startet. Die Definition von Gist der von sehr ähnlich, mit der AAusnahme, dass stattdessen \gdefa \global\let(es gibt kein \gletähnliches \gdef) verwendet wird. Kurz gesagt, Gaktiviert einen Charakter und macht ihn zu etwas anderem. Machen wir Verknüpfungen für zwei Befehle, die wir später verwenden werden:

GFF\else
GHH\fi
Jetzt können wir statt \elseund \fieinfach Fund verwenden H. Viel kürzer :)

AQQ{Q}
Jetzt verwenden wir Awieder ein anderes Makro zu definieren, Q. Grundsätzlich gilt die obige Aussage (in einer weniger verschleierten Sprache) \def\Q{\Q}. Dies ist keine besonders interessante Definition, hat aber eine interessante Funktion. Sofern Sie keinen Code knacken möchten, ist das einzige Makro, das Qsich Qselbst erweitert, so dass es sich wie ein eindeutiger Marker verhält (es wird Quark genannt ). Sie können die \ifxBedingung verwenden, um zu testen, ob das Argument eines Makros wie folgt lautet \ifx Q#1:

AII{\ifxQ}
Sie können also ziemlich sicher sein, dass Sie einen solchen Marker gefunden haben. Beachten Sie, dass ich in dieser Definition das Leerzeichen zwischen \ifxund entfernt habe Q. Normalerweise würde dies zu einem Fehler führen (beachten Sie, dass das Syntax-Highlight dies für \ifxQeine Sache hält), aber da es sich jetzt Qum Catcode 13 handelt, kann es keine Kontrollsequenz bilden. Achten Sie jedoch darauf, diesen Quark nicht zu erweitern, da Sie sonst in einer Endlosschleife stecken bleiben, weil sich Qerweitert, zu Qwelcher erweitert, zu Qwelcher ...

Nun, da die Vorbereitungen abgeschlossen sind, können wir zum richtigen Algorithmus gehen, um ihn zu setzen. Aufgrund der Tokenisierung von TeX muss der Algorithmus rückwärts geschrieben werden. Dies liegt daran, dass TeX zum Zeitpunkt der Definition den Zeichen in der Definition unter Verwendung der aktuellen Einstellungen Catcodes zuweist. Beispiel:

\def\one{E}
\catcode`E=13\def E{1}
\one E

die Ausgabe ist E1, während, wenn ich die Reihenfolge der Definitionen ändere:

\catcode`E=13\def E{1}
\def\one{E}
\one E

die Ausgabe ist 11. Dies liegt daran, dass im ersten Beispiel der Ein der Definition angegebene Buchstabe (Catcode 11) vor der Catcode-Änderung als Buchstabe gekennzeichnet wurde, sodass er immer ein Buchstabe ist E. Im zweiten Beispiel wurde jedoch Ezuerst \oneaktiviert und erst dann definiert, und jetzt enthält die Definition den Katcode 13, Eder sich zu erweitert 1.

Ich werde diese Tatsache jedoch übersehen und die Definitionen neu anordnen, um eine logische (aber nicht funktionierende) Reihenfolge zu erhalten. In den folgenden Abschnitten können Sie davon ausgehen , dass die Buchstaben B, C, D, und Eaktiv sind.

\gdef\S#1{\iftrueBH#1 Q }
(Beachten Sie, dass es in der vorherigen Version einen kleinen Fehler gab, der das letzte Leerzeichen in der obigen Definition nicht enthielt. Ich habe ihn nur beim Schreiben bemerkt. Lesen Sie weiter und Sie werden sehen, warum wir diesen benötigen, um das Makro ordnungsgemäß zu beenden. )
Zuerst definieren wir das Makro auf Benutzerebene \S. Dieser sollte kein aktiver Charakter sein, um eine benutzerfreundliche (?) Syntax zu haben, also ist das Makro für gwappins eht setterl \S. Das Makro beginnt mit einer immer zutreffenden Bedingung \iftrue(es wird bald klar sein, warum) und ruft dann das BMakro auf, gefolgt von H(das wir zuvor definiert haben \fi), um es mit dem zu vergleichen \iftrue. Dann verlassen wir das Argument des Makros, #1gefolgt von einem Leerzeichen und dem Quark Q. Nehmen wir an \S{hello world}, wir verwenden dann den Eingabestromsollte so aussehen: \iftrue BHhello world Q␣(Ich habe das letzte Leerzeichen durch ein ersetzt, ␣damit das Rendern der Site es nicht verschlingt, wie ich es in der vorherigen Version des Codes getan habe). \iftrueist wahr, also dehnt es sich aus und wir bleiben mit BHhello world Q␣. TeX ist nicht entfernen Sie die \fi( H) , nachdem die bedingte ausgewertet wird, sondern es lässt sie dort , bis das \fiist tatsächlich erweitert. Jetzt ist das BMakro erweitert:

ABBH#1 {HI#1FC#1|BH}
Bist ein durch Trennzeichen getrenntes Makro, dessen Parameter text ist H#1␣. Das Argument ist also das, was zwischen Hund einem Leerzeichen steht. Fortsetzung des obigen Beispiels über dem Eingabestream vor der Erweiterung von Bis BHhello world Q␣. Bgefolgt von H, wie es sollte (sonst würde TeX einen Fehler auslösen), dann ist das nächste Leerzeichen zwischen hellound world, so #1ist das Wort hello. Und hier müssen wir den Eingabetext in die Leerzeichen aufteilen. Yay: D Der Ausbau der Bentfernt alles bis zum ersten Platz aus dem Eingangsstrom und ersetzt durch HI#1FC#1|BHmit zu #1sein hello: HIhelloFChello|BHworld Q␣. Beachten Sie, dass es BHspäter im Eingabestream eine neue gibt , um eine Endrekursion von durchzuführenBund später Wörter verarbeiten. Nachdem dieses Wort verarbeitet wurde, Bwird das nächste Wort verarbeitet, bis das zu verarbeitende Wort das Quark ist Q. Das letzte Leerzeichen danach Qwird benötigt, da für das mit Trennzeichen versehene Makro am Ende des Arguments ein Leerzeichen B erforderlich ist . In der Vorgängerversion (siehe Bearbeitungsverlauf) hat sich der Code bei Verwendung nicht mehr richtig verhalten \S{hello world}abc abc(der Abstand zwischen den abcs würde verschwinden).

OK, zurück zum Eingangsstrom: HIhelloFChello|BHworld Q␣. Zuerst gibt es das H( \fi), das die Initiale vervollständigt \iftrue. Jetzt haben wir folgendes (pseudocodiert):

I
  hello
F
  Chello|B
H
world Q␣

Das I...F...HDenken ist eigentlich eine \ifx Q...\else...\fiStruktur. Der \ifxTest prüft, ob das (erste Token des) ergriffenen Wortes der QQuark ist. Wenn es da ist nichts anderes und die Ausführung beendet zu tun, sonst was bleibt , ist: Chello|BHworld Q␣. Jetzt Cwird erweitert:

ACC#1#2|{D#2Q|#1 }
Das erste Argument von CUndelimited wird, es sei denn , so verspannt , es wird ein einzelnes Token wird, wird das zweite Argument , begrenzt durch |, so dass nach dem Ausbau der C(mit #1=hund #2=ello) der Eingangsstrom ist: DelloQ|h BHworld Q␣. Beachten Sie, dass ein anderer |dort abgelegt wird und das hvon danach helloabgelegt wird. Der halbe Tausch ist erledigt; Der erste Buchstabe ist am Ende. In TeX ist es einfach, das erste Token einer Tokenliste zu erfassen. Ein einfaches Makro \def\first#1#2|{#1}erhält den ersten Buchstaben, wenn Sie verwenden \first hello|. Das letzte ist ein Problem, da TeX immer die "kleinste, möglicherweise leere" Token-Liste als Argument aufgreift, sodass wir einige Workarounds benötigen. Das nächste Element in der Token-Liste ist D:

ADD#1#2|{I#1FE{}#1#2|H}
Dieses DMakro ist eine der Problemumgehungen und nützlich, wenn das Wort nur einen Buchstaben enthält. Angenommen, statt hellowir hatten x. In diesem Fall würde der Eingangsstrom sein DQ|x, dann Derweitern würde (mit #1=Qund #2leer): IQFE{}Q|Hx. Dies ähnelt dem I...F...H( \ifx Q...\else...\fi) -Block in B, der erkennt, dass das Argument der Quark ist und die Ausführung unterbricht und nur xzum Satz verwendet wird. In anderen Fällen (auf das zurückgehenden helloBeispiel), Dwürde erweitern (mit #1=eund #2=lloQ) zu: IeFE{}elloQ|Hh BHworld Q␣. Auch das I...F...Hwird prüfen , Qaber die fehlschlagen und nimmt \elseZweig: E{}elloQ|Hh BHworld Q␣. Nun das letzte Stück von diesem Ding, dasE Makro würde erweitern:

AEE#1#2#3|{I#3#2#1FE{#1#2}#3|H}
Der Parametertext hier ist ziemlich ähnlich zu Cund D; Das erste und das zweite Argument sind nicht begrenzt, und das letzte Argument ist durch begrenzt |. Die Eingangsstrom sieht wie folgt aus : E{}elloQ|Hh BHworld Q␣, dann Edehnt sich (mit #1leeren, #2=eund #3=lloQ): IlloQeFE{e}lloQ|HHh BHworld Q␣. Ein weiterer I...F...HBlock überprüft das Quark (die sieht lund kehrt false): E{e}lloQ|HHh BHworld Q␣. Nun Eerweitert wieder (mit #1=eleeren, #2=lund #3=loQ): IloQleFE{el}loQ|HHHh BHworld Q␣. Und nochmal I...F...H. Das Makro macht noch ein paar Iterationen, bis das Qgefunden ist und der trueZweig genommen wird: E{el}loQ|HHHh BHworld Q␣-> IoQlelFE{ell}oQ|HHHHh BHworld Q␣-> E{ell}oQ|HHHHh BHworld Q␣-> IQoellFE{ello}Q|HHHHHh BHworld Q␣. Nun wird der Quark gefunden und die bedingten ERWEITERT: oellHHHHh BHworld Q␣. Puh.

Oh, warte, was sind das? NORMALE BRIEFE? Oh Junge! Die Buchstaben sind schließlich gefunden und TeX aufschreibt oell, dann ein Haufen H( \fi) gefunden und erweitert (nichts) mit dem Eingangsstrom zu verlassen: oellh BHworld Q␣. Jetzt werden beim ersten Wort der erste und der letzte Buchstabe ausgetauscht, und als Nächstes sucht TeX den anderen B, um den gesamten Vorgang für das nächste Wort zu wiederholen.

}
Zum Schluss haben wir die Gruppe wieder dort gestartet, so dass alle lokalen Zuweisungen rückgängig gemacht werden. Die lokalen Zuweisungen sind die catcode Änderungen der Buchstaben A, B, C, ... , die Makros gemacht wurden , so dass sie zu ihrer normalen Brief Bedeutung zurückkehren und können ohne Bedenken im Text verwendet werden. Und das ist es. Das dort \Sdefinierte Makro löst nun die oben beschriebene Verarbeitung des Textes aus.

Eine interessante Sache an diesem Code ist, dass er vollständig erweiterbar ist. Das heißt, Sie können es sicher in sich bewegenden Argumenten verwenden, ohne befürchten zu müssen, dass es explodiert. Sie können den Code sogar verwenden, um zu überprüfen, ob der letzte Buchstabe eines Wortes mit dem zweiten in einem \ifTest übereinstimmt (aus welchem ​​Grund auch immer Sie das benötigen würden) :

\if\S{here} true\else false\fi % prints true (plus junk, which you would need to handle)
\if\S{test} true\else false\fi % prints false

Entschuldigen Sie die (wahrscheinlich viel zu) wortreiche Erklärung. Ich habe versucht, es auch für Nicht-TeXies so klar wie möglich zu machen :)

Zusammenfassung für den Ungeduldigen

Das Makro \Sstellt der Eingabe ein aktives Zeichen voran, das Bdurch ein letztes Leerzeichen begrenzte Tokenlisten aufnimmt und an dieses übergibt C. CNimmt das erste Token in dieser Liste und verschiebt es an das Ende der Tokenliste und erweitert es Dum das verbleibende. Dprüft, ob "was bleibt" leer ist; in diesem Fall wurde ein Wort mit einem Buchstaben gefunden; unternimmt dann nichts; sonst expandiert E. EDurchläuft die Token-Liste, bis der letzte Buchstabe des Wortes gefunden wird. Wenn er gefunden wird, verlässt er den letzten Buchstaben, gefolgt von der Wortmitte, gefolgt von dem ersten Buchstaben, der am Ende des Token-Streams von verbleibt C.

JavaScript (ES6),  39  36 Bytes

3 Bytes dank @FryAmTheEggman gespart

Verwendet einen Zeilenumbruch als Trennzeichen.

s=>s.replace(/(.)(.*)(.)/g,'$3$2$1')

Probieren Sie es online!

Netzhaut ,8 5 Bytes

,V,,`

Probieren Sie es online!

3 Bytes gespart dank Kevin Cruijssen !

Verwendet eine neue Zeile als Trennzeichen. Wir nutzen die Rückwärtsstufe von Retina und einige Grenzen. Die erste Grenze ist, auf welche Übereinstimmungen die Umkehrung angewendet werden soll. Wir wählen also alle mit aus ,. Dann wollen wir, dass der erste und der letzte Buchstabe jedes Matches vertauscht werden, also nehmen wir jeden Buchstaben in den Bereich, ,,der sich in einen Bereich vom Anfang bis zum Ende mit der Schrittgröße Null übersetzt.

Pepe , 107 105 Bytes

REEeREeeEeeeeerEEreREEEeREEEEEEeREEEErEEREEEEEEEreererEEEeererEEEerEEeERrEEEeerEEeerereeerEEEEeEEEReEeree

Probieren Sie es online!

Erläuterung:

Notation zu Kommentaren: command-explanation -> (stack) // explanation

REEe # input -> (R)
REeeEeeeee # push space to last -> (R) // this prevents an infinite loop

rEE # create loop labeled 0 and automatically push 0 
  re # pop 0 -> (r)
  REEEe # go to last item -> (R)
  REEEEEEe # ...then copy the char to other stack
  REEEE # go to first item -> (R)

  rEE # create loop labeled 32 // detect space
    REEEEEEE # move item to other stack (R)
  ree # do this while char != 32

  re # pop 32 -> (r)
  rEEEee # push item (dup to end) -> (r)
  re # ...then pop -> (r)
  rEEEe rEEeE # go to 2nd to last item -> (r)
  RrEEEee # push the item (R flag: dup to first) -> (r)
  rEEee # go to next -> (r) //
  re # ...then pop -> (r)
  reee rEEEEeEEE # out all as char then clear -> (r)
  ReEe # out 32 as char -> (R)
ree # do this while stack != 0

Python 3 , 72-58 Bytes

print(*[x[-1]+x[1:-1]+x[:x>x[0]]for x in input().split()])

Probieren Sie es online!

LaskelH , 71 Bytes

h=reverse
s(x:y:o)=a:h(x:r)where(a:r)=h$y:o
s o=o
f=unwords.map s.words

Probieren Sie es online!

Beispiel Ein- / Ausgabe:

Swap the first and last letter in each word
This also works with single letter words like a

It is basically just a straight up implementation in which
I for words consisting of two or more letters cons the head
of the reversed tail on the reverse of the original head consed
on the reversed tail

Note that the rules say that we only have to support one kind
of separator - I am choosing spaces Technically it works with
other whitespace as well, but it will turn everything into spaces
in the end Line endings in this example usage are handled separately
to make the example output look nicer

pwaS eht tirsf dna tasl rettel ni hace dorw
shiT olsa sorkw hitw eingls rettel sordw eikl a

tI si yasicallb tusj a ttraighs pu nmplementatioi ni hhicw
I rof sordw gonsistinc fo owt ro eorm setterl sonc eht deah
fo eht deverser lait no eht eeversr fo eht lriginao deah donsec
no eht deverser lait

eotN that eht suler yas that ew ynlo eavh ot tuppors eno dink
fo reparatos - I ma ghoosinc spaces yechnicallT ti sorkw hitw
rtheo ehitespacw sa ,ellw tub ti lilw nurt gverythine onti spaces
ni eht dne einL sndinge ni shit example esagu era dandleh yeparatels
ot eakm eht example tutpuo kool ricen
```

05AB1E , 10 Bytes

#vyRćsRćðJ

Probieren Sie es online!

-3 Danke an @Kevin Cruijssen .

#           | Split into words.
 vy         | For each word...
   RćsRć    | Reverse, split head, swap, reverse, split tail
        ðJ  | Join by spaces.

J , 23 17 Bytes

({:,1|.}:)&.>&.;:

Probieren Sie es online!

Ruby mit -p, 42 41 29 Byte

gsub /(\w)(\w*)(\w)/,'\3\2\1'

Probieren Sie es online!

Haskell, 54 Bytes

unwords.map f.words
f[a]=[a]
f(a:b)=last b:init b++[a]

Probieren Sie es online!

Japt -S , 7 Bytes

¸®ÎiZÅé

Versuch es

PowerShell , 37 Byte

$args-replace'(\w)(\w*)(\w)','$3$2$1'

Probieren Sie es online!

Stax , 8 Bytes

Σq╞♪áZN¢

Führen Sie es aus und debuggen Sie es

Verwendet Zeilenumbrüche als Worttrennzeichen.

Leerzeichen , 179 Bytes

[N
S S S N
_Create_Label_OUTER_LOOP][S S S N
_Push_n=0][N
S S T   N
_Create_Label_INNER_LOOP][S N
S _Duplicate_n][S N
S _Duplicate_n][S N
S _Duplicate_n][T   N
T   S _Read_STDIN_as_character][T   T   T   _Retrieve_input][S S S T    S T T   N
_Push_11][T S S T   _Subtract_t=input-11][N
T   T   S S N
_If_t<0_jump_to_Label_PRINT][S S S T    N
_Push_1][T  S S S _Add_n=n+1][N
S N
T   N
_Jump_to_Label_INNER_LOOP][N
S S S S N
_Create_Label_PRINT][S S S T    N
_Push_1][T  S S T   _Subtract_n=n-1][S N
S _Duplicate_n][S N
S _Duplicate_n][N
T   S N
_If_n==0_jump_to_Label_PRINT_TRAILING][T    T   T   _Retrieve][T    N
S S _Print_as_character][S S S N
_Push_s=0][N
S S S T N
_Create_Label_PRINT_LOOP][S S S T   N
_Push_1][T  S S S _Add_s=s+1][S N
S _Duplicate_s][S T S S T   S N
_Copy_0-based_2nd_n][T  S S T   _Subtract_i=s-n][N
T   S N
_If_0_Jump_to_Label_PRINT_TRAILING][S N
S _Duplicate_s][T   T   T   _Retrieve][T    N
S S _Print_as_character][N
S T S T N
_Jump_to_Label_PRINT_LOOP][N
S S N
_Create_Label_PRINT_TRAILING][S S S N
_Push_0][T  T   T   _Retrieve][T    N
S S _Print_as_character][S S S T    S S T   N
_Push_9_tab][T  N
S S _Print_as_character][N
S N
S N
_Jump_to_Label_OUTER_LOOP]

Buchstaben S(Leerzeichen), T(Tabulator) und (Zeilenvorschub) werden Nnur als Hervorhebungen hinzugefügt.
[..._some_action]nur als Erklärung hinzugefügt.

Tabulator als Trennzeichen. Die Eingabe sollte einen abschließenden Zeilenumbruch (oder einen Tabulator) enthalten, da das Programm sonst nicht weiß, wann es anhalten soll, da die Eingabe in Whitespace jeweils nur für ein Zeichen erfolgen kann.

Probieren Sie es online aus (nur mit Leerzeichen, Tabulatoren und Zeilenumbrüchen).

Erklärung im Pseudocode:

$[0, ..., \text{word_length}]$

Start OUTER_LOOP:
  Integer n = 0
  Start INNER_LOOP:
    Character c = STDIN as character, saved at heap-address n
    If(c == '\t' OR c == '\n'):
      Jump to PRINT
    n = n + 1
    Go to next iteration of INNER_LOOP

  PRINT:
    n = n - 1
    If(n == 0): (this means it was a single-letter word)
      Jump to PRINT_TRAILING
    Character c = get character from heap-address n
    Print c as character
    Integer s = 0

    Start PRINT_LOOP:
      s = s + 1
      If(s - n == 0):
        Jump to PRINT_TRAILING
      Character c = get character from heap-address s
      Print c as character
      Go to next iteration of PRINT_LOOP

    PRINT_TRAILING:
      Character c = get character from heap-address 0
      Print c as character
      Print '\t'
      Go to next iteration of OUTER_LOOP

Das Programm wird mit einem Fehler beendet, wenn versucht wird, ein Zeichen zu lesen, wenn in TIO kein Zeichen angegeben ist (oder wenn es in einigen Whitespace-Compilern wie vii5ard auf eine Eingabe wartet ).

Wolfram Language (Mathematica) , 58 Byte

StringReplace[#,a:u~~w:u..~~b:u:>b<>w<>a/.{u->Except@#2}]&

Probieren Sie es online!

-22 Bytes von @attinat

-12 Bytes von @ M.Stern

QuadR , 20 Bytes

(\w)(\w*)(\w)
\3\2\1

Bilden Sie einfach drei Erfassungsgruppen, die aus 1, 0 oder mehr und 1 Wortzeichen bestehen, und kehren Sie dann ihre Reihenfolge um.

Probieren Sie es online!

APL + WIN, 50 Bytes

(∊¯1↑¨s),¨1↓¨(¯1↓¨s),¨↑¨s←((+\s=' ')⊂s←' ',⎕)~¨' '

Fordert zur Eingabe einer Zeichenfolge auf und verwendet Leerzeichen als Begrenzer.

Probieren Sie es online! Mit freundlicher Genehmigung von Dyalog Classic

Japt -S , 10 Bytes

Ich bin davon überzeugt, dass es einen kürzeren Ansatz geben muss (und ich hatte Recht ), aber das reicht für den Moment.

¸ËhJDg)hDÌ

Versuch es

¸ËhJDg)hDÌ     :Implicit input of string
¸              :Split on spaces
 Ë             :Map each D
  h            :  Set the character at
   J           :    Index -1 to
    Dg         :    The first character in D
      )        :  End set
       h       :  Set the first character to
        DÌ     :    The last character in D
               :Implicit output, joined by spaces

sed, 64 bytes

sed -E 's/\b([[:alpha:]])([[:alpha:]]*)([[:alpha:]])\b/\3\2\1/g'

sed , 34 bytes

Und vermutlich funktioniert die Musteridee mit den meisten RE-Tools (und ich weiß, dass es Unterschiede zwischen Standard-RE und erweitertem RE gibt).

s,\b\(\w\)\(\w*\)\(\w\)\b,\3\2\1,g

Probieren Sie es online!

Ruby, 53 Bytes

gets.split(" ").map{|z|print z[-1]+z[1..-2]+z[0]," "}

Ich habe es ohne Regex versucht. Die Ausgabe druckt jedes Wort in einer neuen Zeile. Wenn das gegen die Regeln verstößt, lass es mich wissen und ich werde es reparieren.

Ungolfed:

gets.split(" ").map {|z|
    print z[-1] + z[1..-2] + z[0], " "
}

8088 Assembly, IBM PC DOS, 39 38 Bytes

$ xxd pwas.com
00000000: d1ee ac8a c8fd 03f1 c604 244e 8bfe ac3c  ..........$N...<
00000010: 2075 098a 2586 6402 8825 8bfe e2f0 b409   u..%.d..%......
00000020: ba82 00cd 21c3

Zerlegt:

D1 EE       SHR  SI, 1          ; point SI to DOS PSP (080H) 
AC          LODSB               ; load string length into AL 
8A C8       MOV  CL, AL         ; load string length into CX for loop
FD          STD                 ; set LODSB to decrement 
03 F1       ADD  SI, CX         ; point SI to end of string 
C6 04 24    MOV  BYTE PTR[SI], '$' ; put a '$' DOS string terminator at end 
4E          DEC  SI             ; start at last char of word 
8B FE       MOV  DI, SI         ; point DI to last char of word 
        CHR_LOOP: 
AC          LODSB               ; load next (previous?) char into AL 
3C 20       CMP  AL, ' '        ; is it a space? 
75 0A       JNE  END_CHR        ; if so, continue loop 
8A 25       MOV  AH, [DI]       ; put last char in AH 
86 64 02    XCHG AH, [SI][2]    ; swap memory contents of first char with last 
                                ; (unfortunately XCHG cannot swap mem to mem)
88 25       MOV  [DI], AH       ; put first char value into last char position 
8B FE       MOV  DI, SI         ; point DI last char of word 
        END_CHR:
E2 EF       LOOP CHR_LOOP       ; continue loop 
B4 09       MOV  AH, 9          ; DOS display string function 
BA 0082     MOV  DX, 082H       ; output string is at memory address 82H 
CD 21       INT  21H            ; display string to screen 
C3          RET                 ; return to DOS 

Standalone-PC-DOS-Programm. Eingabe über Kommandozeilenargumente, Ausgabe auf Bildschirm.

Laden Sie PWAS.COM herunter und testen Sie es .

Perl 5 -p , 24 Bytes

s/(\w)(\w*)(\w)/$3$2$1/g

Probieren Sie es online!

Batch, 141 Bytes

@set t=
@for %%w in (%*)do @call:c %%w
@echo%t%
@exit/b
:c
@set s=%1
@if not %s%==%s:~,1% set s=%s:~-1%%s:~1,-1%%s:~,1%
@set t=%t% %s%

Übernimmt Eingaben als Befehlszeilenparameter. Die Manipulation von Zeichenfolgen ist im Batch-Modus am besten, und es hilft nicht, einzelne Buchstaben in Sonderfällen zu verwenden.

C # (Visual C # Interactive Compiler) , 90 Byte

n=>n.Split().Any(x=>WriteLine(x.Length<2?x:x.Last()+x.Substring(1,x.Length-2)+x[0])is int)

Verwendet Newline als Begrenzer, obwohl wirklich jedes Leerzeichen verwendet werden kann.

Probieren Sie es online!

Icon , 76 Bytes

link segment
procedure f(s)
w:=!seglist(s,' ')&w[1]:=:w[-1]&writes(w)&\x
end

Probieren Sie es online!

Java, 110 bis 109 Bytes

-1 Byte unter Verwendung einer Newline als Delimeter

s->{int l;for(var i:s.split("\n"))System.out.println(i.charAt(l=i.length()-1)+i.substring(1,l)+i.charAt(0));}

TIO

Haskell , 75 74 Bytes

Es wurde ein Fehler behoben, auf den Cubic verwies und der auch 1 Byte weniger bedeutete.

f=unwords.map(#v).words
x#g=g(r$tail x)++[x!!0]
r=reverse
v[]=[]
v x=r$x#r

Probieren Sie es online!

Scala, 100 Bytes

(b:String,c:String)=>b.split(c)map(f=>f.tail.lastOption++:(f.drop(1).dropRight(1)+f.head))mkString c

T-SQL, 126 Bytes

SELECT STRING_AGG(STUFF(STUFF(value,1,1,RIGHT(value,1)),LEN(value),1,LEFT(value,1)),' ')
FROM STRING_SPLIT((SELECT*FROM t),' ')

Die Eingabe erfolgt über eine bereits vorhandene Tabelle t mit varchar Feld v , je unseren IO - Standards .

Lesen von hinten nach vorne, STRING_SPLITAufteilen einer Zeichenfolge in einzelne Zeilen über ein Trennzeichen, STUFFÄndern der Zeichen an den angegebenen Positionen und STRING_AGGerneutes Zusammenfügen der Zeichen .