Jestem robotem. Kupiłem tę klawiaturę ze względu na jej łatwy prostokątny układ:

~`   !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 =========]

Aby wydrukować ludzki tekst, muszę przekonwertować go na polecenia, które moi interpretatorzy mogą interpretować. Mój lewy manipulator unosi się nad Shiftklawiszem. Mój prawy manipulator na początku unosi się nad ~klawiszem. Polecenia, które rozumieją moi manipulatorzy, to:

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

Napisz kod, aby przekonwertować dowolny komunikat ASCII na listę poleceń. Dane wejściowe mogą zawierać dowolną liczbę 95 drukowanych znaków ASCII; ewentualnie także TAB i znaki nowej linii. Wyjściem powinna być lista poleceń manipulatorów.

Na przykład, aby wpisać Hello World!, polecenia są

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

Przed wydrukowaniem każdej wiadomości resetuję manipulatory do stanu początkowego.

Właściwe programowanie wymaga pewnych mechanicznych zagrożeń:

1. Przenoszenie ( LRUD) nie jest dozwolone, gdy Pwłączone jest drukowanie ( )
2. Bez blokowania manipulatorów: gdy manipulator jest włączony ( Slub P), następną komendą dla tego manipulatora powinno być wyłączenie ( slub p) i odwrotnie

3. Bez niepotrzebnego przesuwania: między dwoma poleceniami shift ( s, S) powinna znajdować się Pkomenda

   Tak więc, aby wydrukować ~~, polecenia SPpPpsą prawidłowe, a SPpsSPpnie są

4. Bez wychodzenia poza granice: żadna komenda ruchu nie powinna próbować przesunąć prawego manipulatora o więcej niż 13 pól w prawo lub 4 na dół do początkowej pozycji (lub dowolnego miejsca na górze lub na lewo)

Dodatkowe uwagi:

• Naciśnięcie wyłączonego klawisza (podobnie jak sekwencja poleceń DDPp) powoduje, że nie ma naciśnięcia żadnego klawisza i jest dozwolone.
• Naciśnięcie Shift+ Tabnie daje żadnego efektu, ale Shift+ Spacei Shift+ Entermają taki sam efekt jak bez Shift.
• Naciśnięcie w dowolnym miejscu spacji i Enterklawisza ma ten sam efekt.
• Klucze białych znaków w danych wyjściowych nie mają znaczenia, ale można ich użyć do pięknego sformatowania.

Python 2 , 338 337 335 331 325 bajtów

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

Wypróbuj online!

Przechodzi bezpośrednio od każdej postaci do następnej.

Wyjaśnienie:

• S=[c in K,s][c in' \n'], sprawdza, czy następny znak powinien być wielką lub małą literą. Jeśli cjest spacją lub znakiem nowej linii, wielkość liter pozostaje taka sama.

• X=[max(x,12),min(max(x,5),10),p%15]['\n '.find(c)]. Jeśli cjest spacją lub znakiem nowej linii, wybierana jest najbliższa współrzędna x prądu (ponieważ klucze obejmują wiele kolumn)

• print'sS'[S]*(s!=S)+'LR'[X>x]*abs(X-x)+'UD'[Y>y]*abs(Y-y)+'Pp', wypisuje przełącznik wielkości liter, liczbę ruchów współrzędnych X, liczbę ruchów współrzędnych Y i na koniec Ppdla każdego znaku

Krótsza wersja, jeśli najkrótsza ścieżka nie jest wymagana:

Python 2 , 294 293 291 287 281 bajtów

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

Wypróbuj online!

JavaScript (ES6), 263 bajty

Pobiera dane wejściowe jako tablicę znaków.

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)

Wypróbuj online!

.COM opcode, 108 104 bajtów

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                        

Pobieraj dane z klawiatury przy wyłączonym CapsLock

Jednak źle grał w golfa

        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