Étant donné l'entrée suivante:

• Un entier noù n > 0.
• Une chaîne soù sn'est pas vide et s~=[0-9A-Z]+(majuscules alphanumériques uniquement).

À l'aide d'un clavier QWERTY standard simplifié (comme illustré ci-dessous):

1234567890
QWERTYUIOP
ASDFGHJKL
ZXCVBNM

Effectuez l'opération suivante:

• Recherchez la ligne d'origine de chaque caractère sur le clavier.
• Remplacez la lettre par l'équivalent décalé correct pour en nfonction de sa position d'origine + n.
  • EG s="AB"et n=2: Adeviendraient Det Bdeviendraient M.
• Si keyboard_row[position + n] > keyboard_row.length, revenez au début.
  • EG s="0P"et n=2: 0deviendraient 2et Pdeviendraient W.

Exemples:

f("0PLM",1)    = 1QAZ
f("ZXCVB",2)   = CVBNM
f("HELLO",3)   = LYDDW
f("0PLM",11)   = 1QSV
f("0PLM",2130) = 0PHX

Règles

• Il s'agit du code-golf , le plus petit nombre de victoires d'octets.

C'est un peu plus difficile qu'il n'y paraît à première vue.

Gelée , 13 octets

ØQØDṭ,ṙ€¥⁸F€y

Essayez-le en ligne!

Comment ça marche

ØQØDṭ,ṙ€¥⁸F€y  Main link. Left argument: n (integer). Right argument: s (string)

ØQ             Qwerty; set the return value to
               ["QWERTYUIOP", "ASDFGHJKL", "ZXCVBNM"].
  ØD           Digits; yield "0123456789".
    ṭ          Tack, yielding ["QWERTYUIOP", "ASDFGHJKL", "ZXCVBNM", "0123456789"].
        ¥⁸     Call the two links to the left as a dyadic chain, with right
               argument n.
      ṙ€       Rotate each string in the array n units to the left.
     ,         Yield the pair of the unmodified and the rotated string array.
          F€   Flatten each, mapping, e.g., ["QWERTYUIOP", ..., "0123456789"] to
               "QWERTYUIOPASDFGHJKLZXCVBNM0123456789".
            y  Translate s according to the mapping we've built.

Python 2 , 110 octets

lambda s,n,y='1234567890'*99+'QWERTYUIOP'*99+'ASDFGHJKL'*99+'ZXCVBNM'*99:''.join(y[y.find(c)+n%630]for c in s)

Essayez-le en ligne!

Cela utilise une chaîne suffisamment grande (99 copies de chaque ligne) et le LCM entre les longueurs de lignes (630) pour trouver la substitution correcte en évitant une correction individuelle entre chaque ligne.

Java 8, 159 158 octets

n->s->{for(int i=s.length,j;i-->0;)for(String x:"1234567890;QWERTYUIOP;ASDFGHJKL;ZXCVBNM".split(";"))if((j=x.indexOf(s[i])+n)>=n)s[i]=x.charAt(j%x.length());}

-1 octet grâce à @ OlivierGrégoire modifiant le tableau d'entrée au lieu d'imprimer directement.

Explication:

Essayez-le en ligne.

n->s->{  // Method with integer and character-array parameters, and no return-type
  for(int i=s.length,j;i-->0;)
         //  Loop over the input character-array with index
    for(String x:"1234567890;QWERTYUIOP;ASDFGHJKL;ZXCVBNM".split(";"))
         //   Inner loop over the qwerty-lines
      if((j=x.indexOf(s[i])+n)>=n)
         //    If the current qwerty-line contains the character
         //     Set `j` to the index of this character on that line + input `n`
        s[i]=x.charAt(j%x.length());}
         //     Replace the character at index `i`
         //     with the new character (at index `j` modulo length_of_qwerty_line)

Rétine , 49 octets

"$&"+T`9o`dQW\ERTYUI\OPQASDFG\HJK\LAZXC\VBNMZ
0A`

Essayez-le en ligne! Prend entrée net ssur des lignes séparées. Explication:

"$&"+

Répétez nfois.

T`9o`dQW\ERTYUI\OPQASDFG\HJK\LAZXC\VBNMZ

Déplacez tous les caractères d'une touche vers la droite.

0A`

Supprimer n.

JavaScript (ES6), 101 99 octets

Prend une entrée dans la syntaxe de curry (s)(n). Fonctionne avec des tableaux de caractères.

s=>n=>s.map(c=>(S='1QAZ2WSX3EDC4RFV5TGB6YHN7UJM8IK_9OL_0P')[(p=S.search(c)+n*4)%(-~'9986'[p%4]*4)])

Cas de test

let f =

s=>n=>s.map(c=>(S='1QAZ2WSX3EDC4RFV5TGB6YHN7UJM8IK_9OL_0P')[(p=S.search(c)+n*4)%(-~'9986'[p%4]*4)])

console.log(JSON.stringify(f([..."0PLM"])(1)))    // 1QAZ
console.log(JSON.stringify(f([..."ZXCVB"])(2)))   // CVBNM
console.log(JSON.stringify(f([..."HELLO"])(3)))   // LYDDW
console.log(JSON.stringify(f([..."0PLM"])(11)))   // 1QSV
console.log(JSON.stringify(f([..."0PLM"])(2130))) // 0PHX

Comment?

Nous recherchons la position p de chaque caractère de l'entrée dans une chaîne S où les lignes du clavier sont entrelacées: les 4 premiers caractères sont '1QAZ' (première colonne du clavier), les 4 caractères suivants sont '2WSX' (deuxième colonne du clavier) et ainsi de suite. Les positions inutilisées sont rembourrées avec des traits de soulignement et les dernières sont simplement jetées.

col # | 0    | 1    | 2    | 3    | 4    | 5    | 6    | 7    | 8    | 9
------+------+------+------+------+------+------+------+------+------+---
row # | 0123 | 0123 | 0123 | 0123 | 0123 | 0123 | 0123 | 0123 | 0123 | 01
------+------+------+------+------+------+------+------+------+------+---
char. | 1QAZ | 2WSX | 3EDC | 4RFV | 5TGB | 6YHN | 7UJM | 8IK_ | 9OL_ | 0P

Cela nous permet d'identifier facilement la ligne avec p mod 4 et élimine le besoin de séparateurs explicites entre les lignes.

On avance par 4n positions, appliquer le bon modulo pour cette ligne (40, 40, 36 et 28 respectivement) et choisir le caractère de remplacement trouvé à cette nouvelle position dans S .

Gelée , 18 octets

ØQØDṭẋ€‘}Ẏ©iЀ⁸+ị®

Essayez-le en ligne!

C,  152  149 octets

Merci à @gastropner pour avoir économisé trois octets!

j,l;f(S,n){for(char*s=S,*k;*s;++s)for(k="1234567890\0QWERTYUIOP\0ASDFGHJKL\0ZXCVBNM\0";l=strlen(k);k+=l+1)for(j=l;j--;)k[j]-*s||putchar(k[(j+n)%l]);}

Essayez-le en ligne!

Déroulé:

j,l;
f(S,n)
{
    for (char*s=S, *k; *s; ++s)
        for (k="1234567890\0QWERTYUIOP\0ASDFGHJKL\0ZXCVBNM\0"; l=strlen(k); k+=l+1)
            for (j=l; j--;)
                k[j]-*s || putchar(k[(j+n)%l]);
}

Rouge , 152 octets

f: func[s n][foreach c s[foreach[t l]["1234567890"10"QWERTYUIOP"10"ASDFGHJKL"9"ZXCVBNM"7][if p: find t c[if(i:(index? p)+ n // l)= 0[i: l]prin t/(i)]]]]

Essayez-le en ligne!

Non golfé:

f: func [s n][1
    foreach c s [
        foreach [t l] ["1234567890"10"QWERTYUIOP"10"ASDFGHJKL"9"ZXCVBNM"7][
            p: find t c
            if p [ 
                i: (index? p) + n // l
                if i = 0 [i: l]
                prin t/(i) ]]]]

Haskell , 99 octets

f(s,n)=[dropWhile(/=c)(cycle r)!!n|c<-s,r<-words"1234567890 QWERTYUIOP ASDFGHJKL ZXCVBNM",elem c r]

Essayez-le en ligne!

Perl 5 , 94 + 1 ( -p) = 95 octets

$s=<>;for$i(1234567890,QWERTYUIOP,ASDFGHJKL,ZXCVBNM){eval"y/$i/".(substr$i,$s%length$i)."$i/"}

Essayez-le en ligne!

Japt, 20 octets

Courir par la porte pour dîner donc plus de golf et une explication à suivre.

;£=D·i9òs)æøX)gV+UbX

Essayez-le

Perl, 59 58 57 56 octets

Comprend +pour-p

Donnez une entrée sur STDIN sur 2 lignes, d'abord la chaîne, puis la répétition

(echo 0PLM; echo 2130) | perl -pe '$a="OPQWERTYUILASDF-MZXCVBNM0-90";eval"y/HI$a/J$a/;"x<>'

Perl 5 , 85 octets

Code de 84 octets + 1 pour -p.

eval join"",map"y/$_/@{[/./&&$'.$&]}/;",(1234567890,QWERTYUIOP,ASDFGHJKL,ZXCVBNM)x<>

Essayez-le en ligne!

Nettoyer , 144 119 octets

import StdEnv

\n s=[l.[(i+n)rem(size l)]\\c<-s,l<-["1234567890","QWERTYUIOP","ASDFGHJKL","ZXCVBNM"],i<-[0..]&j<-:l|j==c]

Essayez-le en ligne!

Fonction Lambda avec la signature Int ![Char] -> [Char]

Rubis , 101 octets

->s,n{n.times{s.tr! '1234567890QWERTYUIOPASDFGHJKLZXCVBNM','2345678901WERTYUIOPQSDFGHJKLAXCVBNMZ'};s}

Essayez-le en ligne!

Je suis honnêtement un peu déçu de ne pas pouvoir faire mieux avec des méthodes «plus intelligentes». Le plus proche que j'ai obtenu était

a=%w{1234567890 QWERTYUIOP ASDFGHJKL ZXCVBNM}
b=a.map{|r|r[1..-1]<<r[0]}*''
a*=''
n.times{s.tr! a,b}

pour un gain net de 7 caractères.