Bei folgender Eingabe:

• Eine ganze Zahl nwo n > 0.
• Eine Zeichenfolge, sbei der ses sich nicht um eine leere Zeichenfolge handelt s~=[0-9A-Z]+(nur alphanumerische Großbuchstaben).

Verwendung einer standardmäßigen, vereinfachten QWERTZ-Tastatur (wie unten gezeigt):

1234567890
QWERTYUIOP
ASDFGHJKL
ZXCVBNM

Führen Sie den folgenden Vorgang aus:

• Suchen Sie die ursprüngliche Zeile, in der sich jedes Zeichen auf der Tastatur befindet.
• Ersetzen Sie den Buchstaben durch das korrekte verschobene Äquivalent für nbasierend auf seiner ursprünglichen Position + n.
  • EG s="AB"und n=2: Awürde werden Dund Bwürde werden M.
• Wenn keyboard_row[position + n] > keyboard_row.lengthja, kehren Sie zum Start zurück.
  • EG s="0P"und n=2: 0würde werden 2und Pwürde werden W.

Beispiele:

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

Regeln

• Dies ist Code-Golf , die niedrigste Anzahl an Bytes gewinnt.

Das ist etwas schwieriger als es auf den ersten Blick scheint.

Jelly , 13 Bytes

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

Probieren Sie es online!

Wie es funktioniert

Ø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 Bytes

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

Probieren Sie es online!

Dies verwendet eine ausreichend große Zeichenfolge (99 Kopien jeder Zeile) und die LCM zwischen den Zeilenlängen (630), um die richtige Ersetzung zu finden und eine individuelle Korrektur zwischen den einzelnen Zeilen zu vermeiden.

Java 8, 159 158 Bytes

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 Byte dank @ OlivierGrégoire, der das Eingabe-Array modifiziert, anstatt direkt zu drucken.

Erläuterung:

Probieren Sie es online aus.

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)

Retina , 49 Bytes

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

Probieren Sie es online! Nimmt Eingaben nund sin separaten Zeilen vor. Erläuterung:

"$&"+

Wiederhole das nmal.

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

Verschieben Sie alle Zeichen eine Taste nach rechts.

0A`

Löschen n.

JavaScript (ES6), 101 bis 99 Byte

Übernimmt Eingaben in der Currying-Syntax (s)(n). Funktioniert mit Arrays von Zeichen.

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

Testfälle

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

Wie?

Wir suchen die Position p jedes Zeichens der Eingabe innerhalb eines Strings S, in dem die Tastaturzeilen verschachtelt sind: Die ersten 4 Zeichen sind '1QAZ' (erste Spalte der Tastatur), die nächsten 4 Zeichen sind '2WSX' (zweite Spalte) der Tastatur) und so weiter. Nicht verwendete Positionen werden mit Unterstrichen aufgefüllt und die letzten werden einfach verworfen.

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

Dies ermöglicht es uns, die Zeile einfach mit p mod 4 zu identifizieren und macht explizite Trennzeichen zwischen den Zeilen überflüssig.

Wir rücken um 4n Positionen vor, wenden das richtige Modulo für diese Zeile an (40, 40, 36 und 28) und wählen das Ersetzungszeichen aus, das an dieser neuen Position in S gefunden wurde .

Jelly , 18 Bytes

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

Probieren Sie es online!

C,  152  , 149 Bytes

Vielen Dank an @gastropner für das Speichern von drei Bytes!

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]);}

Probieren Sie es online!

Abgerollt:

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]);
}

Rot , 152 Bytes

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)]]]]

Probieren Sie es online!

Ungolfed:

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 Bytes

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

Probieren Sie es online!

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

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

Probieren Sie es online!

Japt, 20 Bytes

Ich renne aus der Tür zum Abendessen, um mehr Golf zu spielen und eine Erklärung zu folgen.

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

Versuch es

Perl, 59 58 57 56 Bytes

Enthält +für-p

Geben Sie STDIN als 2 Zeilen ein, zuerst die Zeichenfolge, dann die Wiederholung

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

Perl 5 , 85 Bytes

84 Byte Code + 1 für -p.

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

Probieren Sie es online!

Sauber , 144 119 Bytes

import StdEnv

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

Probieren Sie es online!

Lambda-Funktion mit der Signatur Int ![Char] -> [Char]

Ruby , 101 Bytes

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

Probieren Sie es online!

Ich bin ehrlich gesagt ein wenig enttäuscht, dass ich mit "klügeren" Methoden nicht besser abschneiden kann. Das nächste, was ich bekam, war nach dem Vorbild von

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

für einen Nettogewinn von 7 Zeichen.