Saya sebuah robot. Saya membeli keyboard ini karena tata letaknya yang mudah:

~`   !1   @2   #3   $4   %5   ^6   &7   *8   (9   )0   _-   +=
tab  Qq   Ww   Ee   Rr   Tt   Yy   Uu   Ii   Oo   Pp   {[   }]    \|
     Aa   Ss   Dd   Ff   Gg   Hh   Jj   Kk   Ll   :;   "'   [-enter-]
          Zz   Xx   Cc   Vv   Bb   Nn   Mm   <,   >.   ?/
                         [========= space =========]

Untuk mencetak teks manusia, saya perlu mengubahnya menjadi perintah yang dapat ditafsirkan oleh manipulator saya. Manipulator kiri saya melayang di atas Shiftkunci. Manipulator kanan saya, pada awalnya, melayang di atas ~kunci. Perintah yang dipahami manipulator saya adalah:

S      : press the shift key
s      : release the shift key
L      : move the right manipulator left by 1
R      : move the right manipulator right by 1
U      : move the right manipulator up by 1
D      : move the right manipulator down by 1
P      : press the key under the right manipulator
p      : release the key by the right manipulator

Tulis kode untuk mengonversi pesan ASCII menjadi daftar perintah. Input dapat berisi sejumlah 95 karakter ASCII yang dapat dicetak; mungkin juga TAB dan karakter baris baru. Keluaran harus berupa daftar perintah kepada manipulator.

Jadi, misalnya, untuk mengetik Hello World!, perintahnya adalah

SRRRRRRDDPp
sLLLUPp
RRRRRRDPp
Pp
UPp
LLLLDDDPp
SLLLUUUPp
sRRRRRRRPp
LLLLLPp
RRRRRDPp
LLLLLLPp
SLLUUPp

Saya mengatur ulang manipulator ke kondisi awal sebelum mencetak setiap pesan.

Ada beberapa bahaya mekanis yang harus dihindari dengan pemrograman yang tepat:

1. Tidak ada pemindahan ( LRUD) yang diizinkan saat pencetakan ( P) digunakan
2. Tidak ada gangguan manipulator: ketika manipulator terlibat ( Satau P), perintah berikutnya untuk manipulator ini harus melepaskan ( satau p), dan sebaliknya

3. Tidak ada pemindahan yang tidak perlu: antara masing-masing dua perintah shift ( s, S), harus ada Pperintah

   Jadi, untuk mencetak ~~, perintah SPpPpitu valid, sementara SPpsSPptidak

4. Tidak bergerak keluar dari batas: tidak ada perintah gerakan yang harus mencoba untuk memindahkan manipulator kanan lebih dari 13 spasi ke kanan atau 4 ke bawah dari posisi awal (atau tempat ke atas atau ke kiri)

Catatan tambahan:

• Menekan tombol yang dinonaktifkan (seperti urutan perintah DDPp) menghasilkan tidak ada tombol yang ditekan dan diizinkan.
• Menekan Shift+ Tabtidak memiliki efek, tetapi Shift+ Spacedan Shift+ Entermemiliki efek yang sama dengan tanpa Shift.
• Menekan sembarang tempat pada bilah spasi dan Entertombol memiliki efek yang sama.
• Kunci spasi putih dalam output tidak memiliki arti, tetapi dapat digunakan untuk memformatnya dengan cara yang indah.

Python 2 , 338 337 335 331 325 byte

x=y=s=0
for c in input():p='`1234567890-=`	qwertyuiop[]|`asdfghjkl;\'\n```zxcvbnm,./``````` ~!@#$%^&*()_+~~QWERTYUIOP{}\\~ASDFGHJKL:"\n~~~ZXCVBNM<>?~~~~~~~ '.find(c);S=[p>61,s][c in' \n'];p%=62;Y=p/14;X=[max(x,12),min(max(x,5),10),p%14]['\n '.find(c)];print'sS'[S]*(s^S)+'LR'[X>x]*abs(X-x)+'UD'[Y>y]*abs(Y-y)+'Pp';x,y,s=X,Y,S

Cobalah online!

Bergerak langsung dari setiap karakter ke yang berikutnya.

Penjelasan:

• S=[c in K,s][c in' \n'], periksa apakah karakter berikutnya harus huruf besar atau kecil. Jika cspasi atau baris baru, kasingnya tetap sama.

• X=[max(x,12),min(max(x,5),10),p%15]['\n '.find(c)]. Jika cspasi atau baris baru, koordinat x terdekat dengan arus dipilih (karena tombol span beberapa kolom)

• print'sS'[S]*(s!=S)+'LR'[X>x]*abs(X-x)+'UD'[Y>y]*abs(Y-y)+'Pp', mencetak sakelar kasus, jumlah gerakan koordinat x, jumlah gerakan koordinat y, dan akhirnya Pp, untuk setiap karakter

Versi lebih pendek, jika jalur terpendek tidak diperlukan:

Python 2 , 294 293 291 287 281 byte

x=y=s=0
for c in input():p='`1234567890-=`	qwertyuiop[]|`asdfghjkl;\'\n```zxcvbnm,./``````` ~!@#$%^&*()_+~~QWERTYUIOP{}\\~ASDFGHJKL:"\n~~~ZXCVBNM<>?~~~~~~~ '.find(c);S=[p>61,s][c in' \n'];p%=62;X,Y=p%14,p/14;print'sS'[S]*(s^S)+'LR'[X>x]*abs(X-x)+'UD'[Y>y]*abs(Y-y)+'Pp';x,y,s=X,Y,S

Cobalah online!

JavaScript (ES6), 263 byte

Mengambil input sebagai array karakter.

s=>s.map(c=>(y=i-(i=(j=`\`~1!2@3#4$5%6^7&8*9(0)-_=+00\t0qQwWeErRtTyYuUiIoOpP[{]}|\\00aAsSdDfFgGhHjJkKlL;:'"
${1e6}zZxXcCvVbBnNmM,<.>/?${1e13} `.indexOf(c))>>1),g=k=>'LRUD'[n=k?y/14:y%14,k^=n<0].repeat(n<0?-n:n))()+g(2)+['sS'[j-s&c!=' '&c!=`
`?s^=1:2]]+'Pp',i=s=0)

Cobalah online!

.COM opcode, 108 104 byte

0000h: B4 00 CD 16 BE 50 01 83 C6 03 3A 24 77 F9 0F B6
0010h: DC 03 5C 01 B4 02 CD 16 B4 02 68 00 01 A8 03 B2
0020h: 53 74 08 81 36 20 01 20 01 CD 21 84 DB 74 0B 4B
0030h: B2 52 E8 F4 FF B2 4C CD 21 C3 84 FF 74 0C FE CF
0040h: B2 44 E8 E4 FF B2 55 CD 21 C3 B2 50 CD 21 B2 70
0050h: CD 21 C3 0D FE 00 1B F1 00 1C F0 01 28 E3 01 29
0060h: D7 FF 35 D6 02 39 CC 03                        

Ambil input dari keyboard dengan CapsLock mati

Golfnya jelek

        org 100h
        mov ah, 0
        int 16H
        mov si, table-3
tabing: add si, 3
        cmp ah, [si]
        ja tabing
        movzx bx, ah
        add bx, [si+1]
        mov ah, 2
        int 16H
        mov ah, 2
        push 100H
        test al, 3
        mov dl, 'S'
cmd:    jz fun
        xor [cmd-1], word 0x120
        int 21H
fun:    test bl, bl
        jz bl0
        dec bx
        mov dl, 'R'
        int 21H
        call fun
        mov dl, 'L'
        int 21H
        ret
bl0:    test bh, bh
        jz bh0
        dec bh
        mov dl, 'D'
        int 21H
        call fun
        mov dl, 'U'
        int 21H
        ret
bh0:    mov dl, 'P'
        int 21H
        mov dl, 'p'
        int 21H
        ret
macro key begin, end, U, L {
        db end
        dw U*256+L-begin
}
table:
        key 0x02, 0x0D, 1, 0
        key 0x10, 0x1B, 1, 1
        key 0x1C, 0x1C, 2, 12
        key 0x1E, 0x28, 2, 1
        key 0x29, 0x29, 0, 0
        key 0x2C, 0x35, 3, 2
        key 0x39, 0x39, 4, 5