बिट वीविंग की कल्पना करें

Question

गूढ़ प्रोग्रामिंग भाषा बुराई का बाइट मूल्यों पर एक दिलचस्प ऑपरेशन है जिसे वह "बुनाई" कहता है। यह अनिवार्य रूप से बाइट के आठ बिट्स का क्रमपरिवर्तन है (यह कोई मायने नहीं रखता कि हम किस गिनती से शुरू करते हैं, क्योंकि पैटर्न सममित है):

• बिट 0 को बिट 2 में ले जाया जाता है
• बिट 1 को बिट 0 में ले जाया जाता है
• बिट 2 को बिट 4 में ले जाया जाता है
• बिट 3 को बिट 1 में ले जाया जाता है
• बिट 4 को बिट 6 में ले जाया जाता है
• बिट 5 को बिट 3 में ले जाया जाता है
• बिट 6 को बिट 7 में ले जाया जाता है
• बिट 7 को बिट 5 में ले जाया जाता है

सुविधा के लिए, यहां क्रमपरिवर्तन के दो अन्य प्रतिनिधित्व हैं। एक चक्र के रूप में:

(02467531)

और मानचित्रण के जोड़े की सूची के रूप में:

[[0,2], [1,0], [2,4], [3,1], [4,6], [5,3], [6,7], [7,5]]

आपका काम इस परिवर्तन कल्पना करने के लिए, बॉक्स-ड्राइंग अक्षरों का उपयोग है ─, │, ┌, ┐, └, ┘, ┼(यूनिकोड कोड अंक: U + 2500, U + 2502, U + 250C, U + 2510, U + 2514, U + 2518, यू + 253C)। इस दृश्य को निम्नलिखित बाधाओं को पूरा करना चाहिए:

पहली और आखिरी पंक्ति बिल्कुल:

0 1 2 3 4 5 6 7

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

0 1 2 3 4 5 6 7
│ │ └─┼┐│ │ └┐│
└─┼─┐ ││└─┼─┐││
┌─┘ │ ││  │ │││
│ ┌─┼─┘│  │ │││
│ │ │ ┌┼──┘ │││
│ │ │ │└┐ ┌─┼┼┘
│ │ │ │ │ │ │└┐
0 1 2 3 4 5 6 7

हालांकि, कोई भी अन्य लेआउट जो सही अंकों को सही ढंग से जोड़ता है वह भी ठीक है। कृपया अपने उत्तर में अपना चुना हुआ आउटपुट दिखाएं।

आप एक प्रोग्राम या फ़ंक्शन लिख सकते हैं और कोई इनपुट नहीं लेंगे। आरेख को या तो STDOUT (या निकटतम विकल्प) या एक स्ट्रिंग या एक तार की सूची के रूप में फ़ंक्शन रिटर्न मान के रूप में आउटपुट करें (प्रत्येक एक पंक्ति का प्रतिनिधित्व करता है)।

मानक कोड-गोल्फ नियम लागू होते हैं, इसलिए सबसे छोटा कोड (बाइट्स में) जीतता है।

Comments

क्या हम उन भाषाओं के लिए अन्य प्रतीकों का उपयोग कर सकते हैं जो यूनिकोड का समर्थन नहीं करते हैं?

— दोष

यह चुनौती अनिवार्य रूप से प्रदान किए गए आउटपुट को कॉपी-पेस्ट करने के लिए उबालती है ... 01234567इनपुट के रूप में क्रमचय लेने और फिर उस से कनेक्ट करने के बारे में कैसे 01234567? ताकि आपको स्वयं लिंक का पता लगाना पड़े? यह विशेष रूप से गोल्फिंग के लिए एक कार्य को और अधिक चुनौतीपूर्ण होगा।

— शौकी

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

— मार्टिन एंडर

किसी को इसे बुराई में हल करना होगा।

— आर.के.

@ होलर एक अच्छा कारण है जो हम ऐसा नहीं करते हैं: फिर लोग इसे स्ट्रिंग को बड़े यूनिकोड वर्णों में पैक करके सांकेतिक शब्दों में बदलना कर सकते हैं, जो एक ही चरित्र में कई बाइट्स की जानकारी संग्रहीत कर सकता है। उदाहरण।

— मार्टिन एंडर

Answer 1

दरअसल, 69 बाइट्स

"│ ┌┘│ │└┐ │└┐└┐""┌┘└┼┐└┼┐ └┼┐└┐""└┼┐│└┐┌┘└┐┌┘│""┌┼─┘"3*"│┌┘"+8r' j;)

इसे ऑनलाइन आज़माएं! (संरेखण ऑनलाइन दुभाषिया में थोड़ा गड़बड़ है)

वास्तव में यहाँ एक बड़ा लाभ है - सभी बॉक्स ड्राइंग वर्ण CP437 में हैं, इसलिए वे केवल एक बाइट हैं। यद्यपि प्रत्येक वर्ण की आवश्यकता सैद्धांतिक रूप से 4 बिट्स में एन्कोड की जा सकती है (क्योंकि केवल 9 अद्वितीय वर्ण हैं), स्ट्रिंग को संपीड़ित करके बचाए गए 31 बाइट्स वास्तव में बहुत खराब स्ट्रिंग प्रसंस्करण क्षमताओं के कारण खो जाएंगे। इसका मतलब यह भी है कि किसी भी 8x4 कॉन्फ़िगरेशन का परिणाम समान होगा। चूंकि 8x4 प्रतीत होता है (लंबवत) सबसे कम संभव कॉन्फ़िगरेशन है, यह इष्टतम है।

3 बाइट के लिए मार्टिन को धन्यवाद!

4 और बाइट्स के लिए टिम्मीड को धन्यवाद!

स्पष्टीकरण:

"│ ┌┘│ │└┐ │└┐└┐""┌┘└┼┐└┼┐ └┼┐└┐""└┼┐│└┐┌┘└┐┌┘│""┌┼─┘"3*"│┌┘"+8r' j;)
"│ ┌┘│ │└┐ │└┐└┐""┌┘└┼┐└┼┐ └┼┐└┐""└┼┐│└┐┌┘└┐┌┘│""┌┼─┘"3*"│┌┘"+         push the individual lines, using string multiplication to shorten repeated sections
                                                              8r' j   push the string "0 1 2 3 4 5 6 7" (range(8), join on spaces)
                                                                   ;)  make a copy and move it to the bottom of the stack

Comments

तकनीकी रूप से बहुत से अन्य उत्तरों में सिंगल-बाइट एन्कोडिंग का उपयोग किया जा सकता था और साथ ही साथ जो भी सिंगल-बाइट एन्कोडिंग का उपयोग करके अपनी भाषा का समर्थन करता है (यदि कोई हो), उसी बाइट्स को आपकी तरह आउटपुट करके "आउटपुट CP437- एन्कोडेड" है। , लेकिन ऐसा लगता है कि उस पर कोई नहीं उठा। ¯ \ _ (ツ) _ / ¯

— मार्टिन एंडर

Answer 2

PowerShell v2 +, 172 153 148 145 142 131 123 बाइट्स (81 वर्ण)

($a=""+0..7)
$b='┌┘'
"│$b$('┌┼─┘'*3)
└┼┐$('│└─┐'*3)
$b$('└┼─┐'*3)│
│ $($b*6)│"
$a

मैंने इनलाइन कोड ब्लॉक का उपयोग करके कई वेरिएबल्स की आवश्यकता को समाप्त करते हुए, बुनाई को आगे बढ़ाया। यह शायद इष्टतम के कुछ बाइट्स के भीतर है।

हम $aउस श्रेणी के बराबर सेट करके शुरू करते हैं 0..7जो रिक्त स्थान के साथ जुड़ गई है। ऐसा इसलिए है क्योंकि $ofsकिसी सरणी के लिए डिफ़ॉल्ट (आउटपुट फील्ड सेपरेटर) एक स्थान है, इसलिए जब सरणी को ""+इस तरह के ऑपरेटर के साथ (जैसे पॉवरशेल ) बाएं हाथ की वस्तु के रूप में दाएं-हाथ की वस्तु को निकालने का प्रयास करेगा, तो परिणाम रेंज स्पेस-अलग है।

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

PS C:\Tools\Scripts\golfing> .\visualize-bit-weaving.ps1
0 1 2 3 4 5 6 7
│┌┘┌┼─┘┌┼─┘┌┼─┘
└┼┐│└─┐│└─┐│└─┐
┌┘└┼─┐└┼─┐└┼─┐│
│ ┌┘┌┘┌┘┌┘┌┘┌┘│
0 1 2 3 4 5 6 7

Comments

नीचे की तरफ आगे-पीछे होने के साथ अच्छा काम। :)

— मार्टिन एंडर

Answer 3

जावास्क्रिप्ट ईएस 6, 168 167 बाइट्स

संपादित करें: वूप्स, निकला मैं फ़ंक्शन के हिस्से में |यू + 2502 के बजाय पाइप चार का उपयोग कर रहा था │, अपडेटेड बाइट गिनती।

_=>((n=`0 1 2 3 4 5 6 7 `)+[...`6452301`].map(i=>`${(d=n=>`│ `.repeat(n))(i)}└┐│ ${r=d(6)}┌┼┘ ${r}│└┐ ${d(6-i)}`).join``+n).match(/.{16}/g).join`
`

एक स्ट्रिंग लौटाता है।

आउटपुट:

0 1 2 3 4 5 6 7 
│ │ │ │ │ │ └┐│ 
│ │ │ │ │ │ ┌┼┘ 
│ │ │ │ │ │ │└┐ 
│ │ │ │ └┐│ │ │ 
│ │ │ │ ┌┼┘ │ │ 
│ │ │ │ │└┐ │ │ 
│ │ │ │ │ └┐│ │ 
│ │ │ │ │ ┌┼┘ │ 
│ │ │ │ │ │└┐ │ 
│ │ └┐│ │ │ │ │ 
│ │ ┌┼┘ │ │ │ │ 
│ │ │└┐ │ │ │ │ 
│ │ │ └┐│ │ │ │ 
│ │ │ ┌┼┘ │ │ │ 
│ │ │ │└┐ │ │ │ 
└┐│ │ │ │ │ │ │ 
┌┼┘ │ │ │ │ │ │ 
│└┐ │ │ │ │ │ │ 
│ └┐│ │ │ │ │ │ 
│ ┌┼┘ │ │ │ │ │ 
│ │└┐ │ │ │ │ │ 
0 1 2 3 4 5 6 7 

---

अतिरिक्त: @ TimmyD की विधि का उपयोग करके, मेरे पास एक और 167 बाइट समाधान है:

(n=`0 1 2 3 4 5 6 7
`,a=`│┌┘ `,b=`└┼─┐`,d=`┌┼─┘`,f=` │└┐`)=>[n,a,a,a,a,`
`,b,b,b,`└┼┐
┌┘`,d,d,d,`│
│`,f,f,f,` │
`,n].join``

Answer 4

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

f=
_=>`0
│2525252
1 1 1 1
24242423525252 3 1 1 1 3 242424│
0`.replace(/\d/g,d=>`0 1 2 3 4 5 6 7,└┼┐,┌┘,│
│,│ , │`.split`,`[d])  
;
o.textContent=f();

<pre id=o></pre>

घंटी-घंटी के रूप में मैंने तुरंत इसे प्लेन हंट मेजर की पहली दो पंक्तियों के रूप में मान्यता दी (ध्यान दें कि लिंक की गई छवि 0-4 की बजाय 1-8 का उपयोग करती है)।

Answer 5

पायथ - 119 104 100 81 बाइट्स

बेहद सरल। (इसके वास्तव में इस समय बाइट्स)।

js[KjdU8cX."sz¨ú¨ãÆhÆ?\ÕüÓ¼xFNøa"_G"│┌┘└┼─┐ "15K

इसे यहाँ ऑनलाइन आज़माएँ ।

मैंने @ TimmyD का आउटपुट भी चुरा लिया है:

0 1 2 3 4 5 6 7
│┌┘ │┌┘ │┌┘ │ │
└┼─┐└┼─┐└┼─┐└┐│
┌┘┌┼─┘ └┐│┌┼─┼┘
│ │└┐ ┌─┼┘│└┐└┐
0 1 2 3 4 5 6 7

Answer 6

MS-DOS बैच, 136 बाइट्स

@echo 0 1 2 3 4 5 6 7
@echo ³ÚÙ ³ÚÙ ³ÚÙ ³ÚÙ
@echo ÀÅÄ¿ÀÅÄ¿ÀÅÄ¿ÀÅ¿
@echo ÚÙÚÅÄÙÚÅÄÙÚÅÄÙ³
@echo ³ ³À¿ ³À¿ ³À¿ ³
@echo 0 1 2 3 4 5 6 7

@ टिम्मीड के आउटपुट का उपयोग करना। यह विंडोज बैच में भी काम कर सकता है, लेकिन मेरा कोड पृष्ठ CP850 है, सीपी 437 नहीं।

Comments

विंडोज में भी काम करता है, भले ही आप CP437 या CP850 का उपयोग करें।

— होल्गर

@ होल्गर हुह, मुझे लगता है कि मुझे इसे वैसे भी आज़माना चाहिए था, बस देखने के लिए!

— नील

Answer 7

MATLAB / ऑक्टेव, 112 109 बाइट्स

a='0 1 2 3 4 5 6 7';d=['└┐│ ';'┌┼┘ ';'│└┐ '];e=repmat('│ ',3,1);[a;d d d d;e d d d e;a]

आउटपुट:

0 1 2 3 4 5 6 7
└┐│ └┐│ └┐│ └┐│
┌┼┘ ┌┼┘ ┌┼┘ ┌┼┘
│└┐ │└┐ │└┐ │└┐
│ └┐│ └┐│ └┐│ │
│ ┌┼┘ ┌┼┘ ┌┼┘ │
│ │└┐ │└┐ │└┐ │
0 1 2 3 4 5 6 7

मेरा कोड @Dendrobium और @Neil के ouputs पर आधारित है ।

Comments

गोल्फ के उत्पादन के

— आउटगोल्फर

सूचना: लिंक की गई टिप्पणी हटा दी गई है। यह ओपी कह रहा था कि आपका आउटपुट @TimmyD की तुलना में अधिक गोल्फ है।

— निकले आउटगॉल्फ

Answer 8

/// , 112 बाइट्स (100 वर्ण)

/8/0 1 2 3 4 5 6 7//9/│//A/└┐//B/┌┼┘/8/C/9 A9 A9 A9//D/9A 9A 9A 9/
AC
B B B B
DA
C 9
9 B B B 9
9 D
8

धन्यवाद @MartinEnder -3 बाइट्स के लिए!
धन्यवाद @MartinEnder -9 बाइट्स के लिए!
15-वर्ण नियम को इंगित करने के लिए @MartinEnder (ओपी) धन्यवाद

@ TimmyD के @ मार्को के आउटपुट का उपयोग करता है

0 1 2 3 4 5 6 7
└┐│ └┐│ └┐│ └┐│
┌┼┘ ┌┼┘ ┌┼┘ ┌┼┘
│└┐ │└┐ │└┐ │└┐
└┐│ └┐│ │ └┐│ └┐│
┌┼┘ ┌┼┘ │ ┌┼┘ ┌┼┘
│└┐ │└┐ │ │└┐ │└┐
0 1 2 3 4 5 6 7

Answer 9

पायथन 3, 209 बाइट्स

lambda s="0 1 2 3 4 5 6 7\n":s+"│┌┘ │┌┘ │┌┘ │ │\n└┼─┐└┼─┐└┼─┐└┐│\n┌┘┌┼─┘ └┐│┌┼─┼┘\n│ │└┐ ┌─┼┘│└┐└┐\n"+s

एक स्ट्रिंग लौटाता है।

2 बाइट बचाने के लिए @ मीगो का शुक्रिया!

चरित्र निकाय के क्रेडिट @TimmyD पर जाएं!

Comments

आपको उस a,भाग की आवश्यकता नहीं है , जो इसे एक पैरामीटर के साथ बुलाए जाने की आवश्यकता को भी दूर करेगा।

— मेगो

Answer 10

सुधार , 99 बाइट्स (87 वर्ण)

$8
AC
BE
DA
C 9
9E 9
9 D
8$E B B B$D9A 9A 9A 9$C9 A9 A9 A9$B┌┼┘$A└┐$9│$80 1 2 3 4 5 6 7

@ मार्को के आउटपुट का उपयोग करता है (हर 16 वें वर्ण को एक नई रेखा के साथ बदलें (regex: (.{15}).-> \1\n))।

0 1 2 3 4 5 6 7
└┐│ └┐│ └┐│ └┐│
┌┼┘ ┌┼┘ ┌┼┘ ┌┼┘
│└┐ │└┐ │└┐ │└┐
└┐│ └┐│ │ └┐│ └┐│
┌┼┘ ┌┼┘ │ ┌┼┘ ┌┼┘
│└┐ │└┐ │ │└┐ │└┐
0 1 2 3 4 5 6 7

Answer 11

बैश + जीएनयू सेड, 140 बाइट्स

sed 'h
s/$/nxxxacnb b b bnyyycanc xxxcnc b b b cnc yyyc/
:
s/x/ac /
s/y/ca /
s/a/└┐/
s/b/┌┼┘/
t
y/cn/│\n/
G'<<<'0 1 2 3 4 5 6 7'

आउटपुट:

0 1 2 3 4 5 6 7
└┐│ └┐│ └┐│ └┐│
┌┼┘ ┌┼┘ ┌┼┘ ┌┼┘
│└┐ │└┐ │└┐ │└┐
│ └┐│ └┐│ └┐│ │
│ ┌┼┘ ┌┼┘ ┌┼┘ │
│ │└┐ │└┐ │└┐ │
0 1 2 3 4 5 6 7

@ टिम्मीड के आउटपुट का उपयोग करना : 142 बाइट्स

sed 'h
s/$/npbcccnsurdddnbeeepnp bbbbbbp/
:
s/b/qt/
s/c/quot/
s/d/psor/
s/e/suor/
t
y/nopqrstu/\n─│┌┐└┘┼/
G'<<<'0 1 2 3 4 5 6 7'

आउटपुट:

0 1 2 3 4 5 6 7
│┌┘┌┼─┘┌┼─┘┌┼─┘
└┼┐│└─┐│└─┐│└─┐
┌┘└┼─┐└┼─┐└┼─┐│
│ ┌┘┌┘┌┘┌┘┌┘┌┘│
0 1 2 3 4 5 6 7

Answer 12

टीईसी , 205 बाइट्स

puts "[set B "0 1 2 3 4 5 6 7"]
│┌┘ │┌┘ │┌┘ └┐│
└┼┐ └┼─┐└┼──┐││
┌┘└─┐│ └┐│┌─┼┼┘
│ ┌─┼┘┌─┼┘│ │└┐
$B"

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

आउटपुट

0 1 2 3 4 5 6 7
│┌┘ │┌┘ │┌┘ │┌┘
└┼┐ └┼┐
┌┘└─┐│ ┌┘└─┐│
│└┐ │└┐ │└┐
0 1 2 3 4 5 6 7

Answer 13

SOGL V0.12 , 64 बाइट्स

└┼─┐³
┘┌┼─┘²
┐│└─┐¹
┌┘┌┘┌┘⁰
│┌²┌┼─²¶└┼¹│└─¹¶┌┘³³³│¶│ ⁰⁰│”8δ@∑Q;O

यह कोशिश करो!

पावरशेल से चोरी हुआ पैटर्न