[Question]
  [
Given a word (or any sequence of letters) as input, you must interpolate between each letter such that each adjacent pair of letters in the result is also adjacent on a QWERTY keyboard, as if you typed the input by walking on a giant keyboard. For example, '**yes**' might become '**y**tr**es**', '**cat**' might become '**c**xz**a**wer**t**'.
### Rules:
* This is the keyboard format you should use:
``q````w````e````r````t````y````u````i````o````p``  
 ``a````s````d````f````g````h````j````k````l``  
  ``z````x````c````v````b````n````m``
Any pair of keys which is touching in this layout is considered adjacent. For instance, 's' and 'e' are ajacent, but 's' and 'r' are not.
* The input "word" will consist of any sequence of letters. It will have only letters, so you don't have do deal with special characters.
* The input can be in any convenient form: stdin, a string, a list, etc. Letter case does not matter; you can take whatever is more convenient.
* The output can be in any convenient form: stdout, a string, a list, etc. Letter case does not matter, and it does not need to be consistent.
* Any path across the keyboard is valid, except that you cannot cross the previous letter again before getting to the next letter. For example, '**hi**' could become '**h**j**i**' or '**h**jnbgyu**i**', but not '**h**b*h*u**i**'.
* A letter is not ajacent with itself, so '**poll**' cannot become '**poll**'. Instead it would need to become something like '**pol**k**l**'.
* No output letters are allowed before or after the word. For example, '**was**' cannot become 'tre**was**' or '**was**dfg'.
This is code golf, the shortest answer in bytes wins.
  
[Answer]
# [Python 2](https://docs.python.org/2/), 83 bytes
```
lambda s:re.findall('.*?'.join(s),'qwertyuioplkmnjhbvgfcxdsza'*len(s))[0]
import re
```
[Try it online!](https://tio.run/##Tcu9DsIgFEDhvU/BdqExxDiaGB9EHWgBoV5@BLTiy6MuhvFLzom1mOB3TR/ODYWbpCB5nxTX1kuBSIGPR@BLsJ5mtoH7qlKpDxsi3pxfzPS86vkl81vAiOrXsNP2MlgXQyokqRaT9YVoClVlYMOfsyg9je0VA2LvVXzf9gE "Python 2 – Try It Online")
Walks the entire keyboard until the word is written. 
[Answer]
# [Python 2](https://docs.python.org/2/) + [NetworkX](https://networkx.org), 274 bytes (optimal solution)
# ~~296~~ ~~300~~ ~~302~~ ~~308~~ ~~315~~ ~~319~~ ~~324~~ ~~327~~ ~~328~~ ~~430~~ ~~432~~ bytes
-4 bytes thanks to mypetlion
```
from networkx import*
i=input()
M,z='qwertyuiop  asdfghjkl   zxcvbnm'.center(55),i[:1]
G=from_edgelist([(M[e],M[e+h])for h in[-1,1,11,12,-11,-12]for e in range(44)if' '!=M[e]and' '!=M[e+h]])
for y,x in zip(i,i[1:]):z+=[shortest_path(G,y,x)[1:],list(G[y])[0]+y][x==y]
print z
```
[Try it online!](https://tio.run/##NU/BbsMgDL3nK7wTsJBpidpLJM459QsQqrKGNLQJMELWwM9nMGmy/WzpPT3bNvjJ6OY4RmcW0NK/jHvuoBZrnH8vFFPabh6T4kIjQ98v6XzYlLEA/TqM9@nxnAEg7refL72gj5vUXjp8PhOqeFuLomPZ@CqHu5zV6jHHFy4FTVBOgozGwQRK86qmKVI2tEqtqhuROZk4cL2@S3w6ETUiQG8sG/R6@J@TjyBFVge6Z31UFqu0vm4FaWPJ@DqlX@Tqr7b3E@5o0pHM0r@LOh4E4Z@iDILvjAVRWKe0h3gcHFlEAW2IopiHBGhOJVOtSPwC "Python 2 – Try It Online")
This solution gives the shortest possible output. The keyboard is transformed into a graph used to find the shortest path to compute the output string:
```
puzzles     --> poiuhbvcxzazxcvbhjklkiuytres
programming --> poiuytrtyuioijhgtresasdcvbnmkmkijnbg
code        --> cvbhjioijhgfde
golf        --> ghjiolkjhgf
yes         --> ytres
hi          --> hji
poll        --> polpl
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt) `-g`, 23 bytes
```
;D·ÎÔ+D·Årí)pUl)fUq".*?
```
[Try it online!](https://ethproductions.github.io/japt/?v=1.4.6&code=O0S3ztQrRLfFcu0pcFVsKWZVcSIuKj8=&input=WyJQIiJPIiJMIiJMIl0KLWc=)
Takes input as an array of capital letters. Very similar to the other answers otherwise.
Explanation:
```
;                          :Set D to the keyboard layout
 D·Î                       :Get the first row of keys
    Ô                      :Reversed
     +                     :Concat
      D·Å                  :The other two rows
         rí)               :Interleaved
            p              :Repeat that string
             Ul)           : A number of times equal to the length of the input
                f          :Get the substrings that match
                 U         : The input
                  q".*?    : joined with ".*?"
                           :Implicitly output just one of the matches
```
[Answer]
# JavaScript (ES6), 70 bytes
Same strategy as TFeld.
```
s=>'qazsxdcfvgbhnjmklpoiuytrew'.repeat(s.length).match(s.join`.*?`)[0]
```
[Try it online!](https://tio.run/##dclBDsIgEADAux8BTNz4gepDmiZd6UJByiJgtX4e9a7HyXhcsejsUj1EnqiZrpXuJG74Ks9Jm9Ve5uiXa0js7lvN9BCQKRFWWSBQtHVWsGDV88eeXRxhfx5Vfxya5lg4EAS20sgeAITGKgaldj9qo/KvEofwvfYG "JavaScript (Node.js) – Try It Online")
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 48 bytes
```
≔”&⌈″⌊5ＥWＸＶＮa…-εW¶ζR”η≔⌕η§θ⁰ζＦθＦ⊕﹪⁻⌕ηιζ²⁶«§ηζ≦⊕ζ
```
[Try it online!](https://tio.run/##TY2xDoIwGIRneIqGqU1qYhxcnFhMGEh8hdoWWi1/oS2IGJ@9IqJxuuHuvo8r5rhlJsbce10DzrqbdOHea9uaa3MBda6HiovRTyyjSJFDug6PGgRWFOWhACFH3FG0JYSiaZ5U1iHcEbRkAdzJRkKQApdW9MbiUkPvfwS9vCja7Qkh6JEmJ6ch4C9YvdsZmpSsXd1/yI/wGWNrjYmbwbwA "Charcoal – Try It Online") Link is to verbose version of code. Explanation:
```
≔”&⌈″⌊5ＥWＸＶＮa…-εW¶ζR”η
```
Get the string `qwertyuioplkmjnhbgvfcdxsza`.
```
≔⌕η§θ⁰ζ
```
Find the position of the first character of the word. This index is normally one past the character just reached, but this value fakes out the first iteration of the loop to print the first character of the word.
```
Ｆθ
```
Loop over each character.
```
Ｆ⊕﹪⁻⌕ηιζ²⁶«
```
Compute how many characters to print to include the next character of the word and loop that many times.
```
§ηζ≦⊕ζ
```
Print the next character cyclically indexed and increment the index.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), ~~43~~ ~~33~~ 31 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
ü2εUžV`.ιJsRìD«Œ.ΔнÅ?XyθÅ¿}¨}JIθ«
```
Not the right language for this challenge, since it cannot use regex like the other answers did.. EDIT: proven wrong by [*@Makonede*'s 05AB1E answer using the Elixir eval builtin `.E`](https://codegolf.stackexchange.com/a/241815/52210).
[Try it online](https://tio.run/##AToAxf9vc2FiaWX//8O8Ms61VcW@VmAuzrlKc1LDrETCq8WSLs6Uw4EywqNSWFF9wqh9SknOuMKr//9wb2xs) or [verify all test cases](https://tio.run/##AVUAqv9vc2FiaWX/fHZ5PyIg4oaSICI/ef/DvDLOtVXFvlZgLs65SnNSw6xEwqvFki7OlMOBMsKjUlhRfcKofUp5zrjCq/8s/2hpCnBvbGwKd2FzCmNhdAph).
**Explanation:**
```
ü2             # Split the input into overlapping pairs
               #  i.e. "poll" → ["po","ol","ll"]
  ε            # Map each to:
   U           #  Pop and store the current pair in variable `X`
   žV          #  Push ["qwertyuiop","asdfghjkl","zxcvbnm"]
     `         #  Pop and push all three separated to the stack
      .ι       #  Interweave the top two with each other
        J      #  Join the list of characters to a single string
               #   → "azsxdcfvgbhnjmkl"
         s     #  Swap so "qwertyuiop" is at the top
          R    #  Reverse it to "poiuytrewq"
           ì   #  Prepend it in front of the earlier string
               #   → "poiuytrewqazsxdcfvgbhnjmkl"
            D« #  Duplicate it, and append it to itself
               #   → "poiuytrewqazsxdcfvgbhnjmklpoiuytrewqazsxdcfvgbhnjmkl"
   Œ           #  Get all substrings of this strings
    .Δ         #  Find the first substring which is truthy for:
      Á        #   Rotate the current string once towards the right
       2£      #   Only leave the first 2 letters
         R     #   Reverse it
          XQ   #   Check if it's equal to pair `X`
     }¨        #  After the find_first, remove the last character
  }            # Close the map
   J           # Join everything together
    Iθ«        # Append the last character of the input
               # (after which the result is output implicitly)
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~51~~ ~~39~~ 38 bytes
*-1 thanks to [Kevin Cruijssen](https://codegolf.stackexchange.com/users/52210/kevin-cruijssen).*
```
gžV`.ιJsRì×s….*?ý’RŽ½™«.‡Ð~r/ÿ/,"ÿ"’.E
```
[Try it online!](https://tio.run/##yy9OTMpM/f8//ei@sAS9czu9ioMOrzk8vfhRwzI9LfvDex81zAw6uvfQ3kctiw6t1nvUsPDwhLoi/cP79XWUDu9XAsrquf7/H61UoKSjoJQPInIgRCwA "05AB1E – Try It Online") Takes input as a list of lowercase letters and outputs as a singleton list.
This answer exists to [prove Kevin Cruijssen wrong](https://codegolf.stackexchange.com/a/177134); you *can* use regex in 05AB1E.
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal), 16 bytes
```
Lk•÷Y$Ṙp*?‛€?jẎh
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyJBIiwiIiwiTGvigKLDt1kk4bmYcCo/4oCb4oKsP2rhuo5oIiwiIiwieWVzXG5jYXRcbmhpXG5wb2xsXG53YXMiXQ==)
```
Lk•÷Y$Ṙp*?‛€?jẎh
 k•              # List of rows on the keyboard: ["qwertyuiop", "asdfghjkl", "zxcvbnm"]
   ÷             # Push each item onto the stack
    Y            # Interleave the top two: "azsxdcfvgbhnjmkl"
     $           # Swap so "qwertyuiop" is on top
      Ṙ          # Reverse it
       p         # Prepend it to the other string
L       *        # Repeat it input-length number of times
         ?‛€?j   # Join each character in the input by ".*?"
              Ẏh # Get the first regex match
```
[Answer]
# [J-uby](https://github.com/cyoce/J-uby), 71 bytes
Again lost a few bytes by having to call `Regexp.new` with a string instead of using a Regexp literal with interpolation. Same technique as [TField](https://codegolf.stackexchange.com/a/177097/11261) et al.
```
-[:+@|:*&"qazsxdcfvgbhnjmklpoiuytrew",~:join&".*?"|:new&Regexp]|:<<&:[]
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m700K740qXLBIjfbpaUlaboWN911o620HWqstNSUChOriitSktPK0pMy8rJys3MK8jNLK0uKUsuVdOqssvIz89SU9LTslWqs8lLL1YJS01MrCmJrrGxs1KyiY6HG-RSUlhQruEVHKyUr6SgoJYKIEqXYWC64eCVIKBVEFKOIF4CE8kFEDoSIhZq5YAGEBgA)
## Explanation
```
-[
  :+@ | :* & "qazsxdcfvgbhnjmklpoiuytrew",  # Repeat string times size of input
  ~:join & ".*?" | :new&Regexp              # Also make a Regexp by joining input with ".*?"
] |                                         # then
:<< & :[]                                   # call :[] with the two values, i.e. repeated_string[regexp]
```
]