[Question]
  [
When Alice was touch typing on her QWERTY keyboard (Figure 1), she accidentally shifted both of her hands rightwards by one key, so `q` became `w`, `w` became `e`, etc. (`p` became `[`). Spaces were not affected because the space bar was quite big.
Your task is to help her fix her message using the shortest number of bytes, i.e. undo the shifting of her hand positions. More precisely, you will be given a string consisting of spaces as well as characters from `wertyuiop[sdfghjkl;xcvbnm,` and you need to map the characters to `qwertyuiopasdfghjklzxcvbnm` and leave spaces untouched.
Here are some testcases for you to test your program:
```
input      output
----------------------
s[[;r      apple
s gom      a fin
werty      qwert
uiop[      yuiop
sdfgh      asdfg
jkl;       hjkl
xcvb       zxcv
nm,        bnm
 ;p;;o[p[   lollipop
[2 spaces] [2 spaces]
```
(the `lollipop` testcase starts with a space)
Figure 1: Alice's QWERTY keyboard
![](https://upload.wikimedia.org/wikipedia/commons/thumb/d/da/KB_United_States.svg/800px-KB_United_States.svg.png)
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"). Shortest answer in bytes wins.
  
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 15 bytes
```
ØqḊ€ż“[;,”F,Fyɠ
```
[Try it online!](https://tio.run/##ASwA0/9qZWxsef//w5hx4biK4oKsxbzigJxbOyzigJ1GLEZ5yaD//yA7cDs7b1twWw "Jelly – Try It Online")
Takes input via STDIN
## How it works
```
ØqḊ€ż“[;,”F,Fyɠ - Main link. Takes no arguments
Øq              - Set the return value to ['qwertyuiop', 'asdfghjkl', 'zxcvbnm']
  Ḋ€            - Dequeue each; ['wertyuiop', 'sdfghjkl', 'xcvbnm']
    ż“[;,”      - Zip with "[;,"; [['wertyuiop', '['], ['sdfghjkl', ';'], ['xcvbnm', ',']]
          F     - Flatten; "wertyuiop[sdfghjkl;xcvbnm,"
            F   - Flatten the return value; "qwertyuiopasdfghjklzxcvbnm"
           ,    - Pair; ['wertyuiop[sdfghjkl;xcvbnm,', 'qwertyuiopasdfghjklzxcvbnm']
              ɠ - Read a line from STDIN
             y  - Translate. Map w -> q, e -> w, etc.
```
[Answer]
# [J](http://jsoftware.com/), 43 bytes
```
'qwertyuiop[asdfghjkl;zxcvbnm,  '(<:@i:{[)]
```
[Try it online!](https://tio.run/##TZA7C8IwFIV3f8XBJRba4pwoCIKTk2twqLVP0ya2vv3xMQkkFZLlfnDPd26r5ykpsaYgiLEENT9JsT3sd5pcn8Vwe98bqXg2nsuqbi@CfV7549R3MUAWK7pp6JdHRx3NiryWIJlSoiBIKEqQkXM2EHiEsukDQiW7gFyQRy40IBfvkVOZFlqnsND6BWRNPbHSAVh7D2yRAEwlPzflwhhCCtGoSQFMMSb5n4Y5hGfm6R8 "J – Try It Online")
* `'qwertyuiop[asdfghjkl;zxcvbnm, '` The full keyboard, including the shifted away left-most chars and the extra chars `[;,`, as well as two extra spaces at the end.
* `<:@i:` Find the index of the input within that, searching from the right, and substract one.
* `{[` Pull those shifted indexes from the string in step 1.
[Answer]
# C++ (Windows MSVC), 92 bytes
```
#include<Windows.h>
void f(PCH s){for(;*s;)*s++=MapVirtualKey(OemKeyScan(*s)-(*s>32),1)|32;}
```
Take input as a `char*` (`PCH` is typedef of `char*`), output by modify the string in-place.
Trying to make use of some built-ins. But seems not quite short. Maybe some one may take this idea and make a shorter one in other languages.
`OemKeyScan` convert key to its scancode, `'q' -> 16`, `'w' -> 17`, `'e' -> 18`, ..., `'p' -> 25`, `'a' -> 30`, ..., `'l' -> 38`, `'z' -> 44`, ..., `'m' -> 50`. `MapVirtualKey` convert scancode back to (uppercase) character.
Saved 1 byte by ErikF.
[Answer]
# [Vyxal](https://github.com/Lyxal/Vyxal), ~~16 13~~ 12 bytes
```
k•`[;,`Y∑:ǔĿ
```
[Try it Online!](https://lyxal.pythonanywhere.com?flags=&code=k%E2%80%A2%60%5B%3B%2C%60Y%E2%88%91%3A%C7%94%C4%BF&inputs=s%5B%5B%3Br&header=&footer=)
```
k•           # Qwerty keyboard (array of rows)
  `[;,`Y     # Interleave with `[;,`
        ∑    # Concatenate all of that
         :ǔĿ # Shift each character 1 right relative to this in the input.
```
[Answer]
# [Python 3](https://docs.python.org/3/), 61 bytes
```
lambda s:s.translate('p?ml ??'*14+'vxswdfguhjknbio?earycqzt')
```
[Try it online!](https://tio.run/##JY7BbsMgEETvfMXegDaNFLWnIMcf4l5wgmOSBTaA4zg/74J7e08zGg0teQz@ex2a3xW16y8a0jHtc9Q@oc5GcGodQtvyj8PPJ3@@0nwZrtN4u/vehtbouJwf78zlOo8WDRyODKynHYQpEzSVpyzkPhHaLDh8nYBLBhStz2IQJZbQNFtbrqnrVKwVTYSGJbgGtykM1rPZxLxUfVRikw3UVV0qsVRujVu5ErvdUVUrR5G9zs@@yrsA825XufeOgSKlQvc/AxgQLZUpgM3hDw "Python 3 – Try It Online")
### Explanation
A naive implementation with `str.translate` would use the following translation table:
```
???????????????????????????????? ???????????m??????????????l???????????????????????????????p??????vxswdfguhjknbio?earycqzt
```
To optimize for size, notice that the characters `' mlp'` all have different positions, modulo 7. As such, we can replace the first 98 characters of the table with `'p?ml ??'*14`. The rest of the table is the same.
[Answer]
# [Bash](https://www.gnu.org/software/bash/), 34 bytes
```
tr snvfrghjokl\;,mp[wtdyibecux a-z
```
[Try it online!](https://tio.run/##DcnJEYAgDADAf6pIAVpBSokf8OBQhCGoYPPoflcrsb2XjHLeWzbWx/2YaAiJn7I0p9f5qqjGt3dhpgyCJgZ41lwaXC4mBlk2Y8HvB0Gdbw1nGAApEUX@F/ED "Bash – Try It Online") Using `bash` because I don't know how to score this as a `tr` answer.
[Answer]
# [Haskell](https://www.haskell.org/), 65 bytes
```
a#(c:d)|a==c=d!!0|1>0=a#d
map(#",mnbvcxz;lkjhgfdsa[poiuytrewq  ")
```
[Try it online!](https://tio.run/##BcHBEoIgEADQe1@B0EFnOtg1ZvuRPW0gSQKuYFqN/07vjVSmIYRaSbXmZruDAAzYpumP670HUvbkIBK3Sl5iemzm89Nheo1PZwshz/79XfOwL0LIrkbyCTj7tJ6dLIg6C81az8go6x8 "Haskell – Try It Online")
`(#)` takes a character and a string and returns the character after the first match in the string. Our implementation then just maps this across the string with `,mnbvcxz;lkjhgfdsa[poiuytrewq`  as the preset string.
[Answer]
# [C# (Visual C# Interactive Compiler)](http://www.mono-project.com/docs/about-mono/releases/5.0.0/#csc), 64 bytes
```
x=>x.Select(t=>" mlpvxswdfguhjknbio?earycqzt"[t%94%88%57%43%32])
```
[Try it online!](https://tio.run/##jdE9a8MwEAbgvb9CCAw2pA40KU1R7A6lhUK3Dh1MB1mVbSX6iiQndv68azUQYk/S@Irn7rgj9p5YNry3kmytM0zWC/DxJltBDS453ZIGmzyvsqHL8i79opwSF7ssh0Bwfezs6beq22a3lyVTLxSbnhzODhYuel5Hm030@BStV9Hq4ScZ0N2rklZxmn4b5ugnkzS@dEzHD4JdXMXQFgUyMEkSBP7fcgmw1pwGWVArMbOgYjLEnqhx/dQefBZiW6Z0MbW9z4JmHtfXzGb2WYjd7Tm6od6Oh@AhtCPHckbPYxZCpVjcSk9LKUIkQBohVVx3NUoIuOKcaaVhUAUwaX2pAODwBw "C# (Visual C# Interactive Compiler) – Try It Online")
[Answer]
# JavaScript (ES6), 66 bytes
I/O format: array of characters.
```
a=>a.map(c=>(S="  ,mnbvcxz;lkjhgfdsa[poiuytrewq")[S.indexOf(c)+1])
```
[Try it online!](https://tio.run/##Tc2xjoQgEIDh3qcgVpDz2FxNtLt6iy2JBSIoLgIrrqv78p7j5S5MqL4/zAxiEVFOJsyfzrdq1@UuykrQUQQsywrfyhyhYnTNItc3s/eh73QbBQ/ePLd5Uq9HTviNGteq9aqxJB9fNdkZzxDKI@dsygt0zuWCRAhWnQF1fkwD0sZBeKlp3pLwAIDwND7wJGwA56pWd326CgDCcLfszyH0B4CvcmlSfx8A7sbin8EbNwIjFhjz/Pf4wTmy3loTfMjPDC/5BZDVGdV@@hayxxGVFZLeRW8Vtb7DGnNKaawJIfsP "JavaScript (Node.js) – Try It Online")
---
# JavaScript (ES6), 57 bytes
If taking an array of ASCII codes as input and returning an array of characters is acceptable, we can do:
```
b=>b.map(c=>"rjbwgtvacnofh_spzleykidumx_q "[c*19%116%30])
```
[Try it online!](https://tio.run/##TdDRasMgFIDh@zyFCIV0dHZhMBiSwBh7CgnFmBiTGrWapk1fPstJ2VC8@n48wun5xIPwnRtfja2bReZLlRcVGbhLRV5g31e3dpy4MFaqU3AP3cznrr4O99MFYSZess9dln3s3t/K/UJZghAOjFGPD2g7xyPizulmC6i1QxyQ7AyEW@PHOQoXAAjXzjoWhRlgG1XLVsWjACD0Z03/HIJaAfwupir2xwrgZjj8M3hlBmBEHaWWPT9fGSNtte6cdXjLcKNXAEmZEGn9DxcqDSgvkLAmWN0QbdtUpowQEsrnXrdKhOL@e93515ju4Sy/ "JavaScript (Node.js) – Try It Online")
[Answer]
# [Ruby](https://www.ruby-lang.org/) -p, 40+1 bytes
```
$_.tr!"snvfrghjokl;,mp[wtdyibecux","a-z"
```
[Try it online!](https://tio.run/##KypNqvz/XyVer6RIUak4ryytKD0jKz87x1ontyC6vCSlMjMpNbm0QklHKVG3Sun//@LoaOuif/kFJZn5ecX/dQsA "Ruby – Try It Online")
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 79 bytes
I combined the source and destination strings so that I can take the character after the match. By inverting the list of characters, I could avoid -1 indexes and having to special-case spaces.
```
f(char*s){for(;*s;putchar(strchr(",mnbvcxz;lkjhgfdsa[poiuytrewq  ",*s++)[1]));}
```
[Try it online!](https://tio.run/##VZDBboMwDIbvPIXFNClJ2aSdPfoEVW87ZRxoaCAtJCwJtF3Fs7PAlk27fZ9t/XEsnmoh5lkS0ZSWOXqXxhJkDvvBLyXivBWNJWnW6cMorp/Ynk9NLStX8t6o4ebt8fIBkGbMbTaUvxSU4jQ/KC3aoTrCq/OVMs/NNkmU9tCVSpPRqIrCPQFYXgDmeJEvFlIc52jT7EegNl2Uy9H6W5RBmZ7/jlWybqKczi1GvorxEFl3WUTAHtHwv4Bl@5X2b7tdgCkDxjwmAZdr@NwhBP9eGaC34SeSpPzRFZBvIeSENsW1KQnz4Q74b7J41@lampJp/gI "C (gcc) – Try It Online")
[Answer]
# [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), 36 bytes
```
T`snvfrg\hj\ok\l;,m\p[\wt\dyibecux`l
```
[Try it online!](https://tio.run/##Dcm5FYAgDADQPlMwgBtkDbukwAMB5XoEr@nR3/5qmk9T76OWdG3Vsts5HxxwiFyI78br62eznI8OvQsRVhBlc4Tb1PbC6XMhkHWzDvYjIDzLNUOKAygsiJn@VeoD "Retina 0.8.2 – Try It Online") Link includes test cases. Explanation: Simply a transliteration, although Retina's built-in classes need to be escaped on the source string (obviously the built-in class `l` is desired on the target string).
Alternative solution, also 36 bytes:
```
T`\wertyuio-p[as\df-hj-l;zxcvbnm,`qo
```
[Try it online!](https://tio.run/##Hcq3AYAgEADA/qdgAJng17B7CwyIqAQB4/KI1ndBJm3bnGvRnDKke9eOe2pjM4x8mvmKz9UfnTWV2FzOkQgDRKacgb9D@Z4gDqOaYF5WhK9D@cDQIzoqytgL "Retina 0.8.2 – Try It Online") Link includes test cases. Transliterates the letters in keyboard order. This costs bytes because `a` and `z` have to be included in the source list and `q` in the destination list but then bytes can be saved by using character ranges to avoid quoting the `o`, `p`, `h` and `l` character classes.
[Answer]
# [Japt](https://github.com/ETHproductions/japt) [`-m`](https://codegolf.meta.stackexchange.com/a/14339/), 29 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
```
;D+S ·¬v gD·mÅí"[;,"¬'+ ¬v bU
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&flags=LW0&code=O0QrUyC3rHYgZ0S3bcXtIls7LCKsJysgrHYgYlU&input=InMgZ29tIgoid2VydHl1aW9wW3NkZmdoamtsO3hjdmJubSwi)
```
; -> use second set of predef. Vars
-m flag -> map input by the program  (U)->
     g   - take from 
D+S·¬v     [ QWERTY +' ' split on (\n),rejoined, to lowercase ]
Dxxx bU  - at index of input in[WERTY..]
D·   - QWERTY split on \n
mÅ   - remove 1st char on each
í    - pair with :
"[;,"¬  - ..splitted
'+   - and join
¬v   - join all and to lowercase
```
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 36 bytes
```
≔”⧴3�⁷Ｒrηs⟲θ]⁺L÷↗¹Ｔ“[～↓TφF”η⭆Ｓ§η⊕⌕ηι
```
[Try it online!](https://tio.run/##JYixDsIgFAD3fsVLJ0jwC5i6mDCYmDgyISCg9IFAa/Xn0cZbLnfaq6KTir1PtQaHZARgM15XvX14fNy9u5mqZE5hebdiX8@Rgad8OJeAjVzaT@6kMhGYl/ZPQhlMTaCxG/EMBOpiZ4vNGnIMaPYX6A7vHXjmPMksh35Y4xc "Charcoal – Try It Online") Link is to verbose version of code. Explanation: Port of @ErikF's C answer, except putting the spaces at the beginning because that compresses better.
```
≔”⧴3�⁷Ｒrηs⟲θ]⁺L÷↗¹Ｔ“[～↓TφF”η
```
Assign the compressed string  `,mnbvcxz;lkjhgfdsa[poiuytrewq` to a variable.
```
⭆Ｓ§η⊕⌕ηι
```
Find each input character in the string and print the character that follows it.
[Answer]
# [Perl 5](https://www.perl.org/), 57 bytes
```
s/./",mnbvcxz;lkjhgfdsa[poiuytrewq  "=~m|\Q$&\E(.)|;$1/ge
```
[Try it online!](https://tio.run/##Dcu7DoIwFADQ/X5FQ4jRBGkcnG4c@QDnsgiUUqAP2/IyxE@3Mp8cy914j9HTnCaZ0tVcrx8ch74TbeNfzBo5bcHx5U1I8viqvXymp7I455cd0xsV/KiMoQNPhFGwcBc2mKSxDHzTig76YURY67kCrTIgaBENO5SQn7FBGu3j1f4B "Perl 5 – Try It Online")
```
s/.                                  #replace one char at a time from input
 /
   ",mnbvcxz;lkjhgfdsa[poiuytrewq  " #...with its next char in this string
     =~ m| \Q$&\E (.)|x;             #found by searching for current char in $&
                                     #which must be escaped by \Q and \E
                                     #since [ has a special meaning in regexes.
   $1                                #Return next char captured into $1 by (.) 
 /gex                                #g = global search: all chars
                                     #e = treat replacement string as eval code
                                     #x = allow white-space, improve readability
```
[Answer]
# [R](https://www.r-project.org/), ~~68~~ 55 bytes
```
function(x)chartr("snvfrghjokl;,mp[wtdyibecux","a-z",x)
```
[Try it online!](https://tio.run/##Rc5LDoMgEIDhfU9B6EYSegLSk7BSFMHyKkVFL08Zmyor/i9khljks8jZiaS9azIRqo0pNvjjFhlHNfmXYdQGvqZ@090g5owpbh87ppkUWd9xziImN7ii0VtM7ug4LZLaAa9DTNvJb0jgWfvAT94gjyG9HNU1BBJ4qt84FamaoFks3aV7TVBn6YWocxYQscCY5/@Vxhujw28lQpiULw "R – Try It Online")
Abusing laconic `Ranges are supported in the specifications` in `chartr` [documentation](https://stat.ethz.ch/R-manual/R-devel/library/base/html/chartr.html) (forced to work by try and error).
Inspired by [@Neil's answer](https://codegolf.stackexchange.com/a/230882/55372).
[Answer]
# [Haskell](https://www.haskell.org/), 59 bytes
```
mapM(`lookup`(zip<*>tail)",mnbvcxz;lkjhgfdsa[poiuytrewq  ")
```
[Try it online!](https://tio.run/##Xc9dbsIwDMDx953CivYAEztBKAdA4gTZA@lH2lAnMU0KtIdfabQJJPvxr59ludOxbxAXU/wsTtNpc8YQ@pHOm9nS/uuQtMWt2Dlf3qrHLLG/dK2po1YU7DiloblfAcR23bW@qMMHAA3WJ/gEAyIqJQcBeYoCjmNMIDQRNoI5aIPjDoz1zN2bIU3MXXNkbrSBFHNTjvxubdqO382RuUuP8o@9XbdGxh7VreRsXiNj3u3@1ZuV3jEFkqQMKv/xUoAB0VL@Y/mtDOo2Lt8V0RM "Haskell – Try It Online")
A function `String -> Maybe String`; it maps `"s gom"` to `Just "a fin"`.
[Answer]
# [Common Lisp](http://www.clisp.org/), 102 bytes
```
(defun f(i &aux(s",mnbvcxz;lkjhgfdsa[poiuytrewq  "))(map'string(lambda(c)(elt s(1+(position c s))))i))
```
[Try it online!](https://tio.run/##jZKxbsIwEIbn5ilOrihnSocidSHqUCEqIXUq6hR1MIkDBjs2sQMJQ16d2oBCK1VVvfj03W//9t2lUlhzPGLG86qAHAXcsapGS4aqWOzS@hDLzXq1zDPLEqNF1biS77cAhFJUzPStK0WxRMnUImOYUuTSgcXHezTaCid0ASlY6peg9GRjWMkUd7yEgePWPaTMcjuIAPqIxCZJXBIgzBjJCfUUwFNYahUo5KLo6J6XrvF0G4KOVkKbxNMmBNcbsny5CjeEoKPrjYw9XPm9Y3W6W3h28HvHCjX0aFGojkBs4lgnJyeQWkphvrn58gA51YhG0aW03V8BRWEqB7w2PHU8e9CVS7Xi4TDmulTMgQMyC6JxO3pyrW1704sYLuIu8c5tJa@6dpy8vsze2nj@MZlM5/P2sx31SHQD8LupdzxnKOC5lc9/aOjpjf/SRWi8ygHyHS8buO1fRgSw9lahvQFei1JT@mMe/LB8AQ "Common Lisp – Try It Online")
Test cases included in TIO.
[Answer]
# Excel, 93 bytes
```
=CONCAT(IFERROR(CHAR(FIND(MID(A1,SEQUENCE(LEN(A1)),1),"snvfrghjokl;,mp[wtdyibecux")+96)," "))
```
[Link to Spreadsheet](https://1drv.ms/x/s!AkqhtBc2XEHJnEGX_Z79laPncjcs?e=u9gVvb)
[Answer]
# [PHP](https://php.net/), 80 bytes
```
str_replace($a=str_split('wertyuiop[asdfghjkl;yxcvbnm,'),[-1=>'q']+$a,$argv[1]);
```
Avoids string repetition and double str\_split().
[Try it online!](https://tio.run/##FcdBDoIwEADAr/TQpBDqgXMtPGRDzIoVkALLtqK8fo1zGxpJrq2XlPnGgSL2odDo/00Up1yYT@B8vqeNANPjOYyvObrz2x/3dbGmtHCpfWN201UarUYeDqi70omISgCOlVI/ "PHP – Try It Online")
[Answer]
## PHP, 186 114 Bytes
```
$W=str_split(",mnbvcxz;lkjhgfdsa[poiuytrewq");for(;$c=$argv[1][$p++];)echo($c!==" ")?$W[array_flip($W)[$c]+1]:" ";
```
[Try it online!](https://tio.run/##Dck7EsIgEADQqyCzBQw2aUUmx6DYYTKI@Wk06xKj8fKY5jWPBirnmnbBu7xwk2kaFyWPj@dlTd@fne63oe@uOSLN43tbuP28pLbdzMpCchC5X7EKCGRMsLpNw6wgHZyTQuoaPEbmuDXdNJICrxFSMFU47WtLKSIjWhZC/AE)
Definitely not the shortest answer on here, but I'm not sure how I could handle this in PHP without using a big array. Any input would be greatly appreciated!
-72 bytes by changing a large keyed array into one small one. Just iterates over every character, find it in the array, then prints the next element in the array.
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), ~~45~~ 35 bytes
```
.rQ"[poiuytrewq;lkjhgfdsa,mnbvcxz  
```
[Try it online!](https://tio.run/##K6gsyfj/X68oUCm6ID@ztLKkKLW80DonOysjPS2lOFEnNy@pLLmiSkHh/38lBesCa@v86IJoJQA "Pyth – Try It Online")
~~```
sm?gJtxK.",zcVÖzùwÔ\"Ã?4‰ØÝ”gR¹³3"dZ@KJ\ Q
```~~
[Try it online!](https://tio.run/##AUsAtP9weXRo//9zbT9nSnR4Sy4iLHpjVsOWesO5d8OUXCIBw4M/NMKJwo3DmMOdwpRnUsK5wrMRMyJkWkBLSlwgUf//IiA7cDs7b1twWyI "Pyth – Try It Online")
\***Edit:**
Improved solution is rather boring...  
`"[poiuytrewq;lkjhgfdsa,mnbvcxz`  is a string of every possible char followed by the char it's meant to be (i.e. ytrewq) with two spaces on the end (space is meant to be space);
This is all surrounded with `.r` which will translate each element of `Q`(Input) into the next element.
**Previous solution**  
Haven't golfed in a while so this feels pretttty rusty...
Maps through qwerty string, shifting char to the left unless it's a space.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), 13 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
žV€¦…[;,øSžW‡
```
[Try it online.](https://tio.run/##yy9OTMpM/f//6L6wR01rDi171LAs2lrn8I7go/vCHzUs/P9fSUmpODrauoirWCE9P5erPLWopJKrNDO/IJqrOCUtPYMrKzvHmqsiuSyJKy9Xh0vBusDaOj8aKKugANQKAA)
**Explanation:**
```
žV            # Push builtin ["qwertyuiop","asdfghjkl","zxcvbnm"]
  €¦          # Remove the first character from each: ["wertyuiop","sdfghjkl","xcvbnm"]
    …[;,ø     # Zip/transpose with string "[;,":
              #  [["wertyuiop","["],["sdfghjkl",";"],["xcvbnm",","]]
         S    # Convert it to a flattened list of characters: 
              #  ["w","e","r","t","y","u","i","o","p","[","s","d","f","g","h","j","k",
              #   "l",";","x","c","v","b","n","m",","]
          žW  # Push builtin "qwertyuiopasdfghjklzxcvbnm"
            ‡ # Transliterate all characters in the (implicit) input
              # (after which the result is output implicitly)
```
]