टेक्स्ट को मुख्य प्रेस में बदलें

मैं एक रोबोट हूँ। मैंने इस कीबोर्ड को इसके आसान आयताकार लेआउट के कारण खरीदा है :

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

मानव पाठ को प्रिंट करने के लिए, मुझे इसे कमांड में बदलने की आवश्यकता है जो मेरे जोड़तोड़ की व्याख्या कर सकते हैं। मेरे बाएँ जोड़तोड़ Shiftकुंजी पर होवर करता है । मेरा सही मैनिप्युलेटर, शुरुआत में, ~कुंजी पर टिका होता है । मेरे जोड़तोड़ को समझने वाले आदेश हैं:

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

किसी भी ASCII संदेश को आदेशों की सूची में बदलने के लिए कोड लिखें। इनपुट में 95 मुद्रण योग्य ASCII वर्णों की संख्या हो सकती है; संभवतः TAB और newline वर्ण भी। आउटपुट जोड़तोड़ करने वालों के लिए कमांड की सूची होनी चाहिए।

इसलिए, उदाहरण के लिए, टाइप करने के लिए, Hello World!कमांड्स हैं

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

मैं प्रत्येक संदेश को प्रिंट करने से पहले जोड़तोड़ को प्रारंभिक स्थिति में रीसेट करता हूं।

कुछ यांत्रिक खतरे हैं जिन्हें उचित प्रोग्रामिंग से बचा जाना चाहिए:

LRUDमुद्रण ( P) लगे होने पर कोई हिलने ( ) की अनुमति नहीं है
मैनिपुलेटर्स का कोई ठेला नहीं: जब एक मैनिपुलेटर लगा हुआ है ( Sया P), इस मैनिपुलेटर के लिए अगला कमांड डिस्गेंजिंग ( sया p), और इसके विपरीत होना चाहिए
कोई अनावश्यक स्थानांतरण नहीं: प्रत्येक दो शिफ्ट ( s, S) कमांड के बीच, एक Pकमांड होनी चाहिए

तो, प्रिंट करने के लिए ~~, कमांड SPpPpमान्य हैं, जबकि SPpsSPpनहीं हैं
सीमा से बाहर नहीं जाना: कोई भी आंदोलन कमांड को सही मैनिपुलेटर को 13 स्थानों से अधिक सही या 4 से प्रारंभिक स्थिति के नीचे (या शीर्ष या बाएं किसी भी स्थान) पर ले जाने का प्रयास नहीं करना चाहिए

अतिरिक्त नोट्स:

किसी भी कुंजी को दबाने में एक अक्षम कुंजी (जैसे अनुक्रम DDPp) को दबाया जाता है और अनुमति दी जाती है।
दबाने Shift+ Tabका कोई प्रभाव नहीं है, लेकिन Shift+ Spaceऔर Shift+ Enterका बिना किसी प्रभाव के समान है Shift।
स्पेस बार और की के किसी भी स्पॉट पर दबाने पर Enterसमान प्रभाव पड़ता है।
आउटपुट में व्हॉट्सएप की चाबियों का कोई अर्थ नहीं है, लेकिन इसका उपयोग इसे सुंदर तरीके से प्रारूपित करने के लिए किया जा सकता है।

code-golf keyboard

— anatolyg
स्रोत

क्या गति एक समस्या है? क्या हम प्रत्येक चरित्र के बीच जोड़तोड़ के लिए अपने घर की स्थिति में लौट सकते हैं (इसलिए जब तक इसमें अनावश्यक स्थानांतरण शामिल नहीं है, निश्चित रूप से)

— इंजीनियर टोस्ट

कोई दिक्कत नहीं है। शायद यह अतिरिक्त आंदोलन के बिना अधिक दिलचस्प हो सकता है, लेकिन मुझे सबसे अच्छा संभव आउटपुट की आवश्यकता नहीं है।

— अनातोलीग

संबंधित एक , संबंधित दो ।

— AdmBorkBork

आपने वास्तव में कार्य को परिभाषित नहीं किया है ... इनपुट किस वर्ण में हो सकते हैं? वास्तविक कार्य क्या है (मैं यह अनुमान लगाने जा रहा हूं कि यह शीर्षक के आधार पर स्पष्ट है, लेकिन फिर भी आपको निर्दिष्ट करना चाहिए)

— HyperNeutrino

क्यों परेशान Pp? जहां तक मैं देख सकता हूँ उन हमेशा एक ही कार्रवाई और न हैं Pया pअपने आप ही दिखाई दे सकता है।

— orlp

जवाबों:

पायथन 2 , 338 337 335 331 325 बाइट्स

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

इसे ऑनलाइन आज़माएं!

प्रत्येक चरित्र से सीधे अगले तक ले जाता है।

स्पष्टीकरण:

S=[c in K,s][c in' \n']जाँच करता है कि क्या अगला वर्ण ऊपरी या निचला होना चाहिए। यदि cकोई स्थान या नई रेखा है, तो मामला समान रहता है।
X=[max(x,12),min(max(x,5),10),p%15]['\n '.find(c)]। यदि cकोई स्थान या नई रेखा है, तो वर्तमान में निकटतम x-निर्देशांक चुना जाता है (जैसा कि कई कॉलमों में कुंजी होती है)
print'sS'[S]*(s!=S)+'LR'[X>x]*abs(X-x)+'UD'[Y>y]*abs(Y-y)+'Pp', केस स्विच को प्रिंट करता है Pp, प्रत्येक वर्ण के लिए, x- समन्वय चालों की संख्या, y- समन्वय चालों की संख्या, और अंत में ।

छोटा संस्करण, यदि सबसे छोटा रास्ता आवश्यक नहीं है:

पायथन 2 , 294 293 291 287 281 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— TFeld
स्रोत

क्या वास्तव में space/ के लिए सबसे कम पथ का उपयोग करना आवश्यक है enter?

— अरनौलद

@Arnauld, मैं अतिथि नहीं हूं, यह निर्दिष्ट नहीं किया गया था लेकिन उदाहरण निकटतम स्थान पर जाता है (बाद में o)

— TFeld

जावास्क्रिप्ट (ईएस 6), 263 बाइट्स

वर्णों के एक सरणी के रूप में इनपुट लेता है।

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)

इसे ऑनलाइन आज़माएं!

— Arnauld
स्रोत

.COM opcode, 108 104 बाइट्स

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

CapsLock से कीबोर्ड से इनपुट लें

हालांकि बुरी तरह से घायल

        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

— l4m2
स्रोत

एक महान विचार एक LUT के बिना ऐसा करने के लिए!

— अनातोलीग

Take input from keyboard हमारा रोबोट मित्र, जो इस कार्यक्रम का उपयोग करने के लिए अपने कीबोर्ड का उपयोग करने के लिए मदद मांग रहा है, कैसा है?

— शॉन एच