कीबोर्ड शिफ्ट सिफर

Question

निम्नलिखित इनपुट को देखते हुए:

• एक पूर्णांक nजहां n > 0।
• एक स्ट्रिंग sजहां sखाली नहीं है और s~=[0-9A-Z]+(केवल अल्फा-न्यूमेरिक राजधानियाँ)।

एक मानक, सरलीकृत QWERTY कीबोर्ड का उपयोग करना (जैसा कि नीचे दिखाया गया है):

1234567890
QWERTYUIOP
ASDFGHJKL
ZXCVBNM

निम्नलिखित ऑपरेशन करें:

• मूल पंक्ति ढूंढें जो प्रत्येक वर्ण कीबोर्ड पर है।
• पत्र nको उसकी मूल स्थिति + n के आधार पर सही स्थानांतरित किए गए समकक्ष के साथ बदलें ।
  • ईजी s="AB"और n=2: Aबन जाएगा Dऔर Bबन जाएगा M।
• यदि keyboard_row[position + n] > keyboard_row.length, शुरू से वापस लपेटो।
  • ईजी s="0P"और n=2: 0बन जाएगा 2और Pबन जाएगा W।

उदाहरण:

f("0PLM",1)    = 1QAZ
f("ZXCVB",2)   = CVBNM
f("HELLO",3)   = LYDDW
f("0PLM",11)   = 1QSV
f("0PLM",2130) = 0PHX

नियम

• यह कोड-गोल्फ , सबसे कम बाइट-काउंट जीत है।

---

यह पहली नज़र में लगता है की तुलना में थोड़ा मुश्किल है।

Comments

क्या हमें स्ट्रिंग के बजाय चरित्र-सरणी के रूप में इनपुट लेने की अनुमति है? वर्तमान में हमने मान लिया, लेकिन पूछना भूल गया ..

— केविन क्रूज़सेन

@KevinCruijssen हिलाना यकीन है, यह भी विदेशी नहीं है। जब तक यह आपको एक बाइट को तोड़ने के लिए एक बाइट को बचाता है मैं शिकायत नहीं कर रहा हूं।

— मैजिक ऑक्टोपस Urn

Answer 1

जेली , 13 बाइट्स

ØQØDṭ,ṙ€¥⁸F€y

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

यह काम किस प्रकार करता है

ØQØDṭ,ṙ€¥⁸F€y  Main link. Left argument: n (integer). Right argument: s (string)

ØQ             Qwerty; set the return value to
               ["QWERTYUIOP", "ASDFGHJKL", "ZXCVBNM"].
  ØD           Digits; yield "0123456789".
    ṭ          Tack, yielding ["QWERTYUIOP", "ASDFGHJKL", "ZXCVBNM", "0123456789"].
        ¥⁸     Call the two links to the left as a dyadic chain, with right
               argument n.
      ṙ€       Rotate each string in the array n units to the left.
     ,         Yield the pair of the unmodified and the rotated string array.
          F€   Flatten each, mapping, e.g., ["QWERTYUIOP", ..., "0123456789"] to
               "QWERTYUIOPASDFGHJKLZXCVBNM0123456789".
            y  Translate s according to the mapping we've built.

Comments

जेली में कीबोर्ड-लेआउट बिल्ट-इन एह है?

— मैजिक ऑक्टोपस Urn

@MagicOctopusUrn नहीं, अभी केवल QWERTY अभी :-P

— आउटगॉल्फ

13 बाइट्स? कौन सा चरित्र सेट माना जाता है? UTF-8 में यह 26 बाइट्स है!

— सेफेलोपॉड

@ साइफलोपॉड जेली जेली कोड पेज का उपयोग करता है ।

— डेनिस

Answer 2

पायथन 2 , 110 बाइट्स

lambda s,n,y='1234567890'*99+'QWERTYUIOP'*99+'ASDFGHJKL'*99+'ZXCVBNM'*99:''.join(y[y.find(c)+n%630]for c in s)

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

यह प्रत्येक पंक्ति के बीच व्यक्तिगत सुधार से बचने के लिए सही प्रतिस्थापन खोजने के लिए पंक्तियों की लंबाई (630) के बीच एक बड़ी पर्याप्त स्ट्रिंग (प्रत्येक पंक्ति की 99 प्रतियां) और एलसीएम का उपयोग करता है।

Answer 3

जावा 8, 159 158 बाइट्स

n->s->{for(int i=s.length,j;i-->0;)for(String x:"1234567890;QWERTYUIOP;ASDFGHJKL;ZXCVBNM".split(";"))if((j=x.indexOf(s[i])+n)>=n)s[i]=x.charAt(j%x.length());}

-1 बाइट के लिए धन्यवाद @ ओलिवियरग्रेजायर सीधे मुद्रण के बजाय इनपुट-सरणी को संशोधित करता है।

स्पष्टीकरण:

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

n->s->{  // Method with integer and character-array parameters, and no return-type
  for(int i=s.length,j;i-->0;)
         //  Loop over the input character-array with index
    for(String x:"1234567890;QWERTYUIOP;ASDFGHJKL;ZXCVBNM".split(";"))
         //   Inner loop over the qwerty-lines
      if((j=x.indexOf(s[i])+n)>=n)
         //    If the current qwerty-line contains the character
         //     Set `j` to the index of this character on that line + input `n`
        s[i]=x.charAt(j%x.length());}
         //     Replace the character at index `i`
         //     with the new character (at index `j` modulo length_of_qwerty_line)

Comments

158-बाइट्स , इनपुट-आउटपुटिंग की लागत पर char[]।

— ओलिवियर ग्रेजायर

Answer 4

रेटिना , 49 बाइट्स

"$&"+T`9o`dQW\ERTYUI\OPQASDFG\HJK\LAZXC\VBNMZ
0A`

इसे ऑनलाइन आज़माएं! इनपुट nऔर sअलग-अलग लाइनों पर ले जाता है । स्पष्टीकरण:

"$&"+

दोहराएँ nबार।

T`9o`dQW\ERTYUI\OPQASDFG\HJK\LAZXC\VBNMZ

सभी पात्रों को दाईं ओर एक कुंजी बदलें।

0A`

हटाएं n।

Answer 5

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

करी सिंटैक्स में इनपुट लेता है (s)(n)। पात्रों के सरणियों के साथ काम करता है।

s=>n=>s.map(c=>(S='1QAZ2WSX3EDC4RFV5TGB6YHN7UJM8IK_9OL_0P')[(p=S.search(c)+n*4)%(-~'9986'[p%4]*4)])

परीक्षण के मामलों

let f =

s=>n=>s.map(c=>(S='1QAZ2WSX3EDC4RFV5TGB6YHN7UJM8IK_9OL_0P')[(p=S.search(c)+n*4)%(-~'9986'[p%4]*4)])

console.log(JSON.stringify(f([..."0PLM"])(1)))    // 1QAZ
console.log(JSON.stringify(f([..."ZXCVB"])(2)))   // CVBNM
console.log(JSON.stringify(f([..."HELLO"])(3)))   // LYDDW
console.log(JSON.stringify(f([..."0PLM"])(11)))   // 1QSV
console.log(JSON.stringify(f([..."0PLM"])(2130))) // 0PHX

कैसे?

हम एक स्ट्रिंग S के भीतर इनपुट के प्रत्येक वर्ण की स्थिति p की तलाश करते हैं जहाँ कीबोर्ड पंक्तियाँ परस्पर जुड़ी होती हैं: पहले 4 वर्ण '1QAZ' (कीबोर्ड का पहला कॉलम), अगले 4 वर्ण '2WSX' (दूसरा कॉलम) हैं कीबोर्ड) और इतने पर। अप्रयुक्त पदों को अंडरस्कोर से गद्देदार किया जाता है और अंतिम वाले को बस छोड़ दिया जाता है।

col # | 0    | 1    | 2    | 3    | 4    | 5    | 6    | 7    | 8    | 9
------+------+------+------+------+------+------+------+------+------+---
row # | 0123 | 0123 | 0123 | 0123 | 0123 | 0123 | 0123 | 0123 | 0123 | 01
------+------+------+------+------+------+------+------+------+------+---
char. | 1QAZ | 2WSX | 3EDC | 4RFV | 5TGB | 6YHN | 7UJM | 8IK_ | 9OL_ | 0P

यह हमें आसानी से पी मोड 4 के साथ पंक्ति को पहचानने की अनुमति देता है और पंक्तियों के बीच स्पष्ट विभाजक की आवश्यकता को समाप्त करता है।

हम 4n पदों से आगे बढ़ते हैं , इस पंक्ति (क्रमशः 40, 40, 36 और 28) के लिए सही मोडुलो लागू करते हैं और एस में इस नए स्थान पर पाए गए प्रतिस्थापन चरित्र को चुनते हैं ।

Answer 6

जेली , 18 बाइट्स

ØQØDṭẋ€‘}Ẏ©iЀ⁸+ị®

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

Answer 7

सी,  152  149 बाइट्स

तीन बाइट्स बचाने के लिए @gastropner का धन्यवाद!

j,l;f(S,n){for(char*s=S,*k;*s;++s)for(k="1234567890\0QWERTYUIOP\0ASDFGHJKL\0ZXCVBNM\0";l=strlen(k);k+=l+1)for(j=l;j--;)k[j]-*s||putchar(k[(j+n)%l]);}

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

unrolled:

j,l;
f(S,n)
{
    for (char*s=S, *k; *s; ++s)
        for (k="1234567890\0QWERTYUIOP\0ASDFGHJKL\0ZXCVBNM\0"; l=strlen(k); k+=l+1)
            for (j=l; j--;)
                k[j]-*s || putchar(k[(j+n)%l]);
}

Comments

या तो मैं मतिभ्रम कर रहा हूं, या आंतरिक लूप को बदला जा सकता है, for(j=l;j--;)लेकिन मुझे नहीं पता कि किसी अन्य के बिना क्यों बदला गया। फिर भी, आपको 149 पर मिलना चाहिए।

— गैस्ट्रोपनर

@gastropner आह, हाँ, खोज क्रम कोई फर्क नहीं पड़ता, इसलिए यह काम करता है। धन्यवाद!

— स्टेडीबॉक्स

Answer 8

लाल , 152 बाइट्स

f: func[s n][foreach c s[foreach[t l]["1234567890"10"QWERTYUIOP"10"ASDFGHJKL"9"ZXCVBNM"7][if p: find t c[if(i:(index? p)+ n // l)= 0[i: l]prin t/(i)]]]]

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

Ungolfed:

f: func [s n][1
    foreach c s [
        foreach [t l] ["1234567890"10"QWERTYUIOP"10"ASDFGHJKL"9"ZXCVBNM"7][
            p: find t c
            if p [ 
                i: (index? p) + n // l
                if i = 0 [i: l]
                prin t/(i) ]]]]

Answer 9

हास्केल , 99 बाइट्स

f(s,n)=[dropWhile(/=c)(cycle r)!!n|c<-s,r<-words"1234567890 QWERTYUIOP ASDFGHJKL ZXCVBNM",elem c r]

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

Comments

आप इसका उपयोग कर सकते हैं जिसके s#n= ...बजाय f(s,n)= ...केवल उदाहरण के लिए उपयोग किया जाने वाला एक उदाहरण संकेतन है।

— लैकोनी

Answer 10

पर्ल 5 , 94 + 1 ( -p) = 95 बाइट्स

$s=<>;for$i(1234567890,QWERTYUIOP,ASDFGHJKL,ZXCVBNM){eval"y/$i/".(substr$i,$s%length$i)."$i/"}

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

Comments

धिक्कार है, मैंने आपका उत्तर नहीं देखा। वे मूल रूप से एक ही हैं, मेरी आशाओं का उपयोग करने के लिए स्वतंत्र महसूस करते हैं और मैं अपना उत्तर हटा दूंगा। मुझे बताएं, यदि नहीं, तो मैं इस टिप्पणी को हटा दूंगा :)

— डोम हेस्टिंग्स

@DomHastings वे काफी अलग हैं। कृपया दोनों रखें। मुझे दृष्टिकोण में बदलाव देखना पसंद है। मैं उन सभी से सीखता हूं ...

— टन इंजील

Answer 11

जाप, 20 बाइट्स

इतने अधिक गोल्फ और खाने के लिए एक स्पष्टीकरण का पालन करने के लिए दरवाजा बाहर चल रहा है।

;£=D·i9òs)æøX)gV+UbX

कोशिश करो

Answer 12

पर्ल, 59 58 57 56 बाइट्स

के लिए शामिल +है-p

एसटीडीआईएन पर 2 लाइनों के रूप में इनपुट दें, पहले स्ट्रिंग, फिर दोहराएं

(echo 0PLM; echo 2130) | perl -pe '$a="OPQWERTYUILASDF-MZXCVBNM0-90";eval"y/HI$a/J$a/;"x<>'

Comments

वाह, मैं विश्वास नहीं कर सकता तुम 29 बाइट्स बंद मेरा! मैं मूल रूप से इससे बहुत खुश था ...

— डोम हेस्टिंग्स

Answer 13

पर्ल 5 , 85 बाइट्स

के लिए 84 बाइट्स कोड + 1 -p।

eval join"",map"y/$_/@{[/./&&$'.$&]}/;",(1234567890,QWERTYUIOP,ASDFGHJKL,ZXCVBNM)x<>

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

Answer 14

क्लीन , 144 119 बाइट्स

import StdEnv

\n s=[l.[(i+n)rem(size l)]\\c<-s,l<-["1234567890","QWERTYUIOP","ASDFGHJKL","ZXCVBNM"],i<-[0..]&j<-:l|j==c]

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

हस्ताक्षर के साथ लैम्ब्डा फ़ंक्शन Int ![Char] -> [Char]

Answer 15

रूबी , 101 बाइट्स

->s,n{n.times{s.tr! '1234567890QWERTYUIOPASDFGHJKLZXCVBNM','2345678901WERTYUIOPQSDFGHJKLAXCVBNMZ'};s}

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

मैं ईमानदारी से थोड़ा निराश हूं कि मैं 'चतुर' तरीकों से बेहतर नहीं कर सका। मुझे जो सबसे पास मिला, उसकी तर्ज पर था

a=%w{1234567890 QWERTYUIOP ASDFGHJKL ZXCVBNM}
b=a.map{|r|r[1..-1]<<r[0]}*''
a*=''
n.times{s.tr! a,b}

7 वर्णों के शुद्ध लाभ के लिए।