Cho đầu vào sau:

• Một số nguyên nở đâu n > 0.
• Một chuỗi snơi skhông phải là trống rỗng và s~=[0-9A-Z]+(chỉ thủ đô alpha-numeric).

Sử dụng bàn phím QWERTY tiêu chuẩn, đơn giản hóa (như hiển thị bên dưới):

1234567890
QWERTYUIOP
ASDFGHJKL
ZXCVBNM

Thực hiện các thao tác sau:

• Tìm hàng gốc mà mỗi ký tự nằm trên bàn phím.
• Thay thế chữ cái bằng cách dịch chuyển tương đương chính xác ndựa trên vị trí ban đầu của nó + n.
  • EG s="AB"và n=2: Asẽ trở thành Dvà Bsẽ trở thành M.
• Nếu keyboard_row[position + n] > keyboard_row.length, bọc lại để bắt đầu.
  • EG s="0P"và n=2: 0sẽ trở thành 2và Psẽ trở thành W.

Ví dụ:

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

Quy tắc

• Đây là môn đánh gôn , đánh số byte thấp nhất.

Điều này hơi khó khăn hơn so với cái nhìn đầu tiên.

Thạch , 13 byte

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

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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

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

Hãy thử trực tuyến!

Điều này sử dụng một chuỗi đủ lớn (99 bản sao của mỗi hàng) và LCM giữa các độ dài hàng (630) để tìm sự thay thế chính xác tránh sự điều chỉnh riêng lẻ giữa mỗi hàng.

Java 8, 159 158 byte

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 nhờ @ OlivierGrégoire sửa đổi mảng đầu vào thay vì in trực tiếp.

Giải trình:

Hãy thử trực tuyến.

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)

Võng mạc , 49 byte

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

Hãy thử trực tuyến! Đưa đầu vào nvà strên các dòng riêng biệt. Giải trình:

"$&"+

Lặp lại nnhiều lần.

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

Di chuyển tất cả các ký tự một phím sang phải.

0A`

Xóa n.

JavaScript (ES6), 101 99 byte

Đưa đầu vào theo cú pháp currying (s)(n). Hoạt động với các mảng ký tự.

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

Các trường hợp thử nghiệm

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

Làm sao?

Chúng tôi tìm vị trí p của từng ký tự đầu vào trong một chuỗi S trong đó các hàng bàn phím được xen kẽ: 4 ký tự đầu tiên là '1QAZ' (cột đầu tiên của bàn phím), 4 ký tự tiếp theo là '2WSX' (cột thứ hai của bàn phím) và như vậy. Các vị trí không sử dụng được đệm bằng dấu gạch dưới và những vị trí cuối cùng chỉ đơn giản là bị loại bỏ.

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

Điều này cho phép chúng tôi dễ dàng xác định hàng với p mod 4 và loại bỏ sự cần thiết phải phân tách rõ ràng giữa các hàng.

Chúng tôi thúc đẩy bởi 4n vị trí, áp dụng các modulo chính xác cho hàng này (40, 40, 36 và 28 tương ứng) và chọn nhân vật thay thế tìm thấy tại vị trí mới này trong S .

Thạch , 18 byte

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

Hãy thử trực tuyến!

C,  152  149 byte

Cảm ơn @gastropner vì đã tiết kiệm ba byte!

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

Hãy thử trực tuyến!

Chưa được kiểm soát:

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

Màu đỏ , 152 byte

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

Hãy thử trực tuyến!

Ung dung:

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 byte

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

Hãy thử trực tuyến!

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

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

Hãy thử trực tuyến!

Japt, 20 byte

Chạy ra khỏi cửa để ăn tối để chơi golf nhiều hơn và một lời giải thích để làm theo.

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

Thử nó

Perl, 59 58 57 56 byte

Bao gồm +cho-p

Cho đầu vào trên STDIN là 2 dòng, đầu tiên là chuỗi, sau đó lặp lại

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

Perl 5 , 85 byte

Mã 84 byte + 1 cho -p.

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

Hãy thử trực tuyến!

Sạch , 144 119 byte

import StdEnv

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

Hãy thử trực tuyến!

Hàm Lambda có chữ ký Int ![Char] -> [Char]

Ruby , 101 byte

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

Hãy thử trực tuyến!

Tôi thực sự hơi thất vọng vì tôi không thể làm tốt hơn với các phương pháp 'thông minh hơn'. Gần nhất tôi nhận được là dọc theo dòng

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

cho mức tăng ròng 7 ký tự.