Data una parola (o qualsiasi sequenza di lettere) come input, è necessario interpolare tra ogni lettera in modo tale che ogni coppia di lettere adiacenti nel risultato sia anche adiacente su una tastiera QWERTY, come se si digitasse l'input camminando su una tastiera gigante. Ad esempio, " sì " potrebbe diventare " y tr es ", " cat " potrebbe diventare " c xz a wer t ".

Regole:

• Questo è il formato della tastiera che dovresti usare:

  qwertyuiop
 asdfghjkl
  zxcvbnm

  Qualsiasi coppia di tasti che si tocca in questo layout è considerata adiacente. Ad esempio, "s" ed "e" sono contigui, mentre "s" e "r" non lo sono.

• La "parola" di input consisterà in qualsiasi sequenza di lettere. Avrà solo lettere, quindi non avrai a che fare con personaggi speciali.
• L'input può essere in qualsiasi forma conveniente: stdin, una stringa, un elenco, ecc. Il maiuscolo / minuscolo non ha importanza; puoi prendere quello che è più conveniente.
• L'output può essere in qualsiasi forma conveniente: stdout, una stringa, un elenco, ecc. Il maiuscolo / minuscolo non ha importanza e non deve essere coerente.
• Qualsiasi percorso attraverso la tastiera è valido, tranne per il fatto che non è possibile incrociare nuovamente la lettera precedente prima di passare alla lettera successiva. Ad esempio, " ciao " potrebbe diventare " h j i " o " h jnbgyu i ", ma non " h b h u i ".
• Una lettera non è contigua a se stessa, quindi il " sondaggio " non può diventare " sondaggio ". Invece dovrebbe diventare qualcosa di simile a " pol k l ".
• Non sono consentite lettere di output prima o dopo la parola. Ad esempio, " era " non può diventare "tre era " o " era dfg".

Questo è il golf del codice, vince la risposta più breve in byte.

Japt -g , 23 byte

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

Provalo online!

Accetta input come una matrice di lettere maiuscole. Molto simile alle altre risposte altrimenti.

Spiegazione:

;                          :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 byte

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

Provalo online!

Cammina l'intera tastiera fino a quando la parola è scritta.

Python 2 , 274 byte (soluzione ottimale)

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

-4 byte grazie 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

Provalo online!

Questa soluzione offre l'output più breve possibile. La tastiera viene trasformata in un grafico utilizzato per trovare il percorso più breve per calcolare la stringa di output:

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

JavaScript (ES6), 70 byte

Stessa strategia di TFeld.

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

Provalo online!

05AB1E , 43 byte

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

Non è la lingua giusta per questa sfida, dal momento che non può usare regex come le altre risposte.

Provalo online o verifica tutti i casi di test .

Spiegazione:

ü)               # 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"

Carbone , 48 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

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

Prendi la stringa qwertyuioplkmjnhbgvfcdxsza.

≔⌕η§θ⁰ζ

Trova la posizione del primo carattere della parola. Questo indice normalmente supera il carattere appena raggiunto, ma questo valore falsifica la prima iterazione del ciclo per stampare il primo carattere della parola.

Ｆθ

Passa sopra ogni personaggio.

Ｆ⊕﹪⁻⌕ηιζ²⁶«

Calcola quanti caratteri stampare per includere il carattere successivo della parola e esegui il ciclo tante volte.

§ηζ≦⊕ζ

Stampa il carattere successivo indicizzato ciclicamente e incrementa l'indice.