डिजिटल क्लॉक मैच पहेली

Question

मैचों के साथ कई पहेलियाँ हैं जिनमें नए नंबर या आकृतियों को बनाने के लिए कुछ निश्चित संख्याओं को जोड़ना, हटाना या स्थानांतरित करना शामिल है। यह एक डिजिटल घड़ी के साथ ऐसा है।

12-घंटे की डिजिटल घड़ी पर एक वैध समय को देखते हुए, उस अंक को आउटपुट करें जिसके लिए इसे बनाने के लिए सबसे छोटी लाइनों को स्थानांतरित करने की आवश्यकता होती है, इसलिए घड़ी पर हर दृश्यमान अंक वह अंक बन जाता है। यदि एक से अधिक अंक न्यूनतम हैं, तो उन सभी को आउटपुट करें। यदि प्रत्येक अंक को समान, आउटपुट -1या 0 के अलावा अन्य किसी नकली मूल्य से बनाना असंभव है (आपको इनमें से बहुत कुछ मिलेगा)।

घड़ी के अंक इस तरह दिखते हैं:

  |
  |
 _
 _|
|_
 _
 _|
 _|

|_|
  |
 _
|_
 _|
 _
|_
|_|
 _
  |
  |    
 _ 
|_|
|_|
 _
|_|
 _|
 _
| |
|_|

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

इनपुट: 123

घड़ी प्रदर्शन:

       _   _
  | :  _|  _|
  | : |_   _|

आउटपुट: 4

स्पष्टीकरण: प्रदर्शन के लिए 1:23कुल 12 रेखाएँ खींचनी पड़ती हैं। इसलिए, प्रत्येक अंक के समान होने के लिए, प्रत्येक अंक में 4 लाइनें होनी चाहिए। एकमात्र अंक जिसमें 4 लाइनें हैं 4। इसलिए, जवाब होना चाहिए 4।

इनपुट: 1212

घड़ी प्रदर्शन:

     _        _
  |  _| :  |  _|
  | |_  :  | |_

आउटपुट: -1

स्पष्टीकरण: प्रदर्शन के 12:12लिए 14 लाइनों की आवश्यकता होती है। 14 को 4 से विभाजित करना पूर्णांक नहीं है, इसलिए प्रत्येक अंक के लिए समान होना असंभव है।

इनपुट: 654

घड़ी प्रदर्शन:

 _     _  
|_  : |_  |_|
|_| :  _|   |

आउटपुट: 5

स्पष्टीकरण: लाइनों की कुल संख्या १५ है। १५ को ३ से विभाजित किया गया है, इसलिए प्रत्येक अंक में ५ लाइनें होनी चाहिए। केवल अंक के पास 5 लाइनें हैं 2, 3और 5। इसका उत्तर 5यह है कि प्रत्येक अंक को बनाने के लिए केवल 2 चालों की आवश्यकता होती है। 5. बस रेखा को 6 के निचले भाग में 4 के निचले भाग में ले जाएँ, फिर आपके पास है:

 _     _  
|_  : |_  |_|
 _| :  _|  _|

फिर, जैसा कि आप देख सकते हैं, आपको बस इतना करना होगा कि अंक के शीर्ष दाईं ओर रेखा को स्थानांतरित करें जो मूल रूप से 4 से शीर्ष पर था, और आपको मिलता है 5:55। प्रत्येक अंक बनाने के लिए 2या 32 से अधिक चालों की आवश्यकता होगी।

इनपुट: 609

घड़ी प्रदर्शन:

 _     _   _
|_  : | | |_|
|_| : |_|  _|

आउटपुट: 609( 6,0,9या [6,0,9]ठीक भी है)।

स्पष्टीकरण: 6, 0, और 9केवल अंक 6 लाइनों है कि कर रहे हैं। जैसे, वे भी एकमात्र संभव समाधान हैं। यह देखना मुश्किल नहीं है कि इनमें से किसी एक को ही अंक बनाने के लिए दो चालें चलेंगी। इसलिए, आप सभी तीन अंकों का उत्पादन करते हैं।

टिप्पणियाँ:

• हालाँकि इनपुट समय मान्य होना चाहिए, लेकिन आउटपुट समय ठीक नहीं है (उदाहरण 999के लिए आउटपुट ठीक है।)
• मैं इनपुट के साथ बहुत लचीला हूं। आपको एक प्रमुख 0. की आवश्यकता हो सकती है आप एक दशमलव बिंदु के साथ एक संख्या का उपयोग कर सकते हैं। आप एक स्ट्रिंग का उपयोग कर सकते हैं। आप एक सरणी का उपयोग कर सकते हैं। आपके पास हर अंक के लिए एक पैरामीटर हो सकता है।

Comments

संबंधित: codegolf.stackexchange.com/q/54008/42545

— ETHproductions

Answer 1

जूलिया, 160 157 154

x->(c=count_ones;l=[119;36;93;109;46;107;123;37;127;111];m=l[x+1];n=map(a->c(a)==mean(map(c,m))?sum(map(b->c(a$b),m)):1/0,l);find(n.==minimum(n).!=1/0)-1)

यह एक लंबोदर फ़ंक्शन है। इसे कॉल करने के लिए एक चर पर असाइन करें। 0-9किसी भी लंबाई की सीमा में पूर्णांक के एक वेक्टर को स्वीकार करता है और परिणामों का एक (संभवतः खाली) वेक्टर देता है।

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

julia> clock = x->(c=co...        # assign function to variable
(anonymous function)

julia> clock([1 2 3])
1-element Array{Int64,1}:
 4

julia> clock([1 2 1 2])
0-element Array{Int64,1}

julia> clock([6 5 4])
1-element Array{Int64,1}:
 5

clock([6 0 9])
3-element Array{Int64,1}:
 0
 6
 9

व्याख्या

सात खंडों की गणना करें और उन्हें थोड़ा वेक्टर के रूप में प्रस्तुत करें।

+---+                     +-0-+
|   |      Enumerate      1   2
+---+   >  the seven  >   +-3-+
|   |      segments       4   5
+---+                     +-6-+

उदाहरण: 1 (खंड 2 + 5 सक्षम) बन जाता है 36(बिट्स 2 + 5 सेट)।
यहाँ अंकों के लिए अभ्यावेदन दिए गए हैं 0-9।

l=[119;36;93;109;46;107;123;37;127;111];
m=l[x+1];

हम बिट वेक्टर प्रतिनिधित्व प्राप्त करने के लिए सूचकांक के रूप में अंक का उपयोग कर सकते हैं। +1जूलिया में 1-आधारित अनुक्रमण के कारण।

फ़ंक्शन c=count_ones;एक पूर्णांक में 1-बिट्स की संख्या को गिनता है। हम एक उपनाम देते हैं क्योंकि हमें इसकी अधिक बार आवश्यकता होती है।

पूरा कार्यक्रम, कुछ हद तक असंयमित:

x->(
  c=count_ones;
  l=[119;36;93;109;46;107;123;37;127;111];
  m=l[x+1];
  n=map(a->c(a)==mean(map(c,m))?sum(map(b->c(a$b),m)):1/0,l);
  find(n.==minimum(n).!=1/0)-1
)

अब, विस्तार से अंतिम दो पंक्तियाँ:

mean(map(c,m)) प्रति इनपुट अंक लाइनों की औसत संख्या की गणना करता है।

n=map(a->...,l) सभी अंकों के वेक्टर प्रतिनिधित्व पर छोरों।

यदि हमारे वर्तमान अंक की रेखाओं की aसंख्या इनपुट के औसत लिनेकाउंट के लिए असमान है, तो वापस लौटें inf।

c(a)==mean(map(c,m))?...:1/0

यदि नहीं, तो हमारे वर्तमान और सभी इनपुट अंकों के बीच हैमिंग डिस्टेंश का योग वापस करें ।

sum(map(b->c(a$b),m))

अब हमारे पास संख्याओं का प्रतिनिधित्व करने वाला एक वेक्टर है n, जो हमें कुल संख्याओं / विलोपनों की संख्या प्रदान करता है, जो हमें सभी इनपुट अंकों को उस संख्या में बदलने के लिए करना है , या , यदि लाइनों की संख्या को बदले बिना ऐसा परिवर्तन असंभव है।100-9inf

find(n.==minimum(n).!=1/0)-1

अंत में, सभी मिनिमा के स्थान (0-आधारित) को आउटपुट करें जो कि नहीं हैं inf।