Haskell, 31 bytes

f(a:b:c:d:e)=a:c:f(b:d:e) f x=x 

Try it online!

Avoids having to special-case omitting the first character by having extracting it be part of the recursive definition.

brainfuck, 28 bytes

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

Try it online!

First, we print the first character. Then we read the second character and enter the main loop. (,.,[)

When entering the main loop, we expect the first character of a pair to be in the current cell, and we read the next two into the next two cells (>,>,). The tape then looks like this:

[pair1] [pair2] [nextpair1] [0] ^ 

Then, if nextpair1 exists, we know there's going to be at least one character after the current pair, so we can output the two characters in this current pair in reverse ([<.[-]<.>>>]) – the triple > at the end moves us to the location after nextpair1 to break out of the loop. Otherwise, we're at the end of the string, so we go back to pair1 (<<) and print as many characters as we received in order ([.>]).

The main loop will end here if this was the end of the string (>]). If not, recall that we ended at the [0] in the diagram above after the check to see if nextpair1 existed. So the <<[.>] would have brought the pointer to pair2 (which was cleared) instead of pair1, and then >] restarts the main loop, but with the cursor pointing at nextpair1, which is exactly what we want.

Retina, 12 bytes

V`^.|..(?=.) 

Try it online! Link includes test cases. Explanation: V reverses each match. The first character is matched separately, then characters are matched in pairs as long as there is still one character left that is unreversed.

Jelly, 8 7 bytes

Ḣ,Ṫjṭ2/ 

Try it online!

A full program taking a string as its argument and printing the swapped string. Thanks to @JonathanAllan for saving a byte!

Explanation

Ḣ | Head ,Ṫ | Paired with tail j | Join with: ṭ2/ | The remainder, pair wise reduced by tacking the left item in the pair to the end of the right 

Python 2, 49 bytes

f=lambda s:s[3:]and s[:3:2]+f(s[1:5:2]+s[4:])or s 

Try it online!

Based off my Haskell answer. I tried a more direct port using splatted input, but it was clunky:

57 bytes

f=lambda a,b,c,*d:d[1:]and a+c+f(b,*d)or a+b+c+''.join(d) 

Try it online!

APL (Dyalog Extended), 27 20 bytes^SBCS

Anonymous tacit prefix function. Requires ⎕IO←0.

⊢⊇⍨∘⍋≢⌊1+⍳∘≢+2×2|⍳∘≢ 

Try it online!

Explanation and walk-through for "Somebody" and "Character":

⍳∘≢ the indices of the length; [0,1,2,3,4,5,6,7], [0,1,2,3,4,5,6,7,8]

2| two-mod of that; [0,1,0,1,0,1,0,1], [0,1,0,1,0,1,0,1,0]

2× twice that; [0,2,0,2,0,2,0,2], [0,2,0,2,0,2,0,2,0]

⍳∘≢+ add the indices of the length to that; [0,3,2,5,4,7,6,9], [0,3,2,5,4,7,6,9,8]

1+ increment that; [1,4,3,6,5,8,7,10], [1,4,3,6,5,8,7,10,9]

≢⌊ the minimum of the length and that; [1,4,3,6,5,8,7,8], [1,4,3,6,5,8,7,9,9]

⍋ the grade (the indices that would sort it) of that; [0,2,1,4,3,6,5,7], [0,2,1,4,3,6,5,7,8]

⊢⊇⍨∘ use that to reorder the string; "Smobedoy", "Cahartcer"

Perl 6 -p, 26 bytes

s:g[^.||)>..$||..]=$/.flip 

Try it online!

Ruby, 42 bytes

f=->s{s[/(.)(.)(.)(.+)/]?$1+$3+f[$2+$4]:s} 

Try it online!

Brain-Flak, 48 40 bytes

({}<{({}<({}<>)>)<>}<>{{({}<>)<>}{}}<>>) 

Try it online!

This doesn't work for strings that contain null bytes (unless the null byte is the first byte of the string).

Explanation

({}<...>) Store the first element for later {({}<({}<>)>)<>}... Move the stack over in twos (preserving the order of each pair moved) <>{...{}}<> {({}<>)<>} Move everything back in ones 

The one complex part is the <>{...{}}<>. Since moving over in twos can pick up an extra zero from the bottom of the stack we need to removing when bringing things back. Conveniently our main loop will stop when it hits a zero, so when it hits a zero we destroy that zero and, if the next thing is not zero we try again.

This means we will only stop if there are two zeros in a row, which since the input cannot contain zeros, will only occur at the bottom of the stack. In the process we will get rid of any zeros that are present, which fixes our extra zero issue.

Works for all inputs, 114 112 bytes

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

Try it online!

Nearly all of the code is devoted to making this work for even length inputs.

Ruby -pl, 27 bytes

gsub /^.|..(?=.)/,&:reverse 

Try it online!

Alternate solution with the same bytecount, but a regex nobody else has used yet:

gsub /(^|.)(.(?=.))/,'\2\1' 

Try it online!

C++ (clang), ^{117 ... 82} 80 bytes

#import<map> #define f(s)for(int i=1;i<s.size()-2;)s[i++]^=s[i++]^=s[i+1]^=s[i]; 

Try it online!

Saved 11 bytes thanks to @AZTECCO!!!
Saved 2 bytes thanks to @ceilingcat!!!

Python 3, 62 bytes

lambda x:x[0]+re.sub("(.)(.)",r"\2\1",x[1:-1])+x[-1] import re 

Try it online!

05AB1E, 14 bytes

¦¨2ô€RJ¹θ¹н.ÁJ 

Try it online!

¦¨2ô€RJ¹θ¹н.ÁJ ¦¨ # Delete the first and last letter 2ô # Break into groups of 2 €R # Reverse each of them J # Join it back together ¹θ¹н # Push the last and first letter of the input .Á # Rotate stack, so the first letter is first J # Join the items in the stack 

Japt, 11 bytes

h1Ué ¤ò mÔq 

Try it

h1Ué ¤ò mÔq :Implicit input of string U h1 :Overwrite from the 1st (0-indexed) character on with Ué : Rotate U to the right ¤ : Slice off the first 2 characters ò : Split into pairs m : Map Ô : Reverse q : Join 

Haskell, 40 bytes

f(a:b:c:d)=b:a:f(c:d) f x=x g(a:b)=a:f b 

Try it online!

xnor has a shorter version of this answer that combines f and g into a single function.

J, ²⁴ 19 bytes

C.~[:}:_2<@|.\#\@}. 

Try it online!

Creates the boxed indexes representing the cyclic form of the permutation we need (bookeeping), and then applies it C. to the input.

Gema, 15 characters

\A?=? ??\P?=$2? 

The only interesting point here is the use of

\P       Position -- leave input stream here after the template matches

Sample run:

bash-5.0$ echo -n 'School' | gema '\A?=?;??\P?=$2?' Shcool 

Try it online! | Try all test cases online!

JavaScript (Node.js), 40 bytes

f=s=>s[3]?s[0]+s[2]+f(s[1]+s.slice(3)):s 

Try it online!

JavaScript (Node.js), 41 40 bytes

-1 bytes thanks to Arnauld

s=>s.replace(/(?!^)(.)(.)(?=.)/g,"$2$1") 

Try it online!

Python 3, 57 bytes

def f(s):s[1:-2:2],s[2:-1:2]=s[2:-1:2],s[1:-2:2];return s 

Try it online!

Accepts a list and returns a list.

The idea is to simply take the alternating slices and swap them.

Do let me know if the boilerplate stuff can be shortened in Python submissions.

C (clang), 51 48 bytes

f(char*s,z){*++s^=*s^=s[1]^=*++s;z>5&&f(s,z-2);} 

Try it online!

A recursive solution that modifies the original string

Saved 3 thanks to @ceilingcat suggestion to use ^=

x86-16 machine code, 13 bytes

Unassembled listing:

 46 INC SI ; skip first char 8B FE MOV DI, SI ; point DI to string D1 E9 SHR CX, 1 ; divide counter by 2 with round down 49 DEC CX ; skip last char CLOOP: AD LODSW ; load next two chars 86 E0 XCHG AH, AL ; reverse chars AB STOSW ; store next two chars E2 FA LOOP CLOOP ; keep looping C3 RET ; return to caller 

Input/output string in [SI], length in CX.

PC-DOS test program output:

Burlesque, 17 bytes

rt2cog_j)<-++.+RT 

Try it online!

rt # Rotate the string left 2co # Split into chunks of 2 g_j # Take pair of first and last out )<- # Reverse each chunk ++.+# Join everything back together RT # Rotate the string right 

For even length input only you can shave a single character:

RT2col_)<-++.+RT 

Fortran (GFortran), 125 bytes

character(99)a,b(99) read('(a)'),a j=len_trim(a) b=[a(1:1),(a(i+1:i+1),a(i:i),i=2,j-1,2),a(j:j)] print*,(b(i)(1:1),i=1,j) end 

Try it online!

Shame string manipulation in Fortran is so wordy as every substring needs two references. The main magic is mapping a to a character array via:

[a(1:1), ! Prepend first char (a(i+1:i+1),a(i:i), ! Swap a(i+1) for a(i) i=2,j-1,2) ! For i in 2..n-1 ,a(j:j)] ! Append last char 

J, 48 bytes

Man, I love J

(1{.]),([:,[:(|."1)_2[\1}.]}.~_1-2|#),]{.~_1-2|# 

Try it online!

Zsh, 74 71 bytes

Found a more idiomatic Zsh solution. Try it online!

w=$1;printf $w[1]${w[2,$#w-1]//(#m)(?)(?)/$MATCH[2]$MATCH[1]}${w:$#w-1} 

_{74 bytes: w=$1;printf $w[1];for i ({2..$[$#w-2]..2})printf $w[i+1]$w[i];<<<${w:$i+1}}

Charcoal, 20 bytes

§θ⁰Ｆ⪪✂θ¹±¹¦¦¦²⮌ι§θ±¹ 

Try it online! Link is to verbose version of code. Works with strings of at least 2 characters. Explanation:

§θ⁰ 

Print the first character of the string.

Ｆ⪪✂θ¹±¹¦¦¦² 

Split the inner slice of the string into 2-character substrings.

⮌ι 

Print each substring reversed.

§θ±¹ 

Print the last character of the string.

SNOBOL4 (CSNOBOL4), 104 bytes

 P =LEN(1) INPUT P . F REM . S S S P . X P . Y REM . S F =F Y X GT(SIZE(S),2) :S(S) O OUTPUT =F S END 

Try it online!

Red, 95 76 bytes

func[s][prin take s t: take/last s foreach[a b]s[prin any[b""]prin a]prin t] 

Try it online!

Directly prin(t)s the characters instead of returning a string.

Java (JDK), 43 bytes

s->s.replaceAll("(?<=.)(.)(.)(?=.)","$2$1") 

Try it online!

Without much API, 60 bytes

s->{for(int i=1;i<s.length-2;)s[i]^=s[++i]^(s[i]=s[i++-1]);} 

Try it online!

Keg, 16 bytes (SBCS)

The same program as below, with extra simplifying-ops added.

,(!½!2%¬-|$,,)(, 

Try it online!

Keg -ir, 18 bytes

You know, Jono's challenges are definitely easily doable in Keg.

,(!2/1!2%--|$,,)(, 

Try it online!

Explanation

 # Take an input from STDIN , # Step 1. Output the first item. (!2/ # Repeat half of the length-of-stack times 1!2%-- # subtract by 1 if that's odd |$,, # Swap & output the two items )(, # Output the remaining items