कीपैड के विषय पर


15

टॉकिंग रखें और कोई भी धमाका एक स्थानीय मल्टीप्लेयर गेम नहीं है जहां एक खिलाड़ी का एक आभासी "बम" पर नियंत्रण होता है, और उसे एक अन्य खिलाड़ी, "विशेषज्ञ" द्वारा निर्देशित किया जाता है, जिसके पास बम डिफ्यूज़ मैनुअल होता है। खेल में निर्वस्त्र किए जाने वाले मॉड्यूलों में से एक कीपैड मॉड्यूल है, जिसे हम इस चुनौती से निपटेंगे।

काम

इनपुट स्थान के अलावा मुद्रण योग्य ASCII वर्णों की एक पंक्ति (0x21 से 0x7E) के साथ शुरू होगा। ये आपको दिखाई देने वाले कीपैड बटन का प्रतिनिधित्व करते हैं।

अगली कुछ पंक्तियाँ "कुंजियाँ" का प्रतिनिधित्व करेंगी - केवल एक पंक्ति में पहली पंक्ति के सभी अक्षर होंगे, जो जरूरी नहीं कि क्रम में हों। आपका कार्य कीपैड के वर्णों का उत्पादन करना है, मिलान कुंजी लाइन के क्रम में।

उदाहरण के लिए, यदि इनपुट था

5~Fy
HrD7K!#}
Ui%^fHnF
)Tf;y~I5
~Fi(&5gy
,'Xd#5fZ

तो कीपैड बटन होते हैं 5, ~, Fऔर y। केवल 4 वीं कुंजी पंक्ति ~Fi(&5gyमें ये सभी वर्ण हैं, इसलिए हम कीपैड वर्णों को उस क्रम में आउटपुट करते हैं जिसमें वे दिखाई देते हैं, अर्थात ~F5y

नियम और स्पष्टीकरण

  • इनपुट में एक ही मल्टीलाइन स्ट्रिंग होना चाहिए, जिसमें कीपैड बटन और अलग-अलग लाइनों पर की-लाइन हो।
  • वास्तव में एक कुंजी पंक्ति होगी जिसमें सभी कीपैड वर्ण शामिल होंगे।
  • हर लाइन, यानी प्रारंभिक कीपैड लाइन और निम्नलिखित प्रमुख लाइनें, कोई डुप्लिकेट वर्ण नहीं होगा।
  • खेल के विपरीत, आप कीपैड वर्णों की संख्या, प्रत्येक कुंजी लाइन की लंबाई या कुंजी लाइनों की संख्या के बारे में कुछ भी नहीं मान सकते हैं। हालांकि, सभी प्रमुख लाइनों को समान लंबाई की गारंटी दी जाती है।
  • आउटपुट में एक एकल वैकल्पिक अनुगामी न्यूलाइन हो सकती है। इसी तरह आप इनपुट में एक वैकल्पिक अनुगामी न्यूलाइन के बारे में भी अनुमान लगा सकते हैं, लेकिन यदि आपको इसकी आवश्यकता है तो कृपया अपने उत्तर में निर्दिष्ट करें।
  • हालांकि यह पहले से ही सामान्य अभ्यास प्रतीत होता है , मैं स्पष्ट रूप से बताऊंगा: इस चुनौती के लिए एक त्रुटि के साथ समाप्त करना ठीक है, जब तक कि STDOUT आउटपुट सही है (यदि यह आपके आउटपुट का चुना हुआ रूप है)। उम्मीद है कि इससे हैंडलिंग इनपुट आसान हो जाएगा।

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

7
4?j01C3"ch
KP.OG>QB)[
z#)Kn"I2&.
]#,D|sBFy5
Qzj*+~7DLP

आउटपुट: 7। केवल अंतिम पंक्ति में a है 7

0b~
Ob+hy{M|?;>=dtszPAR5
*8rCfsw|3O9.7Yv^x>Hq
$ip.V@n}|La:TbIt^AOF
jZ[Ec4s0|%b*$id',~J6
z*#b}-x$Ua&!O2;['T+?
NVj_X8rlhxfnS\.z}];c
bykscf.w^dnWj+}-*2g_
VP`AJH|&j5Yqmw/"9IMc

आउटपुट : 0b~। 4 वीं कुंजी लाइन में पहले से ही सही क्रम में वर्ण हैं।

MTuz
bIAr>1ZUK`s9c[tyO]~W
oMGIi/H&V"BeNLua%El=
j*uYbplT:~);BM|_mPZt
Q}z5TC@=6pgr<[&uJnM%
YOA(F~_nH6T{%B7[\u#5
y&t"8zQn{wo5[Idu4g:?
[0tZG"-fm!]/|nqk,_2h
dA&C.+(byo6{7,?I}D@w

आउटपुट : zTuM। कुंजी लाइन 4 वीं है, हालांकि तीसरी कुंजी लाइन एक करीब से याद आती है।

o@nj<G1
f]?-<I6h2vS*%l=:}c8>LK5rMdyeon,;sE[@m(73
ibhp+2Hq6yKzIf_Zo}EO3-[*0/e&Fvd]wQU=|%`C
;}>d'cg~CPtQG&%L\)MUl419bkTZ7@]:[*H"RyYj
L^<:zXJ#kj$EFlwN%B`Dd,Cs?]xRZ*K9-uQ.@&f+
i1v'7:90R-l}FMxj`,DTWK+(n32Z4Vs[p@%*eS!d
B|^Ti/ZG$}ufL9*wE[AVt]P7CrX-)2JpD<sYxd6O
ex.$4#KarS^j+'_!B"]H[\83:(DCXUgI*Lct?qAR
^GXQoy*KW&v}n']Em~\N9)fxP(qC=7#4sRdcD6%5
;inr[&$1j_!F~@pzo#blv]}<'|fRds6OW%tEg"G2
e;0T#gfo^+!:xHDN&4V=In?AwhEv$2Fd~ZLz_\81

आउटपुट : n1j@o<G। कुंजी लाइन दूसरी अंतिम पंक्ति है।

स्कोरिंग

यह , इसलिए सबसे कम बाइट्स में कोड जीतता है।


क्या केवल स्वीकार्य आउटपुट पद्धति के बारे में है, या एक फ़ंक्शन रिटर्न मान भी अनुमति है?
जर्बर्ग

@ जर्ब फंक्शन इनपुट और आउटपुट दोनों ठीक हैं
Sp3000

sigh मेरे पास एक समाधान है जो एक परीक्षण मामले के लिए काम करता है ... दूसरे परीक्षण मामलों में बहुत से बच गए अक्षर। ओह अच्छा।
काइल कानोस

जवाबों:



8

अजगर, १०

@zhf!-zT.z

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

व्याख्या

@zhf!-zT.z         ##  z = first line of input, .z = list of rest of lines
   f    .z         ##  Filter .z as T based on
    !-zT           ##  Whether removing all the letters from z that appear in T leaves an
                   ##  Empty string or not (keep the ones that give empty strings)
  h                ##  Take the first such line (necessary indexing, shouldn't ever matter)
@z                 ##  @ is setwise intersection. Pyth implements this by iterating over
                   ##  each element of the second argument and keeping values that appear
                   ##  in the first argument, which gives the intended result

7

अजगर, 9 बाइट्स

eolN@Lz.z

प्रदर्शन

@Lz.z: पहली पंक्ति के साथ चौराहे के लिए सभी लाइनों को फ़िल्टर करें।

olN: लंबाई द्वारा आदेश

e: सबसे लंबे समय तक ले लो।


3

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

g(!)(a:b)=[c|d<-b,all(!d)a,c<-d,c!a]
g elem.lines

पहली पंक्ति एक सहायक कार्य को परिभाषित करती है g , दूसरी पंक्ति पर अनाम फ़ंक्शन मेरा उत्तर है।

व्याख्या

एल्गोरिथ्म स्पष्ट एक है: लाइनों में विभाजित इनपुट, उस रेखा को ढूंढें जिसमें पहली पंक्ति के सभी वर्ण हैं, और उस पंक्ति के अन्य सभी वर्णों को फ़िल्टर करें।

g(!)(a:b)=                            -- g gets a binary function ! and list of strings a:b
          [c|                         -- and returns the string of characters c where
             d<-b,all(!d)a,           -- d is drawn from b and x!d holds for all x in a,
                           c<-d,c!a]  -- and c is drawn from d and c!a holds.
g elem.lines                          -- The input is split into lines and fed to g elem;
                                      -- then x!d means x `elem` d in the above.

3

प्रोलॉग, 204 190 बाइट्स

यह प्रोलॉग के लिए एक अच्छी चुनौती हो सकती है अगर यह मल्टीलाइन इनपुट और अनसैप्ड कैरेक्टर्स और "इनपुट" की संयुक्त आवश्यकताओं के लिए नहीं था। कोड की एक बड़ी संख्या (पी और आर) में एक फाइल को चरित्र के रूप में पढ़ने के लिए मौजूद है। कोड जो कि मुझे कई लाइनों पर अनएक्सपेक्टेड इनपुट लेने के लिए करना था।

यदि केवल 'एक अनकैप्ड कैरेक्टर के रूप में अस्तित्व में है, तो मैं इनपुट को एक स्ट्रिंग के रूप में पढ़ सकता हूं।
यदि केवल "एक अनकैप्ड कैरेक्टर के रूप में मौजूद है, तो मैं एक परमाणु की तरह पढ़ सकता हूं।
यदि इनपुट मल्टीलाइन नहीं था, तो इसके स्थान पर अलग-अलग कहें, मैं इसे कोड के लिए एक पंक्ति के रूप में पढ़ सकता था।

r(I,[H|T]):-read_line_to_codes(I,H),H\=end_of_file,r(I,T).
r(_,[]).
q(_,[]).
q(E,[H|T]):-subset(E,H),intersection(H,E,X),writef("%s",[X]);q(E,T).
p:-open("t",read,I),r(I,[H|T]),q(H,T),!.

यह कैसे कार्य करता है

  1. पढ़ने के लिए फ़ाइल t (जिसमें सभी इनपुट शामिल हैं) खोलता है
  2. सूची की सूची में चरित्र कोड और स्थान के रूप में सभी पंक्तियों को पढ़ें (प्रति पंक्ति 1 सूची)
  3. पूंछ सूची और जाँच करता है कि अगर सिर सूची उस सूची के सबसेट के रूप में मौजूद है
  4. सही क्रम में वांछित पात्रों को प्राप्त करने के लिए सर के साथ सूची का मिलान किया गया
  5. प्रिंट समाधान

कैसे चलाएं
प्रोग्राम कमांड के साथ चलाया जाता है:
पी।
फ़ाइल नामांकित टी युक्त इनपुट को उसी निर्देशिका में होना चाहिए।

संपादित करें: OR के साथ 2 q-clauses को एकीकृत करके 14 बाइट्स सहेजे गए।


2

MATLAB, 107 बाइट्स

b=char(strsplit(char(inputdlg),' '));[~,x]=ismember(b,b(1,:));[~,f]=min(abs(1./sum(~x')-1));b(f,(~~x(f,:)))

यह कोड का एक बहुत ही मैला टुकड़ा होने के नाते समाप्त हो गया ...

जब चलाया जा रहा है, तो एक इनपुट डायलॉग खोला जाता है जहां एक मल्टी-लाइन स्ट्रिंग को चिपकाया जा सकता है (नए सिरे को रिक्त स्थान में बदल दिया जाता है और आउटपुट 1 बहुत लंबी स्ट्रिंग वाला सेल होगा)। मैंने परिणामस्वरूप सेल को एक चार में बदलने के लिए चुना, जो रिक्त स्थान पर विभाजित करना संभव बनाता है (परिणाम एक सेल सरणी है) और फिर फिर से इच्छित आकृति को पुनः प्राप्त करने के लिए चार में परिवर्तित करें। MATLAB का इन- मीम्बर है फ़ंक्शन हमारी पहली पंक्ति को अन्य लाइनों की तुलना में यहाँ एक अच्छा काम करता है।

उसके बाद यह बुरा हो जाता है ... मैंने अपने 'सबसे अच्छे मैच' की जाँच से पहली पंक्ति को बाहर करने के कई तरीके आज़माए और इसके साथ समाप्त हुआ। हम लाइन की तलाश करते हैं और फिर इस जानकारी का उपयोग सूचकांकों (हमारे ismember आउटपुट को तार्किकों में परिवर्तित करके ) को हथियाने के लिए करते हैं, जिससे हम अपना आउटपुट वर्ण चाहते हैं।


2

वोल्फ्राम भाषा 106 बाइट्स

c=Characters[InputString[]~StringSplit~"\n"];o=c[[1]];t=Select;t[t[Rest@c,#~SubsetQ~o&][[1]],o~MemberQ~#&]

उदाहरण इनपुट:

इनपुट पॉपअप

आउटपुट:

आउटपुट परिणाम

कोड की व्याख्या: InputString के साथ सबसे पहले हमें इनपुट की पूरी स्ट्रिंग मिलती है, फिर हमें न्यूलाइन द्वारा स्ट्रिंग को विभाजित करके अक्षरों का पहला सेट प्राप्त होता है, और वेरिएबल ओ में पहले वाले सभी वर्णों को सहेजता है। अगला, हम उन इनपुट लाइनों के बाकी हिस्सों से चयन करते हैं जिनमें पहली पंक्ति के वर्ण (एक चर के रूप में चर o के रूप में सहेजे गए) हैं। फिर उस पंक्ति के चयन के साथ, हम उस पंक्ति के सदस्यों को पकड़ लेते हैं जो मूल सेट में हैं।

संपादित करें: Infix नोटेशन और मेरे अनावश्यक चरों के उपयोग के सुझावों के लिए मार्टिन ब्यूटनर को धन्यवाद


याय, गणितज्ञ। कुछ गोल्फ संकेत: जहाँ तक मुझे बता सकते हैं के रूप में आप का उपयोग cऔर iकेवल एक बार, तो वहाँ उन्हें चर के बताए में कोई लाभ नहीं है। आप शायद इस टिप से कुछ बाइट्स बचा सकते हैं । oनाम न देकर । s[[1]]है #&@@s(आपके दूसरे उपयोग के लिए समान [[1]])। आप StringSplitदूसरे पैरामीटर के बिना उपयोग कर सकते हैं (क्योंकि यह डिफ़ॉल्ट रूप से व्हाट्सएप पर विभाजित होता है)। SubsetQऔर MemberQएक बाइट को बचाने के लिए इन्फिक्स नोटेशन का उपयोग कर सकते हैं, जैसे #~SubsetQ~o
मार्टिन एंडर

मैंने इसे कुछ बदल दिया, और ध्यान नहीं दिया क्योंकि मैंने इसे बदल दिया था जिसका मैंने केवल उपयोग किया था iऔर cएक बार, टिप के लिए धन्यवाद! इसके अलावा, मुझे दूसरे पैरामीटर की जरूरत है StringSplit, क्योंकि कुछ पात्रों के साथ व्हाट्सएप (जो कि वास्तव में व्हाट्सएप नहीं हैं) की व्याख्या के साथ कुछ अजीब चल रहा था
इयान जॉनसन

दिलचस्प। उस मामले में आप अभी भी \nएक बाइट बचाने के लिए, और एक अन्य को बचाने के लिए infix संकेतन का उपयोग करने के बजाय लिखने के बजाय एक शाब्दिक newline एम्बेड कर सकते हैं ।
मार्टिन एंडर

हाँ, पूरी तरह से यकीन नहीं है कि उस मामले में स्ट्रिंगस्प्लिट के साथ क्या हो रहा है, यह वास्तव में InputString का उपयोग करने का एक परिणाम हो सकता है
इयान जॉनसन

1

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

import sys
i=sys.stdin.readlines()
print[''.join(c for c in l if c in i[0])for l in i[1:]if set(i[0])<set(l)][0]

उदाहरण रन: Ideone


1

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

ब्राउज़र का समर्थन करने के लिए स्निपेट डेमो।

f=x=>([a]=x.split`
`).map(y=>[...y].filter(z=>~a.indexOf(z)-x).join(x='')).find(z=>z.length==a.length)
<textarea id="i" rows="6" cols="45">o@nj<G1
f]?-<I6h2vS*%l=:}c8>LK5rMdyeon,;sE[@m(73
ibhp+2Hq6yKzIf_Zo}EO3-[*0/e&Fvd]wQU=|%`C
;}>d'cg~CPtQG&%L\)MUl419bkTZ7@]:[*H"RyYj
L^<:zXJ#kj$EFlwN%B`Dd,Cs?]xRZ*K9-uQ.@&f+
i1v'7:90R-l}FMxj`,DTWK+(n32Z4Vs[p@%*eS!d
B|^Ti/ZG$}ufL9*wE[AVt]P7CrX-)2JpD<sYxd6O
ex.$4#KarS^j+'_!B"]H[\83:(DCXUgI*Lct?qAR
^GXQoy*KW&v}n']Em~\N9)fxP(qC=7#4sRdcD6%5
;inr[&$1j_!F~@pzo#blv]}<'|fRds6OW%tEg"G2
e;0T#gfo^+!:xHDN&4V=In?AwhEv$2Fd~ZLz_\81</textarea><br /><input type="button" onclick="o.value=f(i.value)" value="Run"> Output: <input type="text" id="o" readonly />

टिप्पणी की:

f=x=>
([a]=x.split('\n')) // split input by newlines, assign first value to a
.map(y=> // map function to each line
    [...y].filter(z=> // filter characters
        ~a.indexOf(z)-x // a has character z and not the first item (x is still set)
    ).join(x='') // join characters with empty string, reset x flag
).find(z=>z.length==a.length) // return string with same length as a
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.