चूतड़ों को मसलते हुए

9

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

00 00 00 11

या, कहें, उलटे क्रम में और कुछ सज्जाकारों के साथ, जैसे:

11_00_00_00

इसके अलावा, कस्टम वर्णों के रूप में '0' और '1' को दिखाने के लिए उन्हें अलग पहचान देने के लिए प्रतिबल होना चाहिए, जैसे: 

XX oo oo oo

तो चुनौती है उस कोड को लिखना जो सभी विनिर्देशन को पूरा करता है।

विशिष्टता

फ़ंक्शन इस तरह से इनपुट लेता है: एफ (ए, मुखौटा, शून्य, वाले)

पैरामीटर:

ए - इनपुट नंबर - 0-255 की सीमा में कोई भी (अहस्ताक्षरित) पूर्णांक।
मास्क - एक स्ट्रिंग पैरामीटर जो आउटपुट के निर्माण को परिभाषित करता है।
शून्य - एक ही लंबाई की एक स्ट्रिंग, प्रत्येक आउटपुट स्लॉट के लिए 'शून्य' ग्लिफ़ को परिभाषित करती है।
लोगों - एक ही लंबाई की एक स्ट्रिंग, प्रत्येक उत्पादन स्लॉट के लिए परिभाषित करता है 'एक' ग्लिफ़।

आउटपुट निर्माण के नियम:

आउटपुट कैसे उत्पन्न होता है यह समझने के लिए उदाहरण के साथ इस छवि को करीब से देखें:

यहां छवि विवरण दर्ज करें

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

यदि इनपुट संख्या 128 थी, तो, तार्किक रूप से, आउटपुट होगा X foo bar ooo। "शून्य" और "वाले" मापदंडों में वर्ण: कोई भी मुद्रण योग्य ASCII वर्ण, मान लें कि वे हमेशा मुखौटा के साथ चार-संरेखित होते हैं।

नोट :

  • बिट्स 0-अनुक्रमित हैं: 0 वां बिट एमएसबी है।
  • मान लें कि मास्क स्ट्रिंग में अंक 8,9 की अनुमति नहीं है।
  • इनपुट स्ट्रिंग्स में किसी भी मुद्रण योग्य ASCII वर्ण शामिल हैं।
  • 'ज़ीरोस' और 'अप्स' चार-मास्क के साथ संरेखित हैं।
  • आपकी भाषा में विशेष वर्ण / संशोधक के लिए: हम मान सकते हैं कि वे इनपुट स्ट्रिंग में दिखाई नहीं देंगे।

स्पष्टता के लिए, अधिक उदाहरण देखें।

इनपुट -> आउटपुट उदाहरण

सभी 8 बिट्स को सामान्य अंडाकार और स्टिक संकेतन में एक अंतरिक्ष सीमांकक के साथ सामान्य क्रम में आउटपुट करें: 

mask  =  "0123 4567"  
zeros =  "0000 0000"  
ones  =  "1111 1111"  

A=1 ->    0000 0001


उत्पादन उलट क्रम में, डैश-एंड-ग्लिफ़ नोटेशन में: 

mask =    "| 7654 3210 |"
zeros=    "  ---- ----  "
ones =    "  ssss ssss  "

A=1  ->    | s--- ---- |
A=3   ->   | ss-- ---- |
A=128->    | ---- ---s |


पैक किए गए डेटा के लिए एक आउटपुट में विविध अधिसूचनाएं: 

mask =       "0 | 123 4567"
zeros=       "    --- ----"
ones =       "X   kkk ssss"

A= 15  ->       | --- ssss
A= 16  ->       | --k ----
A= 32  ->       | -k- ----
A= 128 ->     X | --- ----
A= 255 ->     X | kkk ssss


दोहराए जाने वाले पैटर्न: 

mask =    "| 7 66 555 4444 |"
zeros=    "  . .. ... ....  "
ones =    "  0 00 000 0000  "

A= 0 ->    | . .. ... .... |
A= 1 ->    | 0 .. ... .... |
A= 2 ->    | . 00 ... .... |
A= 3 ->    | 0 00 ... .... |
A= 4 ->    | . .. 000 .... |

अपडेट करें

नियमों को थोड़ा सरल किया गया है - कार्यक्रम को केवल एक नंबर प्रिंट करना चाहिए (न कि सरणी / संख्याओं की सूची जैसा कि शुरू में प्रस्तावित किया गया था)।

code-golf  string  binary 
— मिखाइल वी
स्रोत
क्या हम चार आदानों को स्वीकार करने वाला कार्यक्रम भी प्रस्तुत कर सकते हैं? कुछ भाषाएं बहुत अच्छी तरह से कार्य नहीं करती हैं।
— स्टीफन
@ स्टेफेनस मुझे लगता है कि हां, लेकिन मुझे यकीन नहीं है कि मैं उन लोगों को समझ
— मिखाइल वी
2
अंतिम दो तर्क अधिकांश भाषाओं में पूरी तरह से अप्रासंगिक लगते हैं, केवल 1 और 0 की आवश्यकता क्यों नहीं है? पहला तर्क यह है कि एक सूची होने के अलावा ऐसा नहीं लगता है कि नियमित भाषाओं को जोड़ने के लिए एक सरल लूप / पुनरावृत्ति जोड़ें, जबकि प्रतिस्पर्धा के लिए अधिक गूढ़ भाषाओं के लिए इसे बहुत कठिन बना दिया जाता है।
— FryAmTheEggman
@MikhailV यदि आप अपनी चुनौतियों पर सभी प्रस्तुतियाँ समझना चाहते हैं, तो सौभाग्य: / उनमें से अधिकांश में TryItOnline लिंक हैं ताकि आप उन्हें काम करते देख सकें, लेकिन वे सबसे अधिक गोल्फ भाषाओं को बकवास की तरह देखते हैं जब तक कि आप यह नहीं जानते कि वे क्या हैं
— स्टीफन
@FryAmTheEggman मुझे यह भी समझ में नहीं आता Aहै, क्योंकि यह सभी परीक्षण मामलों में समान है
— स्टीफन

जवाबों:

2

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

(A,M,O,I)=>M.replace(/[\d]/g,(d,i)=>(A>>7-d)%2?I[i]:O[i])

कोड स्निपेट दिखाएं

— darrylyeo
स्रोत
2

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

->a,f,*b{f.gsub(/\d/){b[a[55-$&.ord]][$`.size]}}

शून्य और उन मापदंडों को एक सरणी ( *b) के रूप में माना जाता है और शून्य पैरामीटर के साथ संग्रहीत किया जाता है b[0]और जो पैरामीटर संग्रहीत होते हैं b[1]।

मास्क पैरामीटर fमें प्रत्येक /\d/वर्ण ( ) उचित वर्ण से वर्ण के साथ प्रतिस्थापित होता है। विशेष चर $`, जो वर्तमान मैच तक ले जाने वाले पाठ को रखता है, स्थिति का ट्रैक रखने के लिए यहां (ab) का उपयोग किया जाता है।

रूबी की बिट इंडेक्सिंग 0 को सबसे कम महत्वपूर्ण बिट कहती है, लेकिन चुनौती 0 को सबसे महत्वपूर्ण बिट कहती है। 55 से ASCII घटाव ('7' वर्ण) एक प्रयोग करने योग्य रूबी बिट इंडेक्स देता है।

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

— RJHunter
स्रोत
1

गणितज्ञ, 131 बाइट्स

""<>Table[(f/@{##2})[[x[[i]],i]],{i,Length[x=(f=Characters)@#2/.Table[ToString@i->2+Floor[#/2^(7-i)]~Mod~2,{i,0,7}]/._String->1]}]&
— user202729
स्रोत
Length[x]हो सकता है Length@xऔर {#2,#3,#4}हो सकता है {##2}।
— कैलक्यूलेटरफैनलाइन
इसके अलावा, StringJoin@@बस हो सकता है StringJoin@और #1सिर्फ है#
— कैलक्यूलेटरफिलीन
मैंने नियमों को थोड़ा सरल किया है, अपडेट देखें।
— मिखाइल वी
1

q / kdb +, 86 64 बाइट्स

समाधान:

f:{[A;M;Z;O]@[M;m;:;((-8#0b vs A)"I"$'M m)(Z;O)'m:(&)M in .Q.n]}

उदाहरण:

q)f[1;"0123 4567";"0000 0000";"1111 1111"]
"0000 0001"
q)f[1;"| 7654 3210 |";"  ---- ----  ";"  ssss ssss  "]
"| s--- ---- |"
q)f[15;"0 | 123 4567";"    --- ----";"X   kkk ssss"]
"  | --- ssss"
q)f [0;"| 7 66 555 4444 |";"  . .. ... ....  ";"  0 00 000 0000  "]
"| . .. ... .... |"

स्पष्टीकरण:

उन सूचकांकों को बाहर निकालें जहां इनपुट मास्क Mएक अंक है, इसे mइस तरह से कहें कि हम इनपुट मास्क को संशोधित करेंगे। सही क्रम प्राप्त करने के लिए, संख्याओं को स्ट्रिंग से बाहर ले जाएं, पूर्णांक तक कास्ट करें और फिर हमारे 8-बिट सरणी में अनुक्रमित करें। या तो O(यदि 0 सेट है) या Z(यदि 0 सेट है), तो इंडेक्स में 8-बिट ऐरे का उपयोग करें और फिर दिए गए सूचकांकों में इन सूचियों में अनुक्रमित करें m। अंत में ( :) सूचक पर मूल मुखौटा के लिए इस नई सूची को लागू करें m।

{[A;M;Z;O]                                                   } / lambda function with 4 parameters
          @[ ; ; ;                                          ]  / apply, applies 3rd parameter to 1st parameter at indexes from parameter 2 with parameter 4 :)
                   (-8#0b vs A)                                / convert input number to binary (64 bit), take the last 8 items
                                              m:(&)M in .Q.n   / returns indices where mask is in "0123..789", stores in variable m
                               "I"$'M m                        / index into mask at indices m, then cast these numbers to an integer array
                  (                    )                       / we then index into our 8 bits a these offsets to get the output order
                                        (Z;O)                  / 2-item list of the zeroes and ones mask
                                             '                 / take each item on the left and right and apply them to (Z;O) (ie index in at 0 / 1 and then 123..67)
            M m :                                              / apply *this* list to M at each index given by m

टिप्पणियाँ:

अगर हमें फॉर्म में दलीलें देने की इजाजत दी गई तो आगे की 14 बाइट्स निकाल सकते हैं:

[A;M;(Z;O)]

क्यू के रूप में स्पष्ट रूप से नाम के बिना एक समारोह में दिए जाने के लिए 3 तर्क तक की अनुमति देता है (वे क्रमशः x, yऔर zक्रमशः):

f:{@[y;m;:;((-8#0b vs x)"I"$'y m)z'm:(&)y in .Q.n]}
— streetster
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.