# pwaS eht tirsf dna tasl setterl fo hace dorw

Or, "Swap the first and last letters of each word"

Your challenge is to, given a string of alphabetical ASCII characters as well as one other character to use as a delimiter (to separate each word), swap the first and last letters of each word. If there is a one-character word, leave it alone.

The examples/testcases use the lowercase letters and the space as the delimiter.

You do not need to handle punctuation; all of the inputs will only consist of the letters a through z, separated by a delimiter, all of a uniform case.

For example, with the string "hello world":

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"

NOTE: the delimiter does not need to be inputted separately. The delimiter is just the character used to separate words. It can be anything. I wanted to leave options open for creative golfers, so I did not want to limit it to just spaces or new lines. The delimiter is just a character that separates words in the input string.

Test cases:

"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"
"yay racecar" -> "yay racecar"
• How should punctuation be treated? Hello, world! becomes ,elloH !orldw (swapping punctuation as a letter) or oellH, dorlw! (keeping punctuation in place)? – Phelype Oleinik May 16 at 19:23
• @PhelypeOleinik You do not need to handle punctuation; all of the inputs will only consist of the letters a through z, and all a uniform case. – Comrade SparklePony May 16 at 19:24
• Second paragraph reads as well as one other character to use as a delimiter while the fourth reads separated by spaces. Which one is it? – Adám May 16 at 19:46
• @Adám Any non-alphabetic character. I’ll edit to clarify. – Comrade SparklePony May 16 at 21:36
• @BenjaminUrquhart Yes. You can take input as a function argument if you want as well. – Comrade SparklePony May 16 at 21:44

# TeX, 216 bytes (4 lines, 54 characters each)

Because it's not about the byte count, it's about the quality of the typeset output :-)

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

Try it Online! (Overleaf; not sure how it works)

Full test file:

{\let~\catcode~A13 \defA#1{~#113\gdef}AGG#1{~#1 13%
\global\let}GFF\elseGHH\fiAQQ{Q}AII{\ifxQ}AEE#1#2#3|{%
#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

Output:

For LaTeX you just need the 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|{%
#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}

## Explanation

TeX is a strange beast. Reading normal code and understanding it is a feat by itself. Understanding obfuscated TeX code goes a few steps further. I'll try to make this understandable for people who don't know TeX as well, so before we start here's a few concepts about TeX to make things easier to follow:

### For (not so) absolute TeX beginners

• First, and most important item in this list: the code does not have to be in rectangle shape, even though pop culture might lead you to think so.

• TeX is a macro expansion language. You can, as an example, define \def\sayhello#1{Hello, #1!} and then write \sayhello{Code Golfists} to get TeX to print Hello, Code Golfists!. This is called an “undelimited macro”, and to feed it the first (and only, in this case) parameter you enclose it in braces. TeX removes those braces when the macro grabs the argument. You can use up to 9 parameters: \def\say#1#2{#1, #2!} then \say{Good news}{everyone}.

• The counterpart of undelimited macros are, unsurprisingly, delimited ones :) You could make the previous definition a tad more semantical: \def\say #1 to #2.{#1, #2!}. In this case the parameters are followed by so-called parameter text. Such parameter text delimits the argument of the macro (#1 is delimited by ␣to␣, spaces included, and #2 is delimited by .). After that definition you can write \say Good news to everyone., which will expand to Good news, everyone!. Nice, isn't it? :) However a delimited argument is (quoting the TeXbook) “the shortest (possibly empty) sequence of tokens with properly nested {...} groups that is followed in the input by this particular list of non-parameter tokens”. This means that the expansion of \say Let's go to the mall to Martin will produce a weird sentence. In this case you'd need to “hide” the first ␣to␣ with {...}: \say {Let's go to the mall} to Martin.

• So far so good. Now things start to get weird. When TeX reads a character (which is defined by a “character code”), it assigns that character a “category code” (catcode, for friends :) which defines what that character will mean. This combination of character and category code makes a token (more on that here, for example). The ones which are of interest for us here are basically:

• catcode 11, which define tokens which can make up a control sequence (a posh name for a macro). By default all letters [a-zA-Z] are catcode 11, so I can write \hello, which is one single control sequence, while \he11o is the control sequence \he followed by two characters 1, followed by the letter o, because 1 is not catcode 11. If I did \catcode1=11, from that point on \he11o would be one control sequence. One important thing is that catcodes are set when TeX first sees the character at hand, and such catcode is frozen... FOREVER! (terms and conditions may apply)

• catcode 12, which are most of other characters, such as 0"!@*(?,.-+/ and so forth. They are the least special type of catcode as they serve only for writing stuff on the paper. But hey, who uses TeX for writing?!? (again, terms and conditions may apply)

• catcode 13, which is hell :) Really. Stop reading and go do something out of your life. You don't want to know what catcode 13 is. Ever heard of Friday, 13th? Guess where it got its name from! Continue at your own risk! A catcode 13 character, also called an “active” character, is not just a character anymore, it is a macro itself! You can define it to have parameters and expand to something like we saw above. After you do \catcodee=13 you think you can do \def e{I am the letter e!}, BUT. YOU. CANNOT! e is not a letter anymore, so \def is not the \def you know, it is \d e f! Oh, choose another letter you say? Okay! \catcodeR=13 \def R{I am an ARRR!}. Very well, Jimmy, try it! I dare you do that and write an R in your code! That's what a catcode 13 is. I AM CALM! Let's move on.

• Okay, now to grouping. This is fairly straightforward. Whatever assignments (\def is an assignment operation, \let (we'll get into it) is another) done in a group are restored to what they were before that group started unless that assignment is global. There are several ways to start groups, one of them is with catcode 1 and 2 characters (oh, catcodes again). By default { is catcode 1, or begin-group, and } is catcode 2, or end-group. An example: \def\a{1} \a{\def\a{2} \a} \a This prints 1 2 1. Outside the group \a was 1, then inside it was redefined to 2, and when the group ended, it was restored to 1.

• The \let operation is another assignment operation like \def, but rather different. With \def you define macros which will expand to stuff, with \let you create copies of already existing things. After \let\blub=\def (the = is optional) you can change the start of the e example from the catcode 13 item above to \blub e{... and have fun with that one. Or better, instead of breaking stuff you can fix (would you look at that!) the R example: \let\newr=R \catcodeR=13 \def R{I am an A\newr\newr\newr!}. Quick question: could you rename to \newR?

• Finally, the so-called “spurious spaces”. This is kind of a taboo topic because there are people who claim that reputation earned in the TeX - LaTeX Stack Exchange by answering “spurious spaces” questions should not be considered, while others wholeheartedly disagree. Whom do you agree with? Place your bets! Meanwhile: TeX understands a line break as a space. Try to write several words with a line break (not an empty line) between them. Now add a % at the end of these lines. It's like you were “commenting out” these end-of-line spaces. That's it :)

### (Sort of) ungolfing the code

Let's make that rectangle into something (arguably) easier to follow:

{
\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}
ACC#1#2|{D{}#2Q|#1 }
ABBH#1 {HI#1FC#1|BH}
\gdef\S#1{\iftrueBH#1 Q }
}

### Explanation of each step

each line contains one single instruction. Let's go one by one, dissecting them:

{
First we start a group to keep some changes (namely catcode changes) local so that they don't mess up the input text.

\let~\catcode
Basically all TeX obfuscation codes start with this instruction. By default, both in plain TeX and LaTeX, the ~ character is the one active character which can be made into a macro for further use. And the best tool for weirdifying TeX code are catcode changes, so this is generally the best choice. Now instead of \catcodeA=13 we can write ~A13 (the = is optional):

~A13
Now the letter A is an active character, and we can define it to do something:

\defA#1{~#113\gdef}
A is now a macro that takes one argument (which should be another character). First the catcode of the argument is changed to 13 to make it active: ~#113 (replace the ~ by \catcode and add an = and you have: \catcode#1=13). Finally it leaves a \gdef (global \def) in the input stream. In short, A makes another character active and start its definition. Let's try it:

AGG#1{~#113\global\let}
AG first “activates” G and does \gdef, which followed by the next G starts the definition. The definition of G is very similar to that of A, except that instead of \gdef it does a \global\let (there isn't a \glet like the \gdef). In short, G activates a character and makes it be something else. Let's make shortcuts for two commands we'll use later:

GFF\else
GHH\fi
Now instead of \else and \fi we can simply use F and H. Much shorter :)

AQQ{Q}
Now we use A again to define another macro, Q. The above statement basically does (in a less obfuscated language) \def\Q{\Q}. This isn't a terribly interesting definition, but it has an interesting feature. Unless you do want to break some code, the only macro that expands to Q is Q itself, so it acts like a unique marker (it's called a quark). You can use the \ifx conditional to test if the argument of a macro is such quark with \ifx Q#1:

AII{\ifxQ}
so you can be pretty sure that you found such a marker. Notice that in this definition I removed the space between \ifx and Q. Usually this would lead to an error (note that the syntax highlight thinks that \ifxQ is one thing), but since now Q is catcode 13 it cannot form a control sequence. Be careful, however, not to expand this quark or you'll get stuck in an infinite loop because Q expands to Q which expands to Q which...

Now that the preliminaries are done, we can go to the proper algorithm to pwas eht setterl. Due to TeX's tokenization the algorithm has to be written backwards. This is because at the time you do a definition TeX will tokenize (assign catcodes) to the characters in the definition using the current settings so, for example, if I do:

\def\one{E}
\catcodeE=13\def E{1}
\one E

the output is E1, whereas if I change the order of the definitions:

\catcodeE=13\def E{1}
\def\one{E}
\one E

the output is 11. This is because in the first example the E in the definition was tokenized as a letter (catcode 11) before the catcode change, so it will always be a letter E. In the second example, however, E was first made active, and only then \one was defined, and now the definition contains the catcode 13 E which expands to 1.

I will, however, overlook this fact and reorder the definitions to have a logical (but not working) order. In the following paragraphs you can assume that the letters B, C, D, and E are active.

\gdef\S#1{\iftrueBH#1 Q }
(notice there was a small bug in the previous version, it did not contain the final space in the definition above. I only noticed it while writing this. Read on and you'll see why we need that one to properly terminate the macro.)
First we define the user-level macro, \S. This one shouldn't be an active character to have a friendly (?) syntax, so the macro for gwappins eht setterl is \S. The macro starts with an always-true conditional \iftrue (it will soon be clear why), and then calls the B macro followed by H (which we defined earlier to be \fi) to match the \iftrue. Then we leave the argument of the macro #1 followed by a space and by the quark Q. Suppose we use \S{hello world}, then the input stream should look like this: \iftrue BHhello world Q␣ (I replaced the last space by a so that the rendering of the site does not eat it, like I did in the previous version of the code). \iftrue is true, so it expands and we are left with BHhello world Q␣. TeX does not remove the \fi (H) after the conditional is evaluated, instead it leaves it there until the \fi is actually expanded. Now the B macro is expanded:

ABBH#1 {HI#1FC#1|BH}
B is a delimited macro whose parameter text is H#1␣, so the argument is whatever is between H and a space. Continuing the example above the input stream prior to the expansion of B is BHhello world Q␣. B is followed by H, as it should (otherwise TeX would raise an error), then the next space is between hello and world, so #1 is the word hello. And here we got to split the input text at the spaces. Yay :D The expansion of B removes everything up to the first space from the input stream and replaces by HI#1FC#1|BH with #1 being hello: HIhelloFChello|BHworld Q␣. Notice that there is a new BH later in the input stream, to do a tail recursion of B and process later words. After this word is processed B processes the next word until the word-to-be-processed is the quark Q. The last space after Q is needed because the delimited macro B requires one at the end of the argument. With the previous version (see edit history) the code would misbehave if you used \S{hello world}abc abc (the space between the abcs would vanish).

OK, back to the input stream: HIhelloFChello|BHworld Q␣. First there's the H (\fi) that completes the initial \iftrue. Now we have this (pseudocoded):

I
hello
F
Chello|B
H
world Q␣

The I...F...H think is actually a \ifx Q...\else...\fi structure. The \ifx test checks if the (first token of the) word grabbed is the Q quark. If it is there is nothing else to do and the execution terminates, otherwise what remains is: Chello|BHworld Q␣. Now C is expanded:

ACC#1#2|{D#2Q|#1 }
The first argument of C is undelimited, so unless braced it will be a single token, The second argument is delimited by |, so after the expansion of C (with #1=h and #2=ello) the input stream is: DelloQ|h BHworld Q␣. Notice that another | is put there, and the h of hello is put after that. Half the swapping is done; the first letter is at the end. In TeX it is easy to grab the first token of a token list. A simple macro \def\first#1#2|{#1} gets the first letter when you use \first hello|. The last one is a problem because TeX always grabs the “smallest, possibly empty” token list as argument, so we need a few work-arounds. Next item in the token list is D:

This D macro is one of the work-arounds and it's useful in the sole case where the word has a single letter. Suppose instead of hello we had x. In this case the input stream would be DQ|x, then D would expand (with #1=Q, and #2 empty) to: IQFE{}Q|Hx. This is similar to the I...F...H (\ifx Q...\else...\fi) block in B, which will see that the argument is the quark and will interrupt the execution leaving only x for typesetting. In other cases (returning to the hello example), D would expand (with #1=e and #2=lloQ) to: IeFE{}elloQ|Hh BHworld Q␣. Again, the I...F...H will check for Q but will fail and take the \else branch: E{}elloQ|Hh BHworld Q␣. Now the last piece of this thing, the E macro would expand:

AEE#1#2#3|{I#3#2#1FE{#1#2}#3|H}
The parameter text here is quite similar to C and D; the first and second arguments are undelimited, and the last one is delimited by |. The input stream looks like this: E{}elloQ|Hh BHworld Q␣, then E expands (with #1 empty, #2=e, and #3=lloQ): IlloQeFE{e}lloQ|HHh BHworld Q␣. Another I...F...H block checks for the quark (which sees l and returns false): E{e}lloQ|HHh BHworld Q␣. Now E expands again (with #1=e empty, #2=l, and #3=loQ): IloQleFE{el}loQ|HHHh BHworld Q␣. And again I...F...H. The macro does a few more iterations until the Q is finally found and the true branch is taken: E{el}loQ|HHHh BHworld Q␣ -> IoQlelFE{ell}oQ|HHHHh BHworld Q␣ -> E{ell}oQ|HHHHh BHworld Q␣-> IQoellFE{ello}Q|HHHHHh BHworld Q␣. Now the quark is found and the conditional expands to: oellHHHHh BHworld Q␣. Phew.

Oh, wait, what are these? NORMAL LETTERS? Oh, boy! The letters are finally found and TeX writes down oell, then a bunch of H (\fi) are found and expanded (to nothing) leaving the input stream with: oellh BHworld Q␣. Now the first word has the first and last letters swapped and what TeX finds next is the other B to repeat the whole process for the next word.

}
Finally we end the group started back there so that all local assignments are undone. The local assignments are the catcode changes of the letters A, B, C, ... which were made macros so that they return to their normal letter meaning and can be safely used in the text. And that's it. Now the \S macro defined back there will trigger the processing of the text as above.

One interesting thing about this code is that it is fully expandable. That is, you can safely use it in moving arguments without worrying that it will explode. You can even use the code to check if the last letter of a word is the same as the second (for whatever reason you would need that) in an \if test:

\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

Sorry for the (probably far too) wordy explanation. I tried to make it as clear as possible for non TeXies as well :)

### Summary for the impatient

The macro \S prepends the input with an active character B which grabs lists of tokens delimited by a final space and passes them to C. C takes the first token in that list and moves it to the end of the token list and expands D with what remains. D checks if “what remains” is empty, in which case a single-letter word was found, then do nothing; otherwise expands E. E loops through the token list until it finds the last letter in the word, when it is found it leaves that last letter, followed by the middle of the word, which is then followed by the first letter left at the end of the token stream by C.

• I would love a full explanation of this one. I'm very curious as to how it works! – LambdaBeta May 18 at 19:55
• @LambdaBeta I can do it, but not right now. Hold on and I'll ping you when I do it :) – Phelype Oleinik May 18 at 20:38
• @LambdaBeta Done! Sorry, I'm too wordy sometimes :-) – Phelype Oleinik May 20 at 20:25

# JavaScript (ES6),  39  36 bytes

Saved 3 bytes thanks to @FryAmTheEggman

Uses a linefeed as separator.

s=>s.replace(/(.)(.*)(.)/g,'$3$2$1') Try it online! • (.)(.*)(.) is that the Total Recall emoticon? – MikeTheLiar May 17 at 15:34 • @MikeTheLiar Kind of, I guess. :D – Arnauld May 17 at 16:12 • The assignment specifies the string contains the separator. – Cees Timmerman May 18 at 21:12 • @CeesTimmerman I'm not sure what you mean. This code expects a linefeed as separator and therefore takes strings with linefeeds as input. (The footer of the TIO link converts spaces to linefeeds and then back to spaces for readability.) – Arnauld May 18 at 21:29 • "given a string of alphabetical ASCII characters as well as one other character to use as a delimiter (to separate each word)" - Nm, i thought it was a separate parameter. – Cees Timmerman May 18 at 21:32 # Retina, 8 5 bytes ,V,, Try it online! Saved 3 bytes thanks to Kevin Cruijssen! Uses a newline as the separator. We make use of Retina's reverse stage and some limits. The first limit is which matches to apply the reversal to, so we pick all of them with ,. Then we want the first and last letter of each match to be swapped, so we take each letter in the range ,, which translates to a range from the beginning to the end with step size zero. • Dangit, I was just searching through the docs for something like this to update my answer, but you beat me to it. I knew about V, but didn't knew it could be used with the indices 1,-2 like that. Nice one! – Kevin Cruijssen May 16 at 20:23 • @KevinCruijssen I cheated a little and reviewed how limit ranges worked while this was in the sandbox :) I still feel like there should be a better way than inverting a range but I haven't been able to find anything shorter. – FryAmTheEggman May 16 at 20:28 • You're indeed right that it can be shorter without a limit-range, because it seems this 5-byter works (given as example at the bottom of the Step Limits in the docs). – Kevin Cruijssen May 16 at 20:41 • @KevinCruijssen Nice! Can't believe I missed that. – FryAmTheEggman May 16 at 20:51 • So, 5 bytes and only 3 different characters? That's minimalist. – Cœur May 17 at 5:37 # Pepe, 107 105 bytes REEeREeeEeeeeerEEreREEEeREEEEEEeREEEErEEREEEEEEEreererEEEeererEEEerEEeERrEEEeerEEeerereeerEEEEeEEEReEeree Try it online! Explanation: Notation on comments: 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 • How does this work? – lirtosiast May 29 at 10:05 • @lirtosiast explanation added – u_ndefined May 29 at 10:33 # Python 3, 72 58 bytes print(*[x[-1]+x[1:-1]+x[:x>x[0]]for x in input().split()]) Try it online! • Doesn't work for one letter words (eg a) – TFeld May 16 at 19:37 • @TFeld, fixed.. – alexz02 May 16 at 19:55 # 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

Try it online!

Example in/output:

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
$$`$$
• The assignment in the where clause can be moved to a binding in guard to save 5 bytes: Try it online! – Laikoni May 19 at 13:16
• I see what you did there with the name "Haskell" in the title. I did the same thing on my PHP answer. – 640KB May 19 at 15:20

# 05AB1E, 10 bytes

#vyRćsRćðJ

Try it online!

-3 Thanks to @Kevin Cruijssen.

#           | Split into words.
vy         | For each word...
RćsRć    | Reverse, split head, swap, reverse, split tail
ðJ  | Join by spaces.
• 10 bytes – Kevin Cruijssen May 16 at 19:58
• @KevinCruijssen I honestly want to delete it and give it to you, that was 99% your brainpower on the ordering of the arguments haha. – Magic Octopus Urn May 16 at 20:29
• Found a 9-byter, but it only works in the legacy version: |ʒRćsRćJ, – Kevin Cruijssen May 16 at 21:10
• Too bad we don't have a loop_as_long_as_there_are_inputs, then I would have known an 8-byter: [RćsRćJ, This 8-byter using [ never outputs in theory however, only when you're out of memory or time out like on TIO (and it requires a trailing newline in the input, otherwise it will keep using the last word).. – Kevin Cruijssen May 16 at 21:15
• Unfortunately you need ð¡ as single word input is possible, but ð¡εćsÁì}ðý also works at 10 bytes. – Emigna May 17 at 6:06

# J, 23 17 bytes

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

Try it online!

• Very nice trick to swap the first/last letters by rotating and applying 1 A. ! – Galen Ivanov May 17 at 8:55
• 1&A.&.(1&|.) -> ({:,1|.}:) and then you can remove the ::] – ngn May 17 at 21:04
• Amazing, thank you – FrownyFrog May 17 at 21:09
• Really amazing! Once again I'm amazed how simple and elegant can the solution be, but only after I see it done by someone else. – Galen Ivanov May 18 at 6:43

# Ruby with -p, 4241 29 bytes

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

Try it online!

• We no longer include flags in byte counts – Shaggy May 16 at 21:50
• @Shaggy thanks for the heads up. If you look at my post history it shows I was away for 8 months without any answers, so I've likely missed a few memos during that time, haha – Value Ink May 16 at 21:57
• Pretty sure the consensus was changed more than 8 months ago but just in case you missed it: "non-competing" is also no longer a thing. – Shaggy May 16 at 21:58
• Nicely done. I think under the rules you can use newlines as your delimiter and replace the \ws with .s. – histocrat May 17 at 18:23

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

Try it online!

# Japt-S, 7 bytes

¸®ÎiZÅé

Try it

• Nice! I knew there'd be a shorter way. – Shaggy May 17 at 17:44
• I am impressed. Well done – Embodiment of Ignorance May 18 at 1:21

# PowerShell, 37 bytes

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

Try it online!

# Stax, 8 bytes

Σq╞♪áZN¢

Run and debug it

Uses newlines as word separators.

# Whitespace, 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
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]

Letters S (space), T (tab), and N (new-line) added as highlighting only.

Tab as delimiter. Input should contain a trailing newline (or tab), otherwise the program doesn't know when to stop, since taking input in Whitespace can only be done one character at a time.

Try it online (with raw spaces, tabs, and new-lines only).

Explanation in pseudo-code:

Whitespace only has a stack and a heap, where the heap is a map with a key and value (both integers). Inputs can only be read one integer or character at a time, which are always placed in the heap as integers, and can then be received and pushed to the stack with their defined heap-addresses (map-keys). In my approach I store the entire word at the heap-addresses (map-keys) $$\[0, ..., \text{word_length}]\$$, and then retrieve the characters to print one by one in the order we'd want after a tab (or newline) is encountered as delimiter.

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'):
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)
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):
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

The program terminates with an error when it tries to read a character when none is given in TIO (or it hangs waiting for an input in some Whitespace compilers like vii5ard).

# Wolfram Language (Mathematica), 58 bytes

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

Try it online!

-22 bytes from @attinat

-12 bytes from @M.Stern

• 70 bytes using StringReplace with StringExpressions – attinat May 17 at 7:25
• 64 bytes using StringTake instead of StringReplace: StringRiffle[StringSplit@##~StringTake~{{-1},{2,-2},{1}},#2,""]& – Roman May 18 at 17:29
• Here is a more direct approach: StringReplace[#, a : u ~~ w : u .. ~~ b : u :> b <> w <> a /. {u -> Except@#2}] & – M. Stern May 19 at 7:44
• { and } are optional :) – M. Stern May 19 at 7:55
• 55 bytes, also fixes 2-character words – attinat May 19 at 23:59

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

Simply make three capturing groups consisting of 1, 0-or-more, and 1 word-characters, then reverses their order.

Try it online!

# APL+WIN, 50 bytes

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

Prompts for string and uses space as the delimiter.

Try it online! Courtesy of Dyalog Classic

# Japt-S, 10 bytes

Convinced there has to be a shorter approach (and I was right) but this'll do for now.

¸ËhJDg)hDÌ

Try it

¸Ë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
• Much shorter than my 12 byter: ¸®Ì+Zs1J +Zg – Embodiment of Ignorance May 17 at 3:07
• @EmbodimentofIgnorance, that's where I started, too, but it would have failed on single character words. You could save a byte on that, though, with ¸®ÎiZÌ+Zs1J. – Shaggy May 17 at 8:01
• @EmbodimentofIgnorance Found a 7 byter – Oliver May 17 at 17:21

## sed, 64 bytes

sed -E 's/\b([[:alpha:]])([[:alpha:]]*)([[:alpha:]])\b/\3\2\1/g'
• Sure, we could use . instead of [[:alpha:]], but it would actually have to be [^ ], which reduces it to 43, but breaks on punctuation and such. Using [a-zA-Z] brings it up to 55, by which point I'm just hankering after those sweet, sweet human readable entities... – Rich May 18 at 1:08
• You do not need to handle punctuation; all of the inputs will only consist of the letters a through z, separated by a delimiter, all of a uniform case. In other words, you don't need to worry about punctuation "breaking" your code and can just safely go for [^ ] ;) – Value Ink May 18 at 1:15
• @ValueInk Yeah, but then [^ ] should be [^[:space:]] which brings it to 67 chars. – Rich May 20 at 19:17
• "a delimiter" means you can ensure that the delimiter is always a regular space. Who uses tabs in a sentence anyways?? – Value Ink May 20 at 21:24
• Okay. Seems like "code golf" is a game where you're meant to find ways to get a drone to drop the ball in the hole instead of actually doing the work. Thanks for the shitty welcome. – Rich May 23 at 2:32

# sed, 34 bytes

And presumably the pattern idea will work with most RE tools (and I do know there are differences between standard RE and extended RE).

s,\b$$\w$$$$\w*$$$$\w$$\b,\3\2\1,g

Try it online!

• Welcome to PPCG! Methinks that the greedy nature of regex matches means you can cut the \b from the match: Try it online! – Value Ink May 20 at 21:29
• Agreed @ValueInk -- but I was being accurate with the match. Removing the \b will lead to 30 bytes. – PJF May 21 at 14:45
• Use -E for advanced regex and you can use unescaped parentheses. Use . for the swapped chars and you can lose another two chars. This brings yours down to 26 bytes; one of the smallest readable solutions. s,\b(.)(\w*)(.)\b,\3\2\1,g – Rich May 24 at 0:01
• - nope, I'm wrong, you need the \ws at the ends. s,\b(\w)(\w*)(\w)\b,\3\2\1,g 28 chars. – Rich May 24 at 0:13
• Nice work @rich, but as I said I know about standard and extended RE. I just chose to make it standard and readable. The anchors would be required which I neglected to mention in my reply to ValueInk. – PJF May 24 at 13:28

# Ruby, 53 bytes

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

I tried it without regex. The output prints each word on a new line. If that's against the rules, let me know and I'll fix it.

Ungolfed:

gets.split(" ").map {|z|
print z[-1] + z[1..-2] + z[0], " "
}
• Welcome to PPCG! Printing each word on a new line should be fine, but your old solution of p was no good because that added quotes to the output. You could always use puts instead since that one auto-appends the newline and is shorter than print! Also, if you call split with no arguments it automatically splits on spaces. – Value Ink May 23 at 4:06

# 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

Unassembled:

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

Standalone PC DOS executable. Input via command line args, output to screen.

# Perl 5-p, 24 bytes

s/(\w)(\w*)(\w)/$3$2$1/g Try it online! • You can get it to 21 by using the newline as separator: Try it online! – wastl May 17 at 17:38 ## 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% Takes input as command-line parameters. String manipulation is dire in Batch at best, and having to special-case single-letter words doesn't help. # C# (Visual C# Interactive Compiler), 90 bytes n=>n.Split().Any(x=>WriteLine(x.Length<2?x:x.Last()+x.Substring(1,x.Length-2)+x[0])is int) Uses newline as delimiter, though really any whitespace can be used. Try it online! • SelectMany (that is, map and flatten) for 84 bytes, but outputs a single trailing space. Try it online! – someone May 17 at 8:17 # Icon, 76 bytes link segment procedure f(s) w:=!seglist(s,' ')&w[1]:=:w[-1]&writes(w)&\x end Try it online! # Java, 110 109 bytes -1 bytes by using a newline for a 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 • Does this work for single-letter words? – Neil May 17 at 0:19 • @Neil no because I'm bad. I'll fix later. – Benjamin Urquhart May 17 at 0:20 • 109 by using newline as delimiter – Embodiment of Ignorance May 17 at 4:55 # Haskell, 75 74 bytes Fixed a bug pointed at by Cubic and also golfed down 1 byte. f=unwords.map(#v).words x#g=g(r$tail x)++[x!!0]
r=reverse
v[]=[]
v x=r$x#r Try it online! • map g is shorter than (g<$>) – Cubic May 17 at 10:17
• Also, if you look at your test case you'll see it doesn't work for one letter words, it turns a into aa – Cubic May 17 at 10:20