Ich bin ein Roboter. Ich habe diese Tastatur wegen ihres einfachen rechteckigen Layouts gekauft:

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

Um menschlichen Text zu drucken, muss ich ihn in Befehle konvertieren, die meine Manipulatoren interpretieren können. Mein linker Manipulator schwebt über dem ShiftSchlüssel. Mein rechter Manipulator schwebt am Anfang über der ~Taste. Die Befehle, die meine Manipulatoren verstehen, sind:

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

Schreiben Sie Code, um eine ASCII-Nachricht in eine Liste von Befehlen zu konvertieren. Die Eingabe kann eine beliebige Anzahl von 95 druckbaren ASCII-Zeichen enthalten. möglicherweise auch TAB- und Zeilenumbruchzeichen. Die Ausgabe sollte die Liste der Befehle an die Manipulatoren sein.

Um beispielsweise zu tippen Hello World!, sind die Befehle

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

Ich habe die Manipulatoren vor dem Drucken jeder Nachricht auf den Ausgangszustand zurückgesetzt.

Es gibt einige mechanische Gefahren, die durch ordnungsgemäße Programmierung vermieden werden sollten:

1. Kein Verschieben ( LRUD) erlaubt, wenn print ( P) aktiviert ist
2. Kein Blockieren von Manipulatoren: Wenn ein Manipulator aktiviert ist ( Soder P), sollte der nächste Befehl für diesen Manipulator das Deaktivieren ( soder p) sein und umgekehrt

3. Keine unnötige Verschiebung: Zwischen jeweils zwei Verschiebungsbefehlen ( s, S) sollte ein PBefehl stehen

   Zum Drucken ~~sind Befehle SPpPpalso gültig, während dies SPpsSPpnicht der Fall ist

4. Kein Verschieben außerhalb der Grenzen: Kein Bewegungsbefehl sollte versuchen, den rechten Manipulator um mehr als 13 Felder nach rechts oder 4 um den unteren Rand der Ausgangsposition (oder einen beliebigen Punkt nach oben oder links) zu bewegen.

Zusätzliche Bemerkungen:

• Das Drücken einer deaktivierten Taste (Befehlssequenz ähnlich DDPp) führt dazu, dass keine Tasten gedrückt werden und zulässig sind.
• Das Drücken von Shift+ Tabhat keine Wirkung, aber Shift+ Spaceund Shift+ Enterhaben den gleichen Effekt wie ohne Shift.
• Das Drücken einer beliebigen Stelle auf der Leertaste und der EnterTaste hat den gleichen Effekt.
• Leerzeichen in der Ausgabe haben keine Bedeutung, können jedoch verwendet werden, um sie auf schöne Weise zu formatieren.

Python 2 , 338 337 335 331 325 Bytes

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

Probieren Sie es online aus!

Bewegt sich direkt von jedem Charakter zum nächsten.

Erläuterung:

• S=[c in K,s][c in' \n'], prüft, ob das nächste Zeichen Groß- oder Kleinbuchstaben sein soll. Wenn ces sich um ein Leerzeichen oder eine neue Zeile handelt, bleibt der Fall derselbe.

• X=[max(x,12),min(max(x,5),10),p%15]['\n '.find(c)]. Wenn ces sich um ein Leerzeichen oder eine neue Zeile handelt, wird die dem aktuellen am nächsten liegende x-Koordinate ausgewählt (da die Tasten mehrere Spalten umfassen).

• print'sS'[S]*(s!=S)+'LR'[X>x]*abs(X-x)+'UD'[Y>y]*abs(Y-y)+'Pp', druckt den Fallschalter, die Anzahl der x-Koordinatenbewegungen, die Anzahl der y-Koordinatenbewegungen und schließlich Ppfür jedes Zeichen

Kürzere Version, wenn der kürzeste Weg nicht benötigt wird:

Python 2 , 294 293 291 287 281 Bytes

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

Probieren Sie es online aus!

JavaScript (ES6), 263 Byte

Nimmt die Eingabe als Array von Zeichen auf.

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)

Probieren Sie es online aus!

.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                        

Nehmen Sie Eingaben von der Tastatur bei ausgeschaltetem CapsLock vor

Schlecht Golf gespielt

        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