[Question]
  [
> 
> *Inspired by [this](https://chat.stackexchange.com/transcript/message/61463602#61463602) accidental misspelling*
> 
> 
> 
If you could read the title, then you already know what the challenge is about. If not, then I'll tell you. Easy: simply take each word (single space delimited), and swap the positions of the first two letters. You may assume that the input will contain only lowercase ASCII letters and spaces and that there will be no one-letter words. You many optionally take a list of words instead of a sentence.
## Testcases
```
hello world -> ehllo owrld
this is an easy challenge -> htis si na aesy hcallenge
reverse the first two letters of each word -> erverse hte ifrst wto eltters fo aech owrd
pptx is one of ooxml format -> pptx si noe fo ooxml ofrmat
(empty) -> (empty)
```
## Leaderboard
```
/* Configuration */
var QUESTION_ID = 249523; // Obtain this from the url
// It will be like https://XYZ.stackexchange.com/questions/QUESTION_ID/... on any question page
var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe";
var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk";
var OVERRIDE_USER = 107299; // This should be the user ID of the challenge author.
/* App */
var answers = [], answers_hash, answer_ids, answer_page = 1, more_answers = true, comment_page;
function answersUrl(index) {
  return "https://api.stackexchange.com/2.2/questions/" +  QUESTION_ID + "/answers?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + ANSWER_FILTER;
}
function commentUrl(index, answers) {
  return "https://api.stackexchange.com/2.2/answers/" + answers.join(';') + "/comments?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + COMMENT_FILTER;
}
function getAnswers() {
  jQuery.ajax({
    url: answersUrl(answer_page++),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function (data) {
      answers.push.apply(answers, data.items);
      answers_hash = [];
      answer_ids = [];
      data.items.forEach(function(a) {
        a.comments = [];
        var id = +a.share_link.match(/\d+/);
        answer_ids.push(id);
        answers_hash[id] = a;
      });
      if (!data.has_more) more_answers = false;
      comment_page = 1;
      getComments();
    }
  });
}
function getComments() {
  jQuery.ajax({
    url: commentUrl(comment_page++, answer_ids),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function (data) {
      data.items.forEach(function(c) {
        if (c.owner.user_id === OVERRIDE_USER)
          answers_hash[c.post_id].comments.push(c);
      });
      if (data.has_more) getComments();
      else if (more_answers) getAnswers();
      else process();
    }
  });  
}
getAnswers();
var SCORE_REG = /<h\d>\s*([^\n,<]*(?:<(?:[^\n>]*>[^\n<]*<\/[^\n>]*>)[^\n,<]*)*),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/;
var OVERRIDE_REG = /^Override\s*header:\s*/i;
function getAuthorName(a) {
  return a.owner.display_name;
}
function process() {
  var valid = [];
  
  answers.forEach(function(a) {
    var body = a.body;
    a.comments.forEach(function(c) {
      if(OVERRIDE_REG.test(c.body))
        body = '<h1>' + c.body.replace(OVERRIDE_REG, '') + '</h1>';
    });
    
    var match = body.match(SCORE_REG);
    if (match)
      valid.push({
        user: getAuthorName(a),
        size: +match[2],
        language: match[1],
        link: a.share_link,
      });
    else console.log(body);
  });
  
  valid.sort(function (a, b) {
    var aB = a.size,
        bB = b.size;
    return aB - bB
  });
  var languages = {};
  var place = 1;
  var lastSize = null;
  var lastPlace = 1;
  valid.forEach(function (a) {
    if (a.size != lastSize)
      lastPlace = place;
    lastSize = a.size;
    ++place;
    
    var answer = jQuery("#answer-template").html();
    answer = answer.replace("{{PLACE}}", lastPlace + ".")
                   .replace("{{NAME}}", a.user)
                   .replace("{{LANGUAGE}}", a.language)
                   .replace("{{SIZE}}", a.size)
                   .replace("{{LINK}}", a.link);
    answer = jQuery(answer);
    jQuery("#answers").append(answer);
    var lang = a.language;
    lang = jQuery('<a>'+lang+'</a>').text();
    
    languages[lang] = languages[lang] || {lang: a.language, lang_raw: lang, user: a.user, size: a.size, link: a.link};
  });
  var langs = [];
  for (var lang in languages)
    if (languages.hasOwnProperty(lang))
      langs.push(languages[lang]);
  langs.sort(function (a, b) {
    if (a.lang_raw.toLowerCase() > b.lang_raw.toLowerCase()) return 1;
    if (a.lang_raw.toLowerCase() < b.lang_raw.toLowerCase()) return -1;
    return 0;
  });
  for (var i = 0; i < langs.length; ++i)
  {
    var language = jQuery("#language-template").html();
    var lang = langs[i];
    language = language.replace("{{LANGUAGE}}", lang.lang)
                       .replace("{{NAME}}", lang.user)
                       .replace("{{SIZE}}", lang.size)
                       .replace("{{LINK}}", lang.link);
    language = jQuery(language);
    jQuery("#languages").append(language);
  }
}
```
```
body {
  text-align: left !important;
  display: block !important;
}
#answer-list {
  padding: 10px;
  width: 290px;
  float: left;
}
#language-list {
  padding: 10px;
  width: 500px;
  float: left;
}
table thead {
  font-weight: bold;
}
table td {
  padding: 5px;
}
```
```
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<link rel="stylesheet" type="text/css" href="https://cdn.sstatic.net/Sites/codegolf/all.css?v=ffb5d0584c5f">
<div id="language-list">
  <h2>Shortest Solution by Language</h2>
  <table class="language-list">
    <thead>
      <tr><td>Language</td><td>User</td><td>Score</td></tr>
    </thead>
    <tbody id="languages">
    </tbody>
  </table>
</div>
<div id="answer-list">
  <h2>Leaderboard</h2>
  <table class="answer-list">
    <thead>
      <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr>
    </thead>
    <tbody id="answers">
    </tbody>
  </table>
</div>
<table style="display: none">
  <tbody id="answer-template">
    <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr>
  </tbody>
</table>
<table style="display: none">
  <tbody id="language-template">
    <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr>
  </tbody>
</table>
```
  
[Answer]
# x86-64 machine code, 12 bytes
```
B0 20 66 C1 07 08 AE 72 FD 74 F7 C3
```
[Try it online!](https://tio.run/##dVJha9swFPxs/YqbR6jcJqXtyijNvC/b17ERBhskKSjys60hS0ZS2pTSvz7vOVk3VjoQlnzv7t6hJz1rtB4GFTtILHIpThvrN8qiFvW1yDp/C2WnOMKRcLRLdz5UDAdv8e3z4iO@fF1gGSqznuJqT7CUEgWmRK3iRmQ/NvgL8y/hyYZdKIkiRzEXulUBtdxvx5EB8do4bbcV4V1MlfGn7ft/oGBcM2LGJXTKOFmIB5Ht9XF5fnG1novsrjWWIDmIq2U@Wd6s3Br5FLFAWeK8EBlLslqO/bKs36Z4OD6KrGf/xKKV@6R0axxB@4qu87GsvYsJWxdN46jCIXOPEvLFSlHPn0GaTSqPpx6YnF1851i6PO5PToo5fufWeFXibPfhzdj0D1lODDb3iWKxcizqZ//ryqrHYWjJWg@@bluJ1JoIXsqBVLwfmdaSa0gEuqUQCakl1CawHU8Ih5lF@Jr5usV@aH2fdqOJ5zvhgve7jt@KD51K4qeurWriMOveXvKH31TJqcn@Ag "C (gcc) – Try It Online")
Following the standard calling convention for Unix-like systems (from the System V AMD64 ABI), this takes the address of the input, as a null-terminated byte string, in RDI, and modifies the string in place.
In assembly:
```
f:
    mov al, ' '     # Set AL to the ASCII code of the space.
nextword:
    rol WORD PTR [rdi], 8   # Rotate 2 bytes at the address RDI left by 8 bits.
                            # This swaps the current and next characters.
nextletter:
    scasb           # Compare AL with the current character, advancing the pointer.
    jb nextletter   # Jump back if AL is less than the character read.
    je nextword     # Jump back further if AL is equal to the character read.
    ret             # Return (if AL is greater than the character read).
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), ~~7~~ ~~6~~ ~~5~~ 4 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
εΣN≠
```
-1 byte thanks to *@CommandMaster*
[Try it online.](https://tio.run/##NYzNDcIwDIV3yZlZWABxMMUlkdy4si1aRmALJGZgjQ7BIsEO6uX9yM8fK1wKtrZ9tvfx@3y1dkoZiTgd0sJCV3fLRd26QHVB0IfbkIEI6w09C95RFPs6dCyiFm0JEqGZnz3x2P@H/OcHfp5t3fFccR8xrxMFiWUCS@cf)
**Explanation:**
```
ε     # Map over each word of the (implicit) input-list:
 Σ    #  (Stable) sort its characters by:
  N   #   Where the 0-based index
   ≠  #   Is not 1
      # (after which the list of modified words is output implicitly)
```
The `N≠` will make the 0-based indices of the characters in each word `[1,0,1,1,1,...]`, basically putting the second character at the front.
[Answer]
# [V (vim)](https://github.com/DJMcMayhem/V), 4 bytes
```
òxpW
```
[Try it online!](https://tio.run/##K/v///CmioLw//89UnNy8hXK84tyUhQy8ssVEotSFSrzSwE "V (vim) – Try It Online")
Explanation:
```
ò       # Recursively...
 x      #   Delete one letter
  p     #   Paste the last deleted letter
   W    #   Move forward one word
```
[Answer]
# [Brainfuck](https://github.com/TryItOnline/brainfuck), 30 bytes
*Thanks to [tsh](https://codegolf.stackexchange.com/users/44718/tsh) for -4 bytes.*
```
,[>,.<[.[-<++++++++>]<[,>]<],]
```
Explanation:
```
,[                loop every word
  >,.             print second character of word
  <[              loop through next letters of word including first one
    .             print next letter
    [-<++++++++>] multiply the letter by 8 (8*32=256; 256%256=0)
    <[            check if the result is zero
      ,>          if not then load next letter
    ]<
  ]
,]
```
Characters `@` and ``` can also be used as word separators as `8*64=512; 512%256=0` and `8*96=768; 768%256=0`.
[Attempt This Online!](https://ato.pxeger.com/run?1=m70yqSgxMy-tNDl7wYKlpSVpuhb7dKLtdPRsovWidW20ocAu1iZaB0jE6sRCFEHVLlidkZqTk69Qnl-UkwIRAgA)
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 4 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
żḢF)
```
A monadic Link that takes, as allowed in the comments, a list of words and yields a list of words.
**[Try it online!](https://tio.run/##y0rNyan8///onoc7Frlp/n@4Y9Phdu///4tSy1KLilMVSjJSFdIyi4pLFErK8xVyUktKgMIK@WkKqYnJGQrl@UUpAA "Jelly – Try It Online")**
### How?
```
żḢF) - Link: list of lists of characters, words  e.g. [..., "upend", ...]
   ) - for each word:                                       
 Ḣ   -   head (word) -> remove and get the first character  "u"
ż    -   (beheaded word) zip with (head character)          ["pu","e","n","d"]
  F  -   flatten that back into to a list of characters     "puend"
```
Also requires no empty words, also allowed in the comments (as `Ḣ` would yield a zero).
Note: I would say that the `F` is necessary since without this flatten a callable link would return each new word as a list of lists of characters while as a full program it would smash the characters together when it prints.
[Answer]
# JavaScript (ES6), 33 bytes
```
s=>s.replace(/\b(\S)(.)/g,'$2$1')
```
[Try it online!](https://tio.run/##hZCxbsMgEED3fsUpihSQWlvtnn5AhnbImoWSw1BhzoJTHH@9e8RdmkYJYkK8dzy@zckUm8PAL4mOOLvtXLbvpck4RGNRtYcvddhr1ei2e96s39avGz1bSoUiNpE65dTKY4wEI@V4XGkND1bbAvoK0CjA05WLfSgg2yRAUyaw3sSIqcObZnF5ltslQDJgUABvf4Frc8YT5oLAHsGFXBh4JIjILMdATuZZXysuEfWVeQE8IwRXgZEJMC6AI5kngFT8ixgGPtcISljFROc@CpB7wzcyZNQFqBGEVbwA5Crwx73bf340hXNIXXBTHSU@ff@zFfYDT7BQev4B "JavaScript (Node.js) – Try It Online")
[Answer]
# [Python 3](https://www.python.org/), 35 bytes
*Thanks to [steffan](https://codegolf.stackexchange.com/users/92689/steffan) for -34 bytes.*
```
lambda a:[x[1::-1]+x[2:]for x in a]
```
[Try it out](https://ato.pxeger.com/run?1=m72soLIkIz9vweI025ilpSVpuhY3lXMSc5NSEhUSraIrog2trHQNY7Uroo2sYtPyixQqFDLzFBJjIUr3FBRl5pVopGlEq2ek5uTkq-soqJfnF-WkqMdqakKULFgAoQE)
p.s. This is my first serious attempt at Code Golf all feedback is appreciated!
[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog), ~~9~~ 8 bytes
```
{pᶠkt↔}ᵐ
```
[Try it online!](https://tio.run/##NYw9DsIwDIXvkpmJ44AY0uA2FW4cORZthViZGTgAlyj3KRcJTlCX9yM/fw1b52ekbp/zLa6f90W@j9d9XZ45H40HRDI7MxLjWV18n9Sq2KACNs1qzltECB1oZrgCJ6jrom3PSUobCwlBRM@aqK3/zv/5BR@jTBueAmwjomnAQiIerJhTPvwA "Brachylog – Try It Online")
An extremely stupid solution but shorter than my initial, more straightforward idea.
*-1 byte thanks to @UnrelatedString with an event stupider idea*
### Explanation
```
{     }ᵐ    Map for each word:
 pᶠ           Find all permutations of the word
   kt         Get the penultimate one
     ↔        Reverse it
```
This works because `p` will always try permutations in the same order, and it happens that the penultimate one is the input in reverse order, with the last two characters swapped. It also works for 2 letter words because the penultimate permutation here will be the first one, i.e. the identity, and reversing it is the same as swapping the two characters.
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal), 9 8 5 4 bytes
- x bytes thanks to [@Steffan](https://codegolf.stackexchange.com/users/92689/steffan)
```
ƛḣ$Y
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyIiLCIiLCLGm+G4oyRZIiwiIiwiW1wicmV2ZXJzZVwiLCBcInRoZVwiLCBcImZpcnN0XCIsIFwidHdvXCIsIFwibGV0dGVyc1wiLCBcIm9mXCIsIFwiZWFjaFwiLCBcIndvcmRcIl0iXQ==) | [`S` Flag to join by spaces](https://vyxal.pythonanywhere.com/#WyJTIiwiIiwixpvhuKMkWSIsIiIsIltcInJldmVyc2VcIiwgXCJ0aGVcIiwgXCJmaXJzdFwiLCBcInR3b1wiLCBcImxldHRlcnNcIiwgXCJvZlwiLCBcImVhY2hcIiwgXCJ3b3JkXCJdIl0=)
## Explanation
```
ƛḣ$Y
ƛ     Map through each word
 ḣ    Push all but the first letter and the first letter
  $   Swap the first two elements
   Y  Interleave
```
[Answer]
# [Piet](https://www.dangermouse.net/esoteric/piet.html) + [ascii-piet](https://github.com/dloscutoff/ascii-piet), ~~28~~ 25 bytes (13×2=26 codels)
```
tU?QjCuJsNrMbQvQsQjIJjMmm
```
[Try Piet online!](https://piet.bubbler.one/#eJw1TFuOwzAIvArim0hxH2qaq6T9sFJSRyJ2ZNNtV6u9--J0i9AMMMP84JhujP0wtHS80uA6Ohh15Op2pM5wTyfDHTlXDYfN4Dbcf8ztm85v2nyu8pWw8Io9Nk2DhDIvNrvWyjYuI_aTl8KEc1wfalpgkQTPlOV2ifZ0iRrmAtY-AvvyDWPwIhzv_K9n_uJcGDQwTHMuCvpMIKxqZ0iTfY2hJn4C11VfNTBFrnJKr0VgSnnxir9_Yt1TIw)
![Diagram](https://i.stack.imgur.com/P4Zrq.png)
−3 by switching to a vertical layout, allowing two white codels to be removed and one black codel to be implicit.
The program starts with *in(char), in(char), out(char), out(char)*, taking the first two letters from the input and outputting them in reversed order.
After that, it enters a loop:
* *in(char), duplicate, out(char)*: Read the next character from the input, and output it while leaving a copy on the stack.
* *push[3], duplicate, multiply, duplicate, multiply, push[1], add*: Create the value 82 on the stack.
* *divide*: Divide the character code by 82. This produces 1 for lowercase letters (97–122) and 0 for a space (32).
* *pointer*: Rotate the Direction Pointer clockwise by the value on the stack.
	+ For lowercase letters, this sends execution rightwards and executes *subtract, out(char)*, which does nothing with the stack empty, before repeating the loop.
	+ For spaces, execution continues upwards into the white area and returns to the start of the program to process the next word.
	+ When the end of the input is reached, *in(char), duplicate, out(char)* does nothing and leaves the stack empty. The calculation of 82 still works, but then the *divide* does nothing because there is only one value on the stack, and the *pointer* rotates the Direction Pointer by 82, which is congruent to 2 modulo 4, sending it downwards. None of the reversed instructions are *push*es, so they all do nothing (because the stack is empty), and execution reaches the halting structure at the bottom.
[Answer]
# [Zsh](https://www.zsh.org/) `--extendedglob`, 29 bytes
```
<<<${@/(#m)??/`rev<<<$MATCH`}
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m724qjhjU7SSrm5qRUlqXkpqSnpOfpJS7E294tQShaLUstSi4lSFkoxUhbTMouIShZLyfIWc1JISoLBCfppCamJyhkJ5flHK0tKSNF2LvTY2NirVDvoayrma9vb6CUD9IBFfxxBnj4RaiJoFUApKAwA)
Zsh's pattern matching is pretty limited.
-1 byte thanks to @GammaFunction.
[Answer]
# [R](https://www.r-project.org), 28 bytes
```
\(x)sub("(.)(.)","\\2\\1",x)
```
[Attempt This Online!](https://ato.pxeger.com/run?1=ZZDBSgQxDIbx6lOEemlhV9CTF32SwlLH1A5kJkObdWafxcso-BY-iU9javeyIwRawvf_-ZP3j7x-xsevo8T9w7e3iyvHZ2vsrdMyO-P9vfd3Zre4hvxcHaJFskVymagXaxISMcyc6UV5MM65G9g_Aaba51n71xuJpL6AVhgBQzlBlwIRjq94YZBEkdLDGCCgUqk7U1u7jG-YC4IkhNjnIiAzA6GItoGjDulSTbgJmJssCUIfq2wWBqQmi6xTVaYL_Ms_TbLU_DxitWdeBlJBHoJcTPjj6gaM1a9xHCunlsYoZXGY5OQqff62O69re38B)
Simple regex-breast, errr..., I mean... regex-based solution.
Takes input as a vector of words - this works nicely as `sub` is vectorised over the 3rd argument.
[Answer]
# [Ruby](https://www.ruby-lang.org/), 28 bytes
```
->s{s.map{|w|(w.slice!1)+w}}
```
[Try it online!](https://tio.run/##DcjLCYAwDADQVaInRSw4gC4iHvykWKi0JNEg2tmr7/joXO5s@9wO/LA55vi8@lZq2LsVi65uNKUcwY4l4YXECLIjWEcsIBrAo8jfECzgvO6ggbbScPROpvwB "Ruby – Try It Online")
[Answer]
# [QuadR](https://github.com/abrudz/QuadRS), ~~18~~ ~~14~~ 9 bytes
```
\b\w.
⌽⍵M
```
[Try it online!](https://tio.run/##FYxBCsIwEEX3OcVf1o2gXicIoZmYwjRTJ6NtwbvHBN7q/8d7f0LU1qbnD5fpOnD@5h/@3lomZsEuytFZXio6oYBCPTHnwEzlRU7pS1oJlglp0WqwXcBk1mdI6v6cRyW6bbNjRKTQOESOlZFE12DuDw "QuadR – Try It Online")
PCRE **R**eplace:
 `\b` a word boundary
 `\w` any word character, and then
 `.` any character
with:
 `⌽⍵M` the reversed Match
[Answer]
# [APL (dzaima/APL)](https://github.com/dzaima/APL), 6 bytes
OP [seems](https://codegolf.stackexchange.com/questions/249523/erverse-hte-ifrst-wto-eltters-fo-aech-owrd?noredirect=1#comment556971_249523) to have allowed input as a list, so here goes…
```
⌽@1 2¨
```
[Try it online!](https://tio.run/##TU07DsIwDN05RTfDgAScgKtYrUMquXWVRLQwMjAgQCzcgQOwsnCUXCQkRVW7PNvP74MNL4sjlhUG5c@PefDXz3adbb6vsJj5@zNyKgNNzAIZtGK4gJF3urSR7gHrCIT2EEeukZnqHU20hvZkLEFyJVSlsS5dbUpmci6@4yaqz8n1v29a1zSuG@qkpkEs0lWcEsVU6Eb9yt/e/nICCD8 "APL (dzaima/APL) – Try It Online")
`⌽` reverse
`@` at indices
`1 2` one and two
`¨` for each word
[Answer]
# [Perl 5](https://www.perl.org/) + `-p040`, 13 bytes
Uses `-040` to work on each space separated section so that the replacement can be one off avoiding the need for `/g`, which makes it possible to use the implicit `;` from `-p` as the terminating separator.
```
s;(.)(.);$2$1
```
[Try it online!](https://tio.run/##K0gtyjH9/7/YWkNPE4isVYxUDP//z0jNyclXKM8vykn5l19QkpmfV/xft8DAxAAA "Perl 5 – Try It Online")
[Answer]
# [sed](https://www.gnu.org/software/sed/) `-r`, 17 bytes
```
s/\<(.)(.)/\2\1/g
```
[Try it online!](https://tio.run/##K05N@f@/WD/GRkNPE4j0Y4xiDPXT//8vycgsVgCixDyF1MTiSoXkjMScnNS89NR/@QUlmfl5xf91iwA "sed 4.2.2 – Try It Online")
Uses the rare 'start of word' marker `\<`.
[Answer]
# [BQN](https://mlochbaum.github.io/BQN/), ~~10~~ 8 bytes
*Edit: -2 bytes thanks to DLosc*
```
⌽⌾(2⊸↑)¨
```
[Try it at BQN REPL](https://mlochbaum.github.io/BQN/try.html#code=UmV2Rmlyc3QyIOKGkCDijL3ijL4oMuKKuOKGkSnCqAoKeCDihpAg4p+oInJldmVyc2UiLCJ0aGUiLCJmaXJzdCIsInR3byIsImxldHRlcnMiLCJvZiIsImVhY2giLCJ3b3JkIuKfqQpSZXZGaXJzdDIgeA==)
```
         ¨   # for each element of input
⌽            # reverse
 ⌾           # under
  (2⊸↑)      # take first 2 elements
```
The [BQN](https://mlochbaum.github.io/BQN/) 'under' modifier applies a function (here, take first 2 elements) and then applies another function on the result (here, reverse), and finally undoes the first function (so, it 'undoes' taking elements 1&2, thereby putting the result back into these positions).  
Think 'operating under anaesthetic', where the anaesthetic is done before the operation and undone afterwards.
[Answer]
# [Haskell](https://www.haskell.org/), 34 bytes
```
unwords.map(\(a:b:c)->b:a:c).words
```
[Try it online!](https://tio.run/##HclBCoAgEEbhq8zSFnkAwU7S5s/GlGwKNaLTmwQPvsULKDun1A5EIUtRKme4Sr55e8tz5rXoAxepWcEsxg3jtBh09f9aqyEW6kGIUV5yASmxbPwB "Haskell – Try It Online")
[Answer]
# [Python](https://www.python.org), 48 bytes
*Thanks to user `Kalobi` for -3 bytes and `pxeger` for another -3 bytes.*
```
print(*(i[1::-1]+i[2:]for i in input().split()))
```
[Attempt This Online!](https://ato.pxeger.com/run?1=LY5BDoJADEX3c4qGFWgw4spwFcOCYHGalOlkpgiexY0Lde11vI1DMPnJb9rf197f_qZW3OMzWWKEqsYZuzzLsteofXn87n0gp_kmp1NV12XVbOl0qJteAhCQS_Kj5sUueqbkRbHuPRPhXz6-ziKzwCSBz0YtRUhqHWAbb9DZlhndBU3AK4aIoBahpxAVdBJgVE1tkD7lO7tQzsZ7nReIOFwGIvPAkH4aWjVmPfsD)
[Answer]
# [Retina](https://github.com/m-ender/retina/wiki/The-Language), 7 bytes
```
V`\b\w.
```
[Try it online!](https://tio.run/##FYxBDsMgDATvvMIvqNTP9JRDnWQpSA6OjBWS11OQ5rSzGoPnwu/eP99lXdqr9wQRpaYme/CUKw24ELg@tCUWQfkhGC5YBXkCxWzVyZuSwH3MpHH8tzQrezhPv2dEC6ZQvQ@hqHawhz8 "Retina – Try It Online") Link includes test cases. Explanation: A simple use of Retina's reVerse command on the first two letters of each word.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jellylanguage), ~~10~~ ~~7~~ 6 bytes
```
U2œ?U)
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m700KzUnp3LBgqWlJWm6FstDjY5Otg_VXFKclFy8-HC7N0T4pnu0UrR6UWpZalFxqrqOgnpJBphKyywqLgHzy_NBVE5qSQlQCYiZnwYiUxOTM0B0eX5RinqsUizUGgA)
-3 bytes by doing I/O as a list rather than a space-separated string, now that the OP has allowed that.
-1 thanks to @Unrelated String
Explanation:
Given a word \$ a\_n \cdots a\_3 a\_2 a\_1 \$, the permutation \$ a\_n \cdots a\_3 a\_1 a\_2 \$ is at index 2 in the list of permutations of that word.
```
     )       map over each word:
U            reverse
 2œ?         index 2 into all permutations of the reversed input
    U        (un-)reverse
```
[Answer]
# [Java (OpenJDK 8)](http://openjdk.java.net/), ~~38~~ 37 bytes
```
s->s.replaceAll("\\b(\\S)(.)","$2$1")
```
[Try it online!](https://tio.run/##LY6xCoMwGIR3n@InOCSggXa1Fbp06@RYO0SNbexvEky0SPHZbYpOd3DHfdeJSaTGSt0177VG4RzchNLwjQCcF17V0IUKH71C3o669spoft3NqfCD0s8ENs2hhfPq0tzxQVoUtbwgUlKWFS3LglHOSELiY3wgbM2iQLBjhYGwgyajGugDnW5z9wcI9j8Cxey87LkZPbch8ahpy4W1OFPykogGPmbAhjCWhfoSLesP "Java (OpenJDK 8) – Try It Online")
-1 thanks to @KevinCruijssen
Couldn't come up with a less boring version. The shortest other idea I had was just swapping `i+1` and `i+2` in an array where index `i` is a space, but just `toCharArray()` is 13 chars :(
[Answer]
# [Nibbles](http://golfscript.com/nibbles/index.html), 5 bytes (10 nibbles)
```
:\<2@>2@
```
```
           # implicit map over input:
:          # append
 \         # the reverse of
  <2@      # take first 2 characters of each arg
           # onto
     >2@   # drop first 2 characters from each arg
```
[![screenshot](https://i.stack.imgur.com/KF3gN.png)](https://i.stack.imgur.com/KF3gN.png)
[Answer]
# [Java (JDK)](http://jdk.java.net/), 36 bytes
```
l->l.peek(s->s[0]^=s[1]^(s[1]=s[0]))
```
[Try it online!](https://tio.run/##bVDBahsxEL37K6YLAW2xRXu144USmltOPjoOqOuRV45WEppZ20vJt6uSvS2YFCQN897Me6M5qpNaHPfvyfTBR4ZjzuXAxsqvq9knTA@uZePdf0niiKovVGsVEbwo4@D3DCAMv6xpgVhxDidv9tBnTmw4GnfY7kDFA9XXUoDnyeJxc5V7bDsVt7tmfp82oGGd7KKxMiC@C1o0tP22e1vT9vvuTZR3XYC6TqurrPYRxEnF4gXLO0eAghOs4eYhvRaZlxSsYVFBVddSG8sYxWXRfLlIQz/7wKPIeK/C9I3lkv1THu5HjGqsV5NyUdVShWBHQf/Q4heRBsuZpjsRh@datt5abFk83aKPJI/euFxwG@evzmYkxjzvwDLkdtaieq0e6LVawi0@uGpe/jqf7KbOj1m5Hyl1aK2Hs492n7gzBPkoB6hohLzp7O4OmCKeMBICdwjaRGLgsweLnFdC4HWub7uisk8h8KWIeIeF8P7S27L7XnH6Aw "Java (JDK) – Try It Online")
* Takes input as `Stream<char[]>`, and returns another `Stream<char[]>`, with each `char[]` being a word.
[Answer]
# [K (ngn/k)](https://codeberg.org/ngn/k), 11 bytes
```
{x@>1=!#x}'
```
[Try it online!](https://ngn.codeberg.page/k#eJxLs6qucLAztFVUrqhV5+JKc1BSUIpRykjNyclXKM8vyklRyMgvV0gsSlWozC9VAgA7oA49)
[Answer]
# Knight, 78 bytes
```
;=s+" "P;=i~1;=r"";W<=i+1iLs=r+r+=gGs i 1I?g" ";=i+2i+Gs i 1Gs-i 1 1""O Gr 1Lr
```
[Try it online!](https://tio.run/##rVltU9tIEv5s/4pBKWzJlhNJcFVblmWKZIGilkAWkssH8AUhy/bUybJPkmFZQv56rrtnRhrZJne5WyplWTPP9MszPd09TtSbRtH3VzyNktU4HuTFmC9ez4ZNfSThd7WhqHhcxmugjKfT2lDB5wIzjic8jVmSsGSRTumjWY5@PP/0nrnV69XHS@ZVr38/vGT71evx@Tv2S/V6@Ym5Ffj47ErDnn8606Cfzt8fXv1m5hYz8aPFvrl/s8rZwytQKyajWZixjlUt0FFgayliOGT71dz50WecTGGSPPrK8PtgsIZBNYRBNwGTJBYCa5i3FxdnBMKPA3Kyj75phlyeCACs12y9D5NVbFnX6chqNskP2JXrUXBpHF0cm9/9IO8azPjgB/yb6weZYfifBwHvuvwsD7Ju1g2mJznjzD09mAIOYF2Pd8XQSd6DT@YaxgU7yZh7ln23QKjhCz0dUBSHcxagRr/ZBLOWYZbHpsWemg2eFoz7zQaMkok260xWaQQjtDiC92K@tPNleu2NgifHdp5BRoODOMLD08GBN29QPF@yhxkv4nwZRnGzAd@T2IRxWG4KM2xm3BQ36c3kJmNPz9cj0@q/MiwypcEnzCytDVj7VdtiQoQa3YHRmxSGu10xAnY24iSP9YFnYU40i6N/sskiY@lqfhdnubSHmTwf8ykvlFTQju64dumReHaY67Au60jLu12L9VjbaYMKtJRbLIuLVZYyFVRiGcWVv27DfZjx8C6JlRVgRLJ4iDMzAn3KEPb1K1PGRfQWERFf2pakh29xnQeuDXsUlMNr1uExleEMkHS8Wpq4pUxy2mPwtmmwSBq5kCbMuGm3K5uMttg0WAwelEYxEAJJBr6DZcswL1gxi0FYmBUAlhvQUYzihkYWeqKM1c7ei8bCp2vRRjcqMsh8DN2CL1IwGyPWGYFpkWIkXy2XSLilokqN6PTr8Qe0a2SjDBXKyxTiGBIeRq60XLDysV1mBTFwjAOY/PqY9NBMFWSUL4WrJtqNpoZJsojMfcd2LXQQh0snyMF0lSRh9qg7Wu3PpbY9H9qlZaRQrl@la6tJhYsqZFLY5unh0dt3t7/vnP168U3zWJd7x7cK9jYF79Qkn5xevSCxiDMSGaZj9q9VqF5R7L2uYm9ThWDgpF2ScbqFDFq8X19cxzxTrsxWKW6RL7N2p1jkpkqWdAIgtgseMZq9W02uvf2RtEPsdIvyQ2lAvoRzVUxMgIL/u0kyNlTioaplo5B1AXAqSgGiHgr9NdyAuXt1P9F5DMYDZhTZKjYgCMtxjEkYn4SQQnDCwNAyKhLQT/RdFi6i48vbxSKBmbs6Ay/6Wrn1I4c6P@@RbubdhpkJ2pj@pTZC0BaLJDF1U23m2FAi/geT0w2TsQy/P/xwbmMxFoEGr6fXruM4EE7gCryqt5z/GX8pGD58LUY1b5EBeLPxw6PPvcBVNR1THJZ1fNCnJx57ADg@PTvqsAlkR79RhrbUh3k4Cpd2EqfUAmhcqb5KcAbn7iUy1hdiccLahhXH5NRMQDEeEBc@VBWOk2XeiObLtR0gkvioSiFIEx@hmvyBF9HM7AAzG20YcMTkX4SFqn3Y7jPUIgABEoqNHKRhq0VOSfGylayFrOVTGa4Q1K8WGdYualmvR9ZTFWbQQVFyF4ovQXFddgYZz7Razh8T/KuQHwAJUgVH07hIoNs0W7SXLdwhrJFjnlo@n5gm7Sd2BNEsQ1tsiFPLEtscOP5WW@FhUR8g9B0JfaJ1xGwgCfGVvUiSzJ2VlW8rfwS@nHlXzeBKneIScwsYjAaIv2C5WMapqSm2jcygXgGsCuaiVEI8Bp6z/wuNy@7CFC3JBEwfo1PQw0HI2tjgARyaB3pDHaBahZcJg6wbUC@EJxaQlqQb5JAuoholdALm6U1LRWPlye/gSfwH9HF42jf83KntOl0qdjCTbQDPNsIDtCR1XjT4tw14b6v@X9t92VBuCfgyQ8pKZZxT/2xirbJUsRoO962qA91Im2rpFXWR5m6OC@uHZnMx0A49kq4XMq5lVFA1gWUoDlMp9qVSJ2ubvlMyB0kWLioW8ACJGxKSK/a9RjFrtejG1ushdCT64RvqyxvKrN3XnRzsMeHNYupIZpr5qyJXUVLGjmgKhUHd0iDKp5BXMXVjCGrbI9ruRn2bxfUX0XBBYGrPPbHn2CjToREbQCgcxmwQKC89a3tIR2GhHrI9dbsVTZb6jrIsaFttehYyl0i/ehthqUUl9vR1e8WiTrU7W1hYL@NbeOhs8CD2dRsL8y2udQgT6EJoAdQqkzJp0L6B2yCC/F6P5EmiqLSub7RgtKhliTc/JObNdmJ2f7hod/uifxCbNYfEHYPGPN1LX9IuWA9Yzy1ZJixQ78I567lwxlwd7P0kegBptIYNAoSS3r4acRTlRLQ3dCTXnkVtTScg/pvrB4ImyRW4S1AixlIE3/FqMYuzuJ2zdAG9Nk8KnrKH8BF4Y@MFXF6LeBpnsGa5SOO04CHeNuAkL9hDzGbhfQxAKQjhBZuH6QrC5/E1jqJ3d8g4UEFM5KukwF8XSHmZ8BSkp2OUyjXK9HUlZE08ynsZ6bxsSAkb1FAOXeTDBGvoI3idjpN4zG4rs29LKU/4TTRwmpLKmSEK6/XUu0XwhoR2NNOfyzw4oGBdK5CY9Gp5MahnxQOmH/6BfgxwaV/@sNdiAnDAag0lDdpMy4YowxErVWn2RB1A7E4A1UbrloZwKDG0FuNFn83jebTEMEvZ8Pbg/3Vl@Be4MlSu7GzxJZC@SFcOXmZfaN1iMk4fsBrAKxGeKqA72@ysXkr3VObRBZTmtar0h75sqw0H@kqZSsr1X/@b9TIHaWLK9X67r6Nr7fA6Nqiybn36py88qgeubjyIa9RuPWUqJAxKHAW11VqaxBWI6HbLZcLkz@Ce@HlMb0hr3jG9d5HLTuvdPUK19Qdef0@j5URcLQKtw@rqBWjzLpXKC4pdnoW9WuN7JYheE@qvlzxvW8nbs8o@wCtX79Pgf2iI0DB84lZE5SWhbIf03sgDD1Fr18UmiRoEEf9ikh6E6MqTANrH8SSEJAmeqQ6TpzDJx/RjUxgVUKbau1Ebe04csdgLt10UVtZA6AblDw7zkKfYrLIwm0Y2Ce104Pu9hT9r0T0U/5/IdMia@nXv@Xsx4zmDf2HK4jB/xOUJeDuN/w0 "C (gcc) – Try It Online")
Expanded code:
```
;= s (+" " PROMPT)
;= i ~1
;= r ""
;WHILE <(= i + 1 i) (LENGTH s)
  =r + r 
     + (=g (GET s i 1))
     IF (?g " ")
       ;=i (+ 2 i) 
       + ((GET s i 1) 
          (GET s (- i 1) 1))
       ""
OUTPUT (GET r 1 (LENGTH r))
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 8 bytes
```
Ḳµḣ2Uo)K
```
[Try it online!](https://tio.run/##HcwxDsIwDIXhqzxlQ2LiGswMjFFxSJEbV4lF25WFg3RlQkLqDCcpFwkJkid/ev@FmKec1@X5fq3LvDvIZp8/9@/tcczZ@KKCQSKfzBZGfZtQzgaQTRMab5kpnKlipCvFRFBPcG1MCh0ETKrlDXFl0vja@qf6XseakkDVRMaO4SR2ViubHw "Jelly – Try It Online")
## How it works
```
Ḳµḣ2Uo)K - Main link. Takes a string
Ḳ        - Split by spaces
 µ    )  - Over each word:
  ḣ2     -   Take the first two characters
    U    -   Reverse them
     o   -   Logical Or, overwriting the first two characters of the word
       K - Join with spaces
```
[Answer]
# Python 3, 51 bytes
```
lambda s:' '.join(w[1::-1]+w[2:]for w in s.split())
```
[Try it online!](https://tio.run/##VY5BCoMwEEX3PcXgRqVUsN0JPUnrItVJkzJmQjI0evo0bgrC38znzeP7TQy7W9b3Zya1vGYFcaih7j5sXZMe/TBc@vGcHtdh1BwggXUQu@jJStO22QfrpNFNZZCIIXGguWrb078XYyOUKAeo4gaTUUTo3nigAn4xRAQxCNqGKCCJgVCk1MC6/E5mtx/l3su6y9nhDjGvC0GZuSg5cOXIPw "Python 3 – Try It Online")
[Answer]
# APL+WIN, 26 bytes
Prompts for sentence
```
(⌽¨2↑¨s),¨2↓¨s←(s≠' ')⊂s←⎕
```
[Try it online! Thanks to Dyalog Classic](https://tio.run/##JYw7DsIwEER7n2I7BwkK4BRIIM5ghTWOtGQj2@LTUoSPEAIhekouQcNRfJGwCdIWb2Z2xlQ0WOwM8XKQkwmhyJt0fc6mqb6NldBkLjRU6XiwTZYun@97lOr79x16/Q4fgvKRhXR6adC9dN63WpqNdFRjlXZIxLBhTwutREdXBJAzJaAJO8idIcJyiV3qcY0@IESHYAsfIsQNA2GMYgNb6eSuXfuPVVXctmNcYhsyb1cElv3KxC7XPw "APL (Dyalog Classic) – Try It Online")
]