Je suis un robot. J'ai acheté ce clavier en raison de sa disposition rectangulaire facile:

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

Pour imprimer du texte humain, je dois le convertir en commandes que mes manipulateurs peuvent interpréter. Mon manipulateur gauche plane sur la Shiftclé. Mon manipulateur droit, au début, plane sur la ~clé. Les commandes que mes manipulateurs comprennent sont:

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

Écrivez du code pour convertir tout message ASCII en une liste de commandes. L'entrée peut contenir n'importe quel nombre des 95 caractères ASCII imprimables; éventuellement aussi TAB et caractères de nouvelle ligne. La sortie doit être la liste des commandes aux manipulateurs.

Ainsi, par exemple, pour taper Hello World!, les commandes sont

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

Je remets les manipulateurs à leur état initial avant d'imprimer chaque message.

Il existe certains risques mécaniques qui devraient être évités par une programmation appropriée:

1. Aucun déplacement ( LRUD) autorisé lorsque l'impression ( P) est engagée
2. Pas de brouillage des manipulateurs: lorsqu'un manipulateur est engagé ( Sou P), la commande suivante pour ce manipulateur doit être de se désengager ( sou p), et vice-versa

3. Pas de décalage inutile: entre chaque commande shift ( s, S), il doit y avoir une Pcommande

   Donc, pour imprimer ~~, les commandes SPpPpsont valides, alors SPpsSPpqu'elles ne le sont pas

4. Pas de déplacement hors des limites: aucune commande de mouvement ne doit essayer de déplacer le manipulateur droit de plus de 13 espaces vers la droite ou 4 vers le bas de la position initiale (ou n'importe quel endroit en haut ou à gauche)

Notes complémentaires:

• Appuyer sur une touche désactivée (comme une séquence de commandes DDPp) n'entraîne aucune pression et est autorisé.
• Appuyer sur Shift+ Tabn'a aucun effet, mais Shift+ Spaceet Shift+ Enteront le même effet que sans Shift.
• En appuyant sur n'importe quel endroit de la barre d'espace et la Entertouche a le même effet.
• Les clés d'espaces en sortie n'ont aucune signification, mais peuvent être utilisées pour les formater d'une manière magnifique.

Python 2 , 338 337 335 331 325 octets

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

Essayez-le en ligne!

Se déplace directement de chaque personnage au suivant.

Explication:

• S=[c in K,s][c in' \n'], vérifie si le caractère suivant doit être en majuscule ou en minuscule. S'il cs'agit d'un espace ou d'une nouvelle ligne, le cas reste le même.

• X=[max(x,12),min(max(x,5),10),p%15]['\n '.find(c)]. Si cest un espace ou une nouvelle ligne, la coordonnée x la plus proche du courant est choisie (car les clés s'étendent sur plusieurs colonnes)

• print'sS'[S]*(s!=S)+'LR'[X>x]*abs(X-x)+'UD'[Y>y]*abs(Y-y)+'Pp', imprime le commutateur de casse, le nombre de mouvements de coordonnées x, le nombre de mouvements de coordonnées y et enfin Pp, pour chaque caractère

Version plus courte, si le chemin le plus court n'est pas requis:

Python 2 , 294 293 291 287 281 octets

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

Essayez-le en ligne!

JavaScript (ES6), 263 octets

Prend l'entrée comme un tableau de caractères.

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)

Essayez-le en ligne!

.COM opcode, 108 104 bytes

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                        

Prendre l'entrée du clavier avec CapsLock désactivé

Mal golfé cependant

        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