Dada una palabra (o cualquier secuencia de letras) como entrada, debe interpolar entre cada letra de manera que cada par de letras adyacentes en el resultado también sea adyacente en un teclado QWERTY, como si escribiera la entrada caminando en un teclado gigante. Por ejemplo, ' sí ' podría convertirse en ' y tr es ', ' cat ' podría convertirse en ' c xz a wer t '.

Reglas:

• Este es el formato de teclado que debe usar:

  qwertyuiop
 asdfghjkl
  zxcvbnm

  Cualquier par de teclas que se toque en este diseño se considera adyacente. Por ejemplo, 's' y 'e' son adyacentes, pero 's' y 'r' no lo son.

• La "palabra" de entrada consistirá en cualquier secuencia de letras. Solo tendrá letras, por lo que no debe tratar con caracteres especiales.
• La entrada puede estar en cualquier forma conveniente: stdin, una cadena, una lista, etc. El caso de las letras no importa; puedes tomar lo que sea más conveniente.
• El resultado puede ser de cualquier forma conveniente: stdout, una cadena, una lista, etc. Las mayúsculas y minúsculas no importan, y no necesitan ser consistentes.
• Cualquier ruta en el teclado es válida, excepto que no puede volver a cruzar la letra anterior antes de llegar a la siguiente. Por ejemplo, ' hola ' podría convertirse en ' h j i ' o ' h jnbgyu i ', pero no ' h b h u i '.
• Una carta no es adyacente a sí misma, por lo que ' encuesta ' no puede convertirse en ' encuesta '. En cambio, tendría que convertirse en algo así como ' pol k l '.
• No se permiten letras de salida antes o después de la palabra. Por ejemplo, ' was ' no puede convertirse en 'tre was ' o ' was dfg'.

Este es el código de golf, gana la respuesta más corta en bytes.

Japt -g , 23 bytes

;D·ÎÔ+D·Årí)pUl)fUq".*?

Pruébalo en línea!

Toma entrada como una matriz de letras mayúsculas. Muy similar a las otras respuestas de lo contrario.

Explicación:

;                          :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 once of the matches

Python 2 , 83 bytes

lambda s:re.findall('.*?'.join(s),'qwertyuioplkmnjhbvgfcxdsza'*len(s))[0]
import re

Pruébalo en línea!

Camina todo el teclado hasta que se escribe la palabra.

Python 2 , 274 bytes (solución óptima)

296 300 302 308 315 319 324 327 328 430 432 bytes

-4 bytes gracias a 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

Pruébalo en línea!

Esta solución ofrece la salida más corta posible. El teclado se transforma en un gráfico utilizado para encontrar la ruta más corta para calcular la cadena de salida:

puzzles     --> poiuhbvcxzazxcvbhjklkiuytres
programming --> poiuytrtyuioijhgtresasdcvbnmkmkijnbg
code        --> cvbhjioijhgfde
golf        --> ghjiolkjhgf
yes         --> ytres
hi          --> hji
poll        --> polpl

JavaScript (ES6), 70 bytes

La misma estrategia que TFeld.

s=>'qazsxdcfvgbhnjmklpoiuytrew'.repeat(s.length).match(s.join`.*?`)[0]

Pruébalo en línea!

05AB1E , 43 bytes

ü)Jε©žVćRs`.ιJ«D«Œʒg≠yн®нQyθ®θQ**}yªн¨}JIθ«

No es el lenguaje correcto para este desafío, ya que no puede usar expresiones regulares como las otras respuestas.

Pruébelo en línea o verifique todos los casos de prueba .

Explicación:

ü)               # Split the input into overlapping pairs
                 #  i.e. "poll" → ["p","o"],["o","l"],["l","l"]]
  J              # Join each inner list together
                 #  i.e. ["p","o"],["o","l"],["l","l"]] → ["po","ol","ll"]
   ε             # Map each to:
    ©            #  Store the current value in the register
    žV           #  Push ["qwertyuiop","asdfghjkl","zxcvbnm"]
    ćR           #  Extract the head, and reverse it
                 #   i.e. ["qwertyuiop","asdfghjkl","zxcvbnm"] → "poiuytrewq"
    s`           #  Swap to take the remainder, and push them to the stack
      .ι         #  And then interweave them with each other
                 #   i.e. ["asdfghjkl","zxcvbnm"]
                 #    → ["a","z","s","x","d","c","f","v","g","b","h","n","j","m","k","l"]
        J        #  Join the list to a single string
                 #   i.e. → "azsxdcfvgbhnjmkl"
         «       #  Merge them together
                 #   i.e. "qwertyuiop" and "azsxdcfvgbhnjmkl"
                 #    → "poiuytrewqazsxdcfvgbhnjmkl"
          D«     #  Duplicate it, and append it to itself
                 #   i.e. "poiuytrewqazsxdcfvgbhnjmkl"
                 #    → "poiuytrewqazsxdcfvgbhnjmklpoiuytrewqazsxdcfvgbhnjmkl"
            Π   #  Get all substrings of this strings
                 #   i.e. → ["p","po","poi",...,"k","kl","l"]
ʒ              } #  Filter this list by:
 g≠              #   Where the length is NOT 1 (otherwise pair "ll" would result in "l")
              *  #   and
   yн®нQ         #   Where the first character of the substring and pair are the same
             *   #   and
        yθ®θQ    #   Where the last character of the substring and pair are the same
                 #    i.e. "po" → []
                 #    i.e. "ll" → ["lazsxdcfvgbhnjmkl"]
yª               #  After filtering, append the current pair to the filtered list
                 #   i.e. [] → ["po"]
                 #   i.e. ["lazsxdcfvgbhnjmkl"] → ["lazsxdcfvgbhnjmkl","ll"]
  н              #  Get the first item
                 #   ["po"] → "po"
                 #   ["lazsxdcfvgbhnjmkl","ll"] → "lazsxdcfvgbhnjmkl"
   ¨             #  Remove the last character
                 #   i.e. "po" → "p"
                 #   i.e. "lazsxdcfvgbhnjmkl" → "lazsxdcfvgbhnjmk"
}                # Close the map
 J               # Join everything together
                 #  i.e. ["p","o","lazsxdcfvgbhnjmk"] → "polazsxdcfvgbhnjmk"
  Iθ«            # And append the last character of the input
                 # (and output the result implicitly)
                 #  i.e. "polazsxdcfvgbhnjmk" and "poll" → "polazsxdcfvgbhnjmkl"

Carbón , 48 bytes

≔”&⌈″⌊5ＥWＸＶＮa…-εW¶ζR”η≔⌕η§θ⁰ζＦθＦ⊕﹪⁻⌕ηιζ²⁶«§ηζ≦⊕ζ

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

≔”&⌈″⌊5ＥWＸＶＮa…-εW¶ζR”η

Consigue la cuerda qwertyuioplkmjnhbgvfcdxsza.

≔⌕η§θ⁰ζ

Encuentra la posición del primer carácter de la palabra. Este índice normalmente es uno más allá del carácter que se acaba de alcanzar, pero este valor falsifica la primera iteración del bucle para imprimir el primer carácter de la palabra.

Ｆθ

Pase sobre cada personaje.

Ｆ⊕﹪⁻⌕ηιζ²⁶«

Calcule cuántos caracteres imprimir para incluir el siguiente carácter de la palabra y el bucle tantas veces.

§ηζ≦⊕ζ

Imprima el siguiente carácter indexado cíclicamente e incremente el índice.