ब्रेल ग्राफिक्स

Question

4x2 ब्लॉक में एक बूलियन मैट्रिक्स कट और उन्हें ब्रेल पात्रों के रूप में प्रस्तुत करना U+2800... U+28FF।

[[0,1,0,0,1,0],
 [1,0,0,0,0,0],
 [1,0,0,0,1,0],
 [1,1,1,1,0,0]]

⣎⣀⠅

0-s के साथ पैड यदि आयाम 4 और 2 के गुणक नहीं हैं।

[[0,1,0],
 [1,0,0],
 [1,1,1]]

⠮⠄

सामान्य गोल्फिंग नियम लागू होते हैं, इनपुट प्रारूप पर लचीले होते हैं। आउटपुट में या तो मैट्रिक्स की संरचना होनी चाहिए या मैट्रिक्स की तरह दिखना चाहिए, जैसे स्ट्रिंग्स की सूची; newlines के साथ एकल स्ट्रिंग।

संकेत: chr(0x2800 + 128*b7 + 64*b6 + 32*b5 + 16*b4 + 8*b3 + 4*b2 + 2*b1 + b0)डॉट पैटर्न है

b0 b3
b1 b4
b2 b5
b6 b7

बड़ा परीक्षण:

[[0,0,1,1,1,1,0,0,0,0,0,0,0,1,1,0,0,0,0,1,1,1,0],
 [0,1,1,1,1,1,1,0,0,0,0,0,1,1,1,0,0,0,1,1,1,1,1],
 [0,1,1,0,0,1,1,1,0,0,0,1,1,1,1,0,0,1,1,0,0,0,1],
 [1,1,0,0,0,0,1,1,0,0,0,0,0,0,1,0,0,1,1,0,0,1,1],
 [1,1,0,0,0,1,1,0,0,0,0,0,0,0,1,0,0,1,1,1,0,1,0],
 [1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0],
 [1,1,0,1,1,1,1,1,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0],
 [1,1,0,1,1,1,1,1,0,0,1,1,0,0,1,0,0,1,1,1,1,1,1],
 [1,1,0,1,1,1,1,0,0,1,1,1,1,0,1,0,1,1,1,1,1,1,0],
 [1,1,0,1,0,1,1,0,1,1,0,1,1,0,1,0,0,0,0,1,1,0,0],
 [1,1,0,0,0,1,1,0,1,0,0,0,1,0,1,1,0,0,0,1,1,0,0],
 [1,1,0,0,0,1,1,0,1,0,0,0,1,0,1,1,1,0,0,1,1,0,0],
 [0,1,1,0,1,1,1,0,1,0,0,1,1,0,0,1,1,0,0,1,1,0,0],
 [0,1,1,1,1,1,0,0,1,1,1,1,1,0,0,1,1,0,1,1,1,0,0],
 [0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,0,1,1,1,1,0]]

⣰⠟⠻⣦⠀⠠⠾⡇⢠⡞⢛⡆
⣿⢠⣬⣥⠄⣀⠀⡇⢈⣻⣈⡀
⣿⠘⢹⡇⡞⠙⡇⣧⡉⢹⡏⠀
⠘⠷⠟⠁⠳⠾⠃⠘⠇⠾⠧⠀

Comments

दूसरी चुनौती के लिए बधाई।

— Adám

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

— काज

@ काज मुझे नहीं पता, मैं व्यक्तिगत रूप से वास्तव में सराहना करता हूं कि यह पोस्ट कितना संक्षिप्त है। IMO, बहुत अधिक स्पष्टता किसी भी अधिक को जोड़कर नहीं जोड़ा जाएगा (कुछ छोटे स्पष्टीकरणों के अलावा, जैसे कि ऊंचाई 4 की बहु और 2 की चौड़ाई होनी चाहिए); आपका सुझाव मेरे लिए वर्तमान पोस्ट की तुलना में पढ़ने के लिए कठिन है।

— क्वेलक्लेफ

Answer 1

जेली ,  31  30 बाइट्स

sz0Z
ç€2ZF€ç€8Zœ?@€€-36Ḅ+⁽$ṁỌY

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

कैसे?

sz0Z - Link 1, split & right-pad with zeros: list, items; number, chunkSize
s    - split items into chunks of length chunkSize
 z0  - transpose with filler zero
   Z - transpose

ç€2ZF€ç€8Zœ?@€€-36Ḅ+⁽$ṁỌY - Main link: list of lists of numbers (1s & 0s), M
ç€2                       - call the last link (1) as a dyad for €ach (left=M, right=2)
                          -  ((left,right) bits read left-right then top-bottom)
   Z                      - transpose the resulting list of lists of lists
                          -  ((left, right) bits read top-bottom then left-right)
    F€                    - flatten €ach
      ç€8                 - call the last link (1) as a dyad for €ach (left=^, right=8)
         Z                - transpose the resulting list of lists of lists
                          -  ("blocks" each and all read left-right top-to bottom)
               -36        - literal -36
             €€           - for €ach (block-wise row) for €ach (block)
          œ?@             -   lexicographical permutation with reversed arguments
                          -    (get the permutation at index -36 (modular) in a list of
                          -     all permutations of the indexes sorted lexicographically.
                          -     That is the 8!-36 = 40284th - equivalently the values at
                          -     indexes [8,7,6,4,2,5,3,1])
                  Ḅ       - convert from binary list to integer (vectorises)
                    ⁽$ṁ   - base 250 literal = 10240
                   +      - add
                       Ọ  - cast to character (vectorises)
                        Y - join with newlines
                          - implicit print

Comments

Ḅ1 से अधिक "अंक" का समर्थन करता है ? परिणाम में 10240 (0x2800 - दो बाइट्स) को जोड़ने के बजाय, आप द्विआधारी अंकों के वेक्टर में 40 (0x28 - एक बाइट) को प्रीपेन्ड कर सकते हैं। मैं जेली के बारे में ज्यादा नहीं जानता, इसलिए मुझे यकीन नहीं है कि यह वास्तव में काम करेगा।

— नागिन

Ḅजैसा कि आप सुझाव देते हैं, वास्तव में 40 के एक अग्रणी अंक को बदल देगा, लेकिन हमें इसे प्रत्येक ऐसी सूची (2 की गहराई पर) के लिए प्रस्तुत करना होगा, जो मुझे लगता है, कोड के अधिक बाइट्स ( ;@€€40Ḅ) की आवश्यकता होगी ।

— जोनाथन एलन

Answer 2

जावास्क्रिप्ट ईएस 7 210 207 201 200 198 194 185 183 बाइट्स

a=>eval('for(y=0,c="";A=a[y];y+=4,c+=`\n`)for(x=0;A[x]+1;x+=2)c+=String.fromCharCode(10240+eval("for(N=k=0;k<6;k++)N+=(g=(X,Y=3)=>(a[Y+y]||0)[X+x]|0)(k>2,k%3)*2**k")|g(0)+g(1)*2<<6)')

4 बाइट्स ngn के लिए धन्यवाद बचाया

3 बाइट्स ने ल्यूक को धन्यवाद दिया

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

मैं कोड को भागों में विभाजित करने जा रहा हूं और उनके बारे में अलग से बोलूंगा:

for(y=x=0, c=""; a[y]; x+=2)
    !((a[y] || [])[x]+1) && (y+=4,x=0,c+=`\n`)

यह वह जगह है जहाँ हर चर घोषित किया जाता है। xऔर y"कर्सर" (वर्तमान ब्रेल वर्ण के ऊपरी बाएं किनारे) की स्थिति है। X समन्वय हर 2 पुनरावृत्ति से बढ़ता है, और यह तब रुक जाता है, जब सूचकांक के साथ कोई पंक्ति नहीं होती है y([x] रिटर्न undefinedयदि यह मौजूद नहीं है, जो झूठे में परिवर्तित हो जाता है)।

दूसरी पंक्ति में कई तरकीबें हैं। (a[y] || [])[x]यह सुनिश्चित करता है कि (x, y)स्थिति में मूल्य को देखने से कोई त्रुटि नहीं होती है। &&हमेशा की तरह और ऑपरेटर है, और यह केवल अभिव्यक्ति के दाईं ओर की जाँच करता है, अगर बाईं सच था। इसका अनुवाद किया जा सकता है

if (!((a[y] || [])[x] + 1)) 
    y+=4,x=0,c+=`\n`

अगला भाग:

c+=String.fromCharCode(10240+eval("for(N=k=0;k<6;k++)N+=(g=(x,y)=>(a[y]||[])[x]||0)(~~(k/3)+x,k%3+y)*2**k,N")+g(x,y+3)*64+g(x+1,y+3)*128)

String.fromCharCodeबस पारित संख्या को एक समान वर्ण कोड के साथ एक यूनिकोड वर्ण में कनवर्ट करता है। कोष्ठक में अभिव्यक्ति ब्रेल वर्ण के सूचकांक की गणना करती है:

for(N=k=0;k<6;k++)N+=(g=(x,y)=>(a[y]||[])[x]||0)(~~(k/3)+x,k%3+y)*2**k

में स्थिति के माध्यम से चला जाता है

1 4
2 5
3 6

आदेश, पलता 2 के साथ उन स्थानों पर मानों ^मैं , मैं कहाँ सूचकांक है और उन्हें एक साथ जोड़ता है।

g=(x,y)=>(a[y]||[])[x]||0

भाग एक लैम्ब्डा समारोह कहा जाता वाणी gहै, जो एक दिए गए xऔर yरिटर्न या तो पर मूल्य समन्वय (x, y)या 0 यदि सरणी की सीमा से बाहर स्थिति झूठ स्थिति।

+g(x,y+3)*64+g(x+1,y+3)*128

यह हिस्सा पिछले दो पदों को सही वज़न के साथ जोड़ता है जो फ़ंक्शन को पहले से परिभाषित करता है।

अंतिम लेकिन कम से कम, ए

a=>eval('...')

भाग के 2 कार्य हैं। यह एक अनाम लैम्ब्डा को परिभाषित करता है और यह सुनिश्चित करता है कि लूप के लिए कोई समस्या नहीं है (एक लाइन लैंबडा जैसे कि यह केवल लूप के लिए एक एकल नहीं हो सकता है, एक मूल्यांकन इसको रोकता है)।

Comments

कुछ सरल सुझाव: ||0-> |0; ~~(k/3)-> (k>2); *128-> <<7( +-s के साथ |-s)

— ngn

ईएस 7 संस्करण को अपने प्राथमिक समाधान के रूप में क्यों नहीं प्रस्तुत करें?

— झबरा

@ शैगी हर कोई अभी तक ES7 नहीं चला सकता है, इसलिए यह बैकअप है

— Bálint

यह अप्रासंगिक 'इन भागों दौर;) जब तक वहाँ एक है, एकल दुभाषिया (ब्राउज़र) जो आपके कोड को ठीक से चला सकता है, इसे यहाँ मान्य माना जाता है।

— झबरा

@ngn पहले दो के लिए धन्यवाद, लेकिन बिट शिफ्टिंग में मूल रूप से किसी भी चीज़ की तुलना में कम पूर्वता है, इसलिए यह काम नहीं करेगा

— बेलेंट

Answer 3

मैथमेटिका, 126 110 97 90

FromCharacterCode[10240+ListCorrelate[2^{{0,3},{1,4},{2,5},{6,7}},#,1,0][[;;;;4,;;;;2]]]&

---

यह समाधान मैट्रिक्स पर एक (उलट) कर्नेलListCorrelate को समझाने के लिए लाभ उठाता है , जो अनिवार्य रूप से एक स्लाइडिंग मैट्रिक्स गुणन (या डॉट डॉट) है। यहां एक दृश्य विवरण देखें । 0चौथे तर्क के रूप में उपयोग करके पैडिंग की जाती है । निम्नलिखित उदाहरण में, हम परिणाम को संकेत से मेल खाने की अपेक्षा करते हैं:

ListCorrelate[
  2^{{0, 3}, {1, 4}, {2, 5}, {6, 7}},
  {{b0, b3}, {b1, b4}, {b2, b5}, {b6, b7}}
]

(* returns {{b0 + 2 b1 + 4 b2 + 8 b3 + 16 b4 + 32 b5 + 64 b6 + 128 b7}} *)

ध्यान दें कि ListConvolveकोई भी छोटा नहीं है, क्योंकि तीसरा तर्क होगा -1।

चूंकि यह मैट्रिक्स की हर स्थिति में कर्नेल को लागू करता है, हमें बस हर चौथी पंक्ति और दूसरे कॉलम में तत्वों को निकालने की आवश्यकता है। हम के लिए shorthands का उपयोग Spanऔर Part: [[;;;;4,;;;;2]]।

सहायक रूप से, FromCharacterCodeवर्ण कोड का एक मैट्रिक्स ले सकते हैं और तार की एक सूची वापस कर सकते हैं।

---

यह समाधान स्ट्रिंग्स की एक सूची देता है, जो अनुमत आउटपुट स्वरूपों में से एक है। बस Column@आउटपुट के लिए "एक मैट्रिक्स की तरह दिखना चाहिए"।

---

आप इसके साथ एक मुफ्त ऑनलाइन Mathematica नोटबुक में खेल सकते हैं। यहां जाएं , एक नया नोटबुक बनाएं पर क्लिक करें, एक पल रुकें, इस कोड में पेस्ट करें, फिर दबाएं shift+enter।

m1={{0,1,0,0,1,0},{1,0,0,0,0,0},{1,0,0,0,1,0},{1,1,1,1,0,0}};
m2={{0,1,0},{1,0,0},{1,1,1}};
m3={{0,0,1,1,1,1,0,0,0,0,0,0,0,1,1,0,0,0,0,1,1,1,0},{0,1,1,1,1,1,1,0,0,0,0,0,1,1,1,0,0,0,1,1,1,1,1},{0,1,1,0,0,1,1,1,0,0,0,1,1,1,1,0,0,1,1,0,0,0,1},{1,1,0,0,0,0,1,1,0,0,0,0,0,0,1,0,0,1,1,0,0,1,1},{1,1,0,0,0,1,1,0,0,0,0,0,0,0,1,0,0,1,1,1,0,1,0},{1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,1,0,0,0},{1,1,0,1,1,1,1,1,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0},{1,1,0,1,1,1,1,1,0,0,1,1,0,0,1,0,0,1,1,1,1,1,1},{1,1,0,1,1,1,1,0,0,1,1,1,1,0,1,0,1,1,1,1,1,1,0},{1,1,0,1,0,1,1,0,1,1,0,1,1,0,1,0,0,0,0,1,1,0,0},{1,1,0,0,0,1,1,0,1,0,0,0,1,0,1,1,0,0,0,1,1,0,0},{1,1,0,0,0,1,1,0,1,0,0,0,1,0,1,1,1,0,0,1,1,0,0},{0,1,1,0,1,1,1,0,1,0,0,1,1,0,0,1,1,0,0,1,1,0,0},{0,1,1,1,1,1,0,0,1,1,1,1,1,0,0,1,1,0,1,1,1,0,0},{0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,0,1,1,1,1,0}};

MatrixToBraille := Column@
  FromCharacterCode[10240+ListCorrelate[2^{{0,3},{1,4},{2,5},{6,7}},#,1,0][[;;;;4,;;;;2]]]&

MatrixToBraille/@{m1,m2,m3}

फिर आपको यह देखना चाहिए:

Answer 4

डायलॉग एपीएल, 133 122 114 112 101 100 98 95 94 93 90 88 बाइट्स

मान लिया गया है ⎕IO←0

{C⍴{⎕UCS 10240+2⊥(∊S⌷⍨⍵+⍳¨A)[⍎¨⍕76531420]}¨(,b)/,⍳⍴b←{0 0≡A|⍵}¨⍳⍴S←⍵↑⍨A×C←⌈(⍴⍵)÷A←4 2}

- चैट में @ Adám के लिए 8 9 12 बाइट्स धन्यवाद

-2 बाइट्स @ngn की बदौलत

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

कैसे (इनपुट ⍵) है?

• A←4 2, वेक्टर 4 2को वेरिएबल में स्टोर करेंA
• (⍴⍵)÷के ⍵द्वारा विभाजित के आयामA
• ⌈, अधिकतम सीमा
• C←, संग्रहित किया है C
• A×, से गुणा A
• ⍵↑⍨, ⍵उन आयामों के अनुकूल है
• S←, संग्रहित किया है S
• ⍳⍴का सूचकांक S
• {0 0≡A|⍵}¨, 1जहां एक सेल के शीर्ष बाईं ओर, 0हर जगह है
• (,b)/,⍳⍴b←, सत्य सूचकांक
• {⎕UCS 10240+2⊥(∊S⌷⍨⍵+⍳¨A)[⍎¨⍕76531420]}¨, प्रत्येक तत्व को ब्रेल में बदल दें
• C⍴, के आयामों को नया आकार दें C

Comments

विचार +/(2*0 3 1,A,4+⍳3)×something→2⊥something[⍎¨⍕76524130]

— ngn

WOuld जो अभी भी काम करता है जो मैंने इसे बदल दिया है ⎕IO←0?

— ज़ाचारि

वास्तव में, यह केवल⎕IO←0 :)

— ngn

मैंने कोशिश की कि, क्या मैं कुछ गलत कर रहा हूँ? tio.run/…

— Zacharý

क्षमा करें, मैं ⎕IOएपीएल में इस बेवकूफ बात ( ) के बारे में भूल गया । के लिए ⎕IO←1, निश्चित रूप से आप 76524130. के प्रत्येक अंक में 1 जोड़ होगा

— NGN

Answer 5

जावास्क्रिप्ट, 136 बाइट्स

a=>(b=a.map(x=>[]),a.map((l,i)=>l.map((c,j)=>b[i>>2][j>>1]|=c<<'01263457'[i%4+j*4%8])),b.map(l=>l.map(c=>String.fromCharCode(10240+c))))

Ngn के लिए धन्यवाद , बिट शिफ्ट का उपयोग करके 4 बाइट्स बचाएं।

Comments

आप कुछ बदलावों का उपयोग कर सकते हैं जैसे i/4|0->i>>2

— ngn

c*2**एक सा बदलाव है, :) :)

— ngn 28'17

Answer 6

पायथन 2 + ड्रॉइल , 141 125 120 116 बाइट्स

सहेजे गए 16 बाइट्स ngn और L3viathan की बदौलत

L3viathan के लिए 5 बाइट्स सहेजे गए

बची हुई 4 बाइट्स ngn की बदौलत

from drawille import*
def a(d,c=Canvas(),e=enumerate):[c.set(j,i)for i,x in e(d)for j,y in e(x)if y];print c.frame()

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

tio में drawille स्थापित नहीं है इसलिए यह काम नहीं करता है

Comments

अजगर और इसकी बैटरी! :) मुझे आश्चर्यचकित करने में विफल नहीं है। यदि आप उपयोग करते हैं enumerate()और एक सूची समझने के लिए आप इसे 120 बाइट्स तक कम कर सकते हैं ।

— ngn

फ़ंक्शन को एक-लाइनर बनाकर कुछ बाइट्स सहेजें:def b(d,c=l.Canvas()):print([c.set(j,i)for i,x in enumerate(d)for j,y in enumerate(x)if y]and c).frame()

— L3viathan

इसे 120 बाइट्स में मिला

— L3viathan

आपको and cचाल की ज़रूरत नहीं है;print c.frame()

— समझदारी

Answer 7

APL (Dyalog) , 57 54 बाइट्स *

-3 ओपी को धन्यवाद। बूलियन मैट्रिक्स के लिए संकेत। प्रिंट्स चरित्र मैट्रिक्स।

1↓⎕UCS{2⊥40,⌽(,⍉3↑⍵),⊢⌿⍵}⌺(2 2⍴4 2)⊢0⍪⍣3⍪∘0⍣3⊢⎕,0

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

⎕,0 दाहिने ओर एक शून्य जोड़ें (स्तंभों की संख्या को भी अनदेखा कर दिया जाए)

⊢ (अलग करने के लिए उपज है कि 3और ⎕)

⍪∘0⍣3 नीचे तीन बार शून्य जोड़ें (क्योंकि ⌺आंशिक खिड़कियां गिरती हैं)

0⍪⍣3 शीर्ष तीन बार स्टैक शून्य (क्योंकि ⌺शीर्ष बाएं कोने में शुरू होता है)

⊢ उपज है कि (कोष्ठक और अलग करती है 0)

{... }⌺(2 2⍴4 2) प्रत्येक 4-पंक्ति 2-स्तंभ विंडो पर, 4-पंक्ति ऊर्ध्वाधर और 2 पंक्ति क्षैतिज चरण के साथ:

 ⊢⌿⍵ अंतिम पंक्ति (lit. वर्टिकल राईट रिडक्शन); [b6,b7]

 (... ), आगे जोड़ते:

  3↑ तीन पंक्तियाँ ले लो; [[b0,b3],[b1,b4],[b2,b5]]

  ⍉ स्थानांतरित; [[b0,b1,b2],[b3,b4,b5]]

  , फैल जाना; [b0,b1,b2,b3,b4,b5]

 अब हमारे पास है [b0,b1,b2,b3,b4,b5,b6,b7]

 ⌽ रिवर्स; [b7,b6,b5,b4,b3,b2,b1,b0]

 40, प्रीपेंड 40 (40 × 2 ⁹ = 10240 के लिए);[40,b7,b6,b5,b4,b3,b2,b1,b0]

 2⊥ आधार -2 (बाइनरी) के रूप में मूल्यांकन

⎕UCS चरित्र में परिवर्तित करें

1↓ पहली पंक्ति को छोड़ें (सभी के शून्य शून्य होने के कारण ⌺)

---

* क्लासिक में, के ⌺रूप में गिनती ⎕U233A।

Comments

कुछ बाइट्स को बचाने का एक आसान तरीका है, जेली समाधान के तहत मेरी टिप्पणी देखें।

— ngn

एक गलती होनी चाहिए - TIO लिंक आपके द्वारा यहां पोस्ट किए गए कोड से मेल नहीं खाता।

— नागिन 10'17

यह अंत के पास शून्य-गद्दी कोड है: 0⍪⍣3⍪∘0⍣3⊢⎕,0बनाम0⍪∘0⍣3⊢⎕,0

— ngn

फिक्स्ड @ngn, लेकिन मुझे लगता है कि एक लग रहा है ⍪∘0⍣3और ,0में एक बग के कारण केवल जरूरत है ⌺, और पहले एक अपने परीक्षण मामलों के लिए आवश्यक नहीं है।

— आदम

मेरे परीक्षण के मामले संपूर्ण नहीं हैं - समाधान, निश्चित रूप से, किसी भी वैध इनपुट के लिए काम करना चाहिए। आप छोटा कर सकते हैं 0⍪⍣3⍪∘0⍣3⊢⍵,0करने के लिए 0(⊖⍪)⍣6⊢⍵,0।

— ngn

Answer 8

पायथन 3 , 168 165 161 बाइट्स

def f(m):
 while m:
  r,m,s=[*zip(*m)],m[4:],''
  while r:s+=chr(10240+sum(q<<int(w)for(q,w)in zip((r[0]+(0,)*3)[:4]+(r+[()])[1],'01263457')));r=r[2:]
  print(s)

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

Comments

अच्छी तरह से गोल्फ! आप [*zip(*m[:4])]कॉल करने के बजाय तीन बाइट्स बचा सकते हैं list।

— लिन

Answer 9

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

(a!b)c=take b$c++repeat a
r([]:_)=[]
r l=['⠀'..]!!(sum.zipWith(*)[1,8,2,16,4,32,64,128]$l>>=0!2):r(drop 2<$>l)
b[]=[]
b s=r(([]!4)s):b(drop 4s)

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

Answer 10

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

a=[]
y=0
for l in eval(input()):
 y-=1;a+=y%4//3*[-~len(l)//2*[10240]];x=0
 for v in l:a[-1][x//2]|=v<<(6429374>>y%4*6+x%2*3&7);x+=1
for l in a:print(*map(chr,l),sep='')

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

Comments

आप के if y%4<1:a+=-~len(l)//2*[10240],रूप में फिर से लिखना a+=(y%4<1)*[-~len(l)//2*[10240]]और x=0;y+=1एक ही पंक्ति पर फिट कर सकते हैं । मुझे लगता है कि यह एक बाइट बचाता है।

— नवंबर

@ng ने वहां से कुछ और बाइट्स बचाए, धन्यवाद!

— लिन

Answer 11

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

कोड + 1 ध्वज के 163 बाइट्स -p

@a=eval}{for(;$r<@a;$r+=4){for($c=0;$c<@{$a[0]};$c+=2){$n="0b";map$n.=0|$a[$r+3][$c+$_],1,0;for$y(1,0){map$n.=0|$a[$r+$_][$c+$y],2,1,0}$\.=chr 0x2800+oct$n}$\.=$/}

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

प्रत्येक पंक्ति अल्पविराम को एक पंक्ति में अलग कर लेता है।

Answer 12

एपीएल (डायलॉग) , 53 बाइट्स

4 2∘{⎕ucs 2⊥40⍪(⍎¨⍕76531420)∘.⊃,¨⍺∘↑¨↓∘⍵¨⍺∘ר⍳⌈⍺÷⍨⍴⍵}

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