मेरा मेल मार्क! - एएससीआईआई बारकोड

Question

4-राज्य बारकोड

कई डाक सेवाएं (रॉयल मेल यूके, कनाडा पोस्ट, यूएस मेल आदि) अपने मेल के बारे में जानकारी सांकेतिक करने के लिए एक 4-स्टेट बारकोड का उपयोग करती हैं। ASCII में प्रस्तुत, यह कुछ इस तरह दिख सकता है:

| | | | | | | | | |
| | | | | | | | | | | | | | | | |
    | | | | | | | |

4-स्टेट बारकोड बार की एक पंक्ति है। प्रत्येक बार को 4 संभावनाओं की अनुमति देते हुए ऊपर, नीचे या दोनों तरफ बढ़ाया जा सकता है। इसका मतलब है कि प्रत्येक बार अनिवार्य रूप से आधार 4 अंक का प्रतिनिधित्व करता है:

            | |
बार: | | | |
                | |

अंक: 0 1 2 3

इस सहजीवन के साथ समस्या यह है कि यह प्रत्येक बारकोड एक वैध, अलग बारकोड ऊपर की ओर है: यदि अभिविन्यास गलत है, तो इसका अर्थ काफी बदल जाता है। इसलिए, एक स्टार्ट और स्टॉप सीक्वेंस को आम तौर पर लागू किया जाता है ताकि स्कैनर यह गणना कर सके कि इसे किस तरीके से पढ़ा जाना चाहिए।

इस चुनौती के उद्देश्य के लिए, हम ऑस्ट्रेलिया पोस्ट द्वारा निर्दिष्ट स्टार्ट / स्टॉप अनुक्रम का उपयोग करेंगे: प्रत्येक बारकोड एक 1 0अनुक्रम के साथ शुरू और समाप्त होता है ।

---

चुनौती

आपका कार्य एक प्रोग्राम या फ़ंक्शन लिखना है, जो एक सकारात्मक पूर्णांक दिया गया है N, इसे एक ASCII 4-स्टेट बारकोड में परिवर्तित करता है, जहां प्रत्येक बार (स्टार्ट / स्टॉप अनुक्रमों को छोड़कर) बेस -4 प्रतिनिधित्व में एक अंक को दर्शाता है N।

उदाहरण:

पूर्णांक को देखते हुए 19623, हम पहले यह इसके आधार -4 प्रतिनिधित्व करने के लिए, बदल जाएगा 10302213।

हम तब प्रत्येक अंक को संबंधित बार में मैप करेंगे:

1 0 3 0 2 2 1 3

| | | |
| | | | | | | |
    | | | |

अंत में, हम स्टार्ट / स्टॉप सीक्वेंस जोड़ेंगे:

शुरूआत समाप्ति:
१ ० १ १ ०

| | | | | |
| | | | | | | | | | | |
        | | | |

परिणामस्वरूप बारकोड प्रोग्राम का आउटपुट होना चाहिए।

---

नियम:

• इनपुट आपकी भाषा के मानक पूर्णांक आकार की सीमा के भीतर एक सकारात्मक पूर्णांक होगा।
• उत्पादन:
  • हो सकता है या तो लाइनों की एक सूची, या एक स्ट्रिंग जिसमें newlines हों।
  • जब तक आकार बरकरार रहता है, तब तक न्यूलाइंस / स्पेस में अग्रणी या अनुगामी हो सकते हैं।
  • उपरोक्त प्रारूप के साथ बारकोड दिखाना चाहिए - बार ड्रॉ करते समय पाइप चरित्र ( |) और स्पेस कैरेक्टर ( ) का उपयोग करना चाहिए , और प्रत्येक ईमानदार बार के बीच में 1 स्थान होना चाहिए।
• यह कोड-गोल्फ है , इसलिए सबसे छोटा कार्यक्रम (बाइट्स में) जीतता है!

---

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

4095:

| | | | | | | |  
| | | | | | | | | |
    | | | | | |    

4096:

| | |  
| | | | | | | | | | |

7313145:

| | | | | | | | | |  
| | | | | | | | | | | | | | | |
      | | | | | | | |      

Comments

अग्रणी रिक्तियों की अनुमति है? ;)

— आउटगोलर

@FlipTack इस सहजीवन के साथ समस्या - आपने Boondock संन्यासी को नहीं देखा है, क्या आपने?

— लॉर्ड फरक्वाड

@EriktheOutgolfer जब तक वर्णों के 2 डी मैट्रिक्स के रूप में वास्तविक बारकोड है, तब तक बरकरार है, इसमें आवश्यक के रूप में पहले या बाद में कई रिक्त स्थान हो सकते हैं।

— पलटें

अन्य बारकोड संबंधित चुनौतियां: 1 , 2 , 3

— फ्लिपकार्ट

क्या आउटपुट में अग्रणी शून्य हो सकता है?

— user230118

Answer 1

पायथन 3 , 103 99 96 बाइट्स

def f(i,r=[]):
 while i:r=[' | |||||  ||'[i%4::4]]+r;i//=4
 k='|| ',' | ';[*map(print,*k,*r,*k)]

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

Answer 2

MATL , 34 30 29 28 बाइट्स

TFiK_YAyhhH&\EQE+t~vB!P'|'*c

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

व्याख्या

TF      % Push array [1 0] (start sequence)
i       % Push input
K_YA    % Convert to base 4. Gives an array of 4-ary digits
y       % Duplicate from below: pushes [1 0] again (stop sequence)
hh      % Concatenate horizontally twice. Gives array of 4-ary digits
        % including start and stop sequences
H&\     % Two-output modulo 2: pushes array with remainders and array
        % with quotients of dividing by 2
EQE     % Times 2, plus 1, times 2, element-wise. This effectively
        % multiplies each entry by 4 and adds 2
+       % Add element-wise to the array of remainders. The stack now 
        % contains an array of numbers 2, 3, 6 or 7. Each number
        % encodes, in binary form, a column of the output. The
        % previous multiplication of the quotients by 4 will have the
        % effect of shifting one row down (one binary digit upwards),
        % to make room for the central row. The addition of 2 will
        % create the central row, which is always full
t~      % Duplicate, logical negate. Gives an array of zeros of the
        % same length
v       % Concatenate vertically into a 2-row matrix
B       % Convert to binary. Gives a matrix, where each row is the
        % binary representation of one of the numbers of the input
        % matrix, read in column-major order
!P      % Transpose, flip vertically
'|'*    % Multiply by '|'. This transforms 1 into 124 (ASCII code of
        % '|') and leaves 0 as is
c       % Convert to char. Char 0 is shown as space. Implicitly display

Answer 3

जेली , 16 15 बाइट्स

4;jƓb|ṃ⁾| ẎZṙ2G

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

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

4;jƓb|ṃ⁾| ẎZṙ2G  Main link. No arguments.

4                Set the argument and the return value to 4.
 ;               Concatenate the return value with the argument, yielding [4, 4].
   Ɠ             Read an integer n from STDIN.
  j              Join, yielding [4, n, 4].
    b            Convert 4, n, and 4 to base 4. Note that 4 is [1, 0] in base 4.
     |           Perform bitwise OR of each resulting quaternary digit and 4.
                 This pads the binary representation of a digit d to three digits: 
                 [1, d:2, d%2]
      ṃ⁾|        Convert the results to base " |", i.e., binary where ' '
                 represents 0 and '|' represents 1.
          Ẏ      Concatenate the resulting arrays that correspond to 4, n, and 4.
           Z     Zip; transpose rows and columns.
            ṙ2   Rotate 2 units yo the left, correcting the order of [1, d:2, d%2]
                 to [d%2, 1, d:2].
              G  Grid; separate columns by spaces, rows by linefeeds.

Comments

यह स्ट्रिंग 15 यूनिकोड वर्णों वाली है, यह 15 बाइट्स कैसे हो सकती है?

— jmster

@ जम्स्टर जेली का अपना कोडपेज है

— मिस्टर एक्सकोडर

@jmster ये वास्तविक अक्षर नहीं हैं। कार्यक्रम 15 विशिष्ट बाइट्स हैं, जिनमें ये निमोनिक्स हैं। बबलगम के साथ इसकी तुलना करें, यह ज्यादातर दिखता है .......लेकिन प्रत्येक डॉट एक अलग बाइट के लिए खड़ा है।

— फ्रॉनीफ्रॉग

जोड़ने के बजाय बिटवाइज़ या क्यों?

— 13

@FrownyFrog दोनों काम करेंगे। चूंकि अगला चरण बाइनरी में रूपांतरण है, इसलिए मैं एक बिटवाइज़ ऑपरेटर के साथ गया था।

— डेनिस

Answer 4

जेली , 19 बाइट्स

;4⁺;b4Fd2Uj€1Zị⁾| G

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

-1 श्री एक्सकोडर का धन्यवाद ।

Answer 5

ऑक्टेव , 78 77 75 74 70 69 बाइट्स

@(x)' |'(dec2bin([2 6 3 7;~(1:4)](:,[2 1 dec2base(x,4)-47 2 1]))-47)'

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

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

लुकअप टेबल सीधे सलाखों के नक्शे के रूप में:

   base4:  0 1 2 3 -

  lookup:  2 6 3 7 0

  binary:  0 1 0 1 0
           1 1 1 1 0
           0 0 1 1 0

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

---

* 1 बाइट से बचा, धन्यवाद @LuisMendo

---

मूल:

@(x)['' circshift(dec2bin([a=[5 4 dec2base(x,4)-44 5 4];a*0](:))'*92,1)-4384]

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

बेनामी फ़ंक्शन जो बारकोड को एक स्ट्रिंग के रूप में लौटाता है।

यह इस तथ्य पर आधारित है कि यदि हम आधार 4 अंकों में 4 जोड़ते हैं, तो हम बिट 1 और 2 स्वैप के साथ बाइनरी में परिवर्तित संख्या द्वारा बार / स्थान का प्रतिनिधित्व कर सकते हैं:

   base4:  0 1 2 3

    add4:  4 5 6 7

  binary:  0 1 0 1
           0 0 1 1
           1 1 1 1

swap 2/1:  0 1 0 1
           1 1 1 1
           0 0 1 1

एक गोल्फ के दृष्टिकोण से मुश्किल बिट सलाखों के बीच रिक्त स्थान जोड़ रहा है और से परिवर्तित कर रहा 0/1है '|'/' '।

Comments

@LuisMendo चतुर! धन्यवाद।

— टॉम कारपेंटर

Answer 6

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

n=>`|  ${(g=(a,k=n)=>k?g(a,k>>2)+(k&a?'| ':'  '):' ')(1)}|
| |${g(~0)}| |
   `+g(2)

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

let f =

n=>`|  ${(g=(a,k=n)=>k?g(a,k>>2)+(k&a?'| ':'  '):' ')(1)}|
| |${g(~0)}| |
   `+g(2)

console.log(f(4095))
console.log(f(4096))
console.log(f(7313145))

कैसे?

एनबी : नीचे दिए गए संस्करण में, टेम्पलेट शाब्दिकों को मानक तार के साथ बदल दिया गया है ताकि कोड ठीक से इंडेंट किया जा सके।

n =>                        // given the input n
  '|  ' +                   // append the top leading pattern
  (g = (a,                  // g is a recursive function taking a = mask
           k = n) =>        // and using k = value, initially set to n
    k ?                     //   if k is not zero:
      g(a, k >> 2) +        //     do a recursive call for the next group of 2 bits
      (k & a ? '| ' : '  ') //     append '| ' if the bit is set or '  ' otherwise
    :                       //   else:
      ' '                   //     append an extra leading space and stop the recursion
  )(1) +                    // invoke g() with mask = 0b01
  '|\n' +                   // append the top leading pattern and a linefeed
  '| |' +                   // append the middle leading pattern
  g(~0) +                   // invoke g() with all bits set in the mask
  '| |\n' +                 // append the middle trailing pattern and a linefeed
  '   ' +                   // append the bottom leading pattern
  g(2)                      // invoke g() with mask = 0b10

Comments

मुझे इस उत्तर को देखकर अच्छा लगेगा, कुछ अजीब चीजें चल रही हैं: पी

— ब्रायन एच।

@BrianH। मैंने एक स्पष्टीकरण जोड़ा है।

— अरनौलड

Answer 7

आर , 154 109 बाइट्स

function(n,d=c(1,0,n%/%4^floor(log(n,4):0)%%4,1,0),o=c(" ","|"))cat("",o[1+d%%2],"
",o[2+0*d],"
",o[1+(d>1)])

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

catएक मैट्रिक्स के निर्माण और उपयोग करने के बजाय बाइट्स के एक पूरे झुंड को सहेजा और उपयोग किया write, साथ ही आधार से थोड़ा अलग रूपांतरण से 6। प्रत्येक पंक्ति में एक अग्रणी स्थान के साथ प्रिंट और कोई अनुगामी newlines।

अनुक्रमण कुछ मॉड्यूलर अंकगणित का उपयोग करके होता है, कुछ अन्य उत्तरों के विपरीत नहीं, लेकिन चूंकि आर 1-आधारित अनुक्रमण का उपयोग करता है, अंकगणित कुछ अलग है।

स्पष्टीकरण:

function(n,
 d=c(1,0,                         # d contains the padding and 
   n%/%4^floor(log(n,4):0)%%4,   # the base 4 digits
   1,0),                         # 
 o=c("|"," ")                    # the vector to index into
 cat("",                         # cat separates things with spaces by default
                                 # so the empty string will print a leading space
  o[1+d%%2],"                    # odds have a | above
",                               # literal newline, a space will follow it (hence leading spaces)
 o[2+0*d],"                      # array of 2s since the middle is always |
",                               # another literal newline
 o[1+(d>1)])                     # digits greater than 1 have a | below

Answer 8

चारकोल , 50 बाइट्स

ＮθＦ²⊞υι¿θＷθ«⊞υ﹪θ⁴≧÷⁴θ»⊞υθＦ²⊞υιＥ⟦ |¦|¦  ||⟧⪫Ｅ⮌υ§ιλω

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

Ｎθ

एक नंबर इनपुट करें।

Ｆ²⊞υι

पूर्वनिर्धारित रिक्त सूची में स्टॉप अनुक्रम को पुश करें।

¿θ

यदि संख्या सकारात्मक है,

  Ｗθ«⊞υ﹪θ⁴≧÷⁴θ»

बार-बार लागू करने के लिए इसे परिवर्तित करने के लिए बार-बार आधार 4,

  ⊞υθ

अन्यथा बस इसे धक्का दें।

Ｆ²⊞υι

सूची में प्रारंभ अनुक्रम पुश करें।

Ｅ⟦ |¦|¦  ||⟧

तीन तारों पर नक्शा। प्रत्येक स्ट्रिंग 0123प्रत्येक पंक्ति के अंकों के लिए बारकोड अनुवाद का प्रतिनिधित्व करती है।

⪫Ｅ⮌υ§ιλω

अंकों पर नक्शा (सामान्य क्रम में उलट), उन्हें अनुवाद का उपयोग करके सलाखों या रिक्त स्थान में परिवर्तित करें, फिर परिणामों को तीन तारों में मिलाएं जो बाद में अलग-अलग लाइनों पर मुद्रित होते हैं।

Answer 9

जाप , 32 31 बाइट्स

A¤i2Us4)¬®n s|iS)ù2 w i|1ÃqR² y

इसे ऑनलाइन टेस्ट करें!

वास्तव में अभी तक इससे संतुष्ट नहीं हैं, लेकिन यह एक शुरुआत है ...

व्याख्या

A¤  i2Us4)¬ ®   n s |iS)ù2 w i |1Ã qR²  y
As2 i2Us4)q mZ{Zn s'|iS)ù2 w i'|1} qRp2 y
                                           Implicit: U = input, A = 10, R = newline, S = space
As2                                        Convert 10 to a binary string.
    i2   )                                 At index 2, insert
      Us4                                    the input converted to base 4.
          q                                Split into chars.
            mZ{                  }         Map each char Z to
               Zn                            Z converted to a number,
                  s'|iS)                     converted to base " |" (binary using ' ' as 0 and '|' as 1),
                        ù2                   left-padded to length 2 with spaces,
                           w                 reversed,
                             i'|1            with another pipe inserted at index 1.
                                   q       Join the resulting list on
                                    Rp2      a newline repeated twice (adds in blank columns).
                                        y  Transpose the entire string.
                                           Implicit: output result of last expression

Comments

आपकी 32 बाइट्स मुझे इस पूरी गड़बड़ के बारे में थोड़ा बेहतर महसूस कराती हैं ! मुझे वास्तव में गोल्फ की कोशिश नहीं करनी चाहिए, जबकि दोनों सेवारत और पीने वाले पिन!

— झबरा

Answer 10

हास्केल , 91 90 बाइट्स

h s=[do a<-4%s++0%0;x!!a:" "|x<-[" | |","||||","  ||"]]
_%0=[1,0]
b%n=b%div n b++[mod n b]

इसे ऑनलाइन आज़माएं! लाइनों की एक सूची देता है।

---

पहली पंक्ति के लिए एक बाइट गिनती विकल्प:

h s=[do a<-4%s++0%0;" | |  ||||"!!(x+a):" "|x<-[0,6,4]]

Answer 11

जे , ५ ४ ९ ४ 49 बाइट्स

FrownyFrog के लिए 10 बाइट्स धन्यवाद!

[:,.2{."0[:|:' |'{~#:@2 6 3 7{~1 0,4&#.inv,1,0:

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

1 0,4&#.inv,1,0: - संख्या को आधार -4 अंकों की सूची में परिवर्तित करता है, सूची की शुरुआत और अंत में 1 0 जोड़ता है

((#:2 6 3 7){' |') - एन्क्रिप्शन के लिए लुकअप टेबल, बाइनरी 0 अंतरिक्ष से मेल खाती है, 1 से '|'

{~ - ऊपर लुकअप टेबल से एक स्ट्रिंग का चयन करके आधार 4 अंक को एन्क्रिप्ट करता है (तर्क उलट)

|: - परिणामी सरणी को 3 कॉलम से 3 पंक्तियों तक स्थानांतरित करता है

[: - कांटा कैप

,.2{."0 - सलाखों के बीच रिक्त स्थान डालता है

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

Comments

@FrownyFrog धन्यवाद!

— गैलेन इवानोव

Answer 12

एपीएल + विन, 63 बाइट्स

(⍉5 3⍴' | ||  |||||   ')[;,⍉(2 1,(1+((⌈4⍟n)⍴4)⊤n←⎕),2 1),[.1]5]

स्पष्टीकरण:

(⍉5 3⍴' | ||  |||||   ') create a matrix where columns represent bars plus one for separator spaces

(1+((⌈4⍟n)⍴4)⊤n←⎕) prompt for screen input and convert to base 4 and add 1 to convert to index origin 1

2 1,...,2 1 concatenate start stop

,[.1]5 concatenate separator space indices

(.....)[.....] index into bar matrix to display

Answer 13

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

^{-2 बाइट्स notjagan को धन्यवाद}

c=a=0,1
n=input()
while n:c+=n%4,;n/=4
for l in zip(*[' |'[n%2]+'|'+' |'[n/2]for n in c+a][::-1]):print' '.join(l)

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

Comments

114 बाइट्स।

— नॉटजागन

Answer 14

05AB1E , 19 बाइट्स

4BT.øS4~bT„| ‡øÁ€S»

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

यह डेनिस के दृष्टिकोण का एक आधा-बंदरगाह है, जो कि मेरे द्वारा पहले इस्तेमाल की गई विधि की तुलना में सिर्फ एक बाइट है (जो मैं काफी खुश हूं):

05AB1E , 20 बाइट्स

4BT.øS2‰í1ýøT„| ‡€S»

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

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

4BT.øS2 ‰ í1ýøT "| | € S »| पूरा कार्यक्रम। STDIN से इनपुट लेता है, STDOUT को आउटपुट देता है।

4 बी | आधार 4 में बदलें।
  टी | ढेर पर एक 10 धक्का।
   .ø | Surrond (10 से आधार 4 प्रतिनिधित्व को प्रस्तुत करता है और जोड़ता है)।
     एस | अलग-अलग वर्णों / अंकों में विभाजित करें।
                      + ------------------------------------------------- --------------
                      | यह भाग पिछले संस्करण में ¸4.ø4в the हुआ करता था, जो
                      | का अर्थ है: 4 के साथ चारों ओर, प्रत्येक को आधार 4 में परिवर्तित करें (4 -> [1, 0])
                      | और अंत में सूची को गहरा-सपाट करें।
                      + ------------------------------------------------- --------------
      2 ‰ | Divmod 2 ([N // 2, N% 2])।
        í | रिवर्स (तत्व-वार)।
         1ý | मध्य में 1 जोड़ें (तत्व-वार)।
           ø | स्थानांतरित।
            टी "| ‡ | "10" (T) से "|" ()) का अनुवाद (to) करें।
                 € एस »| एक ग्रिड के रूप में प्रारूपित करें।
                 € एस | प्रत्येक के पात्रों को धक्का।
                   »| रिक्त स्थान द्वारा आंतरिक सूचियों में शामिल होने पर, नई सूचियों से जुड़ें।

मैंने चैट में ग्रिड चीज़ के बारे में अदनान (05AB1E के निर्माता) से पूछा है , और उन्होंने मुझे 05 बाइट बचाने के लिए, 05AB1E की एक विशेषता को इंगित करके 2 बाइट्स बचाने में मदद की: जब नई-नई सूचियों द्वारा बहु-द्विमितीय सूची में शामिल किया जाता है, तो आंतरिक सूचियाँ रिक्त स्थान का उपयोग करके भी जुड़ जाती हैं। , इसलिए अनावश्यक है।ðý

Answer 15

APL (Dyalog Classic) , 33 बाइट्स

' |'[≠\2/2⊖1⍪2 2⊤1 0(,,⊣)4⊥⍣¯1⊢⎕]

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

Comments

ओह, यह है कि आप 1 0 के साथ घेरने वाले हैं ...

— FrownyFrog

तो 2⊥⍣¯1आपको बाइनरी सूची कैसे मिलेगी?

— FrownyFrog

@FrownyFrog को घेरने का कोई सही तरीका नहीं है। हां, 2⊥⍣¯1"टू-डिकोड" का विलोम ("ओब्सेर्व") है। यह आवश्यक के रूप में कई बिट्स के साथ बाइनरी में एन्कोड करता है।

— ngn

Answer 16

जे , 42 40 39 बाइट्स

' |'{~[:#:4#.2|.0|:4#:@+1 0(,,[)4#.inv]

डेनिस की बदौलत शेव्ड 2 बाइट्स। 1 बाइट धन्यवाद ngn करने के लिए।

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

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

                                4#.inv]      to base 4
                        1 0(,,[)             append (1 0) on both sides
                   4#:@+                     add 4 to each digit and convert to binary
                0|:                          transpose
             2|.                             rotate the rows
      [:#:4#.             from base 4 to base 2, it's supposed to separate the columns
' |'{~                                       to characters

Answer 17

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

संख्या 4 को आधार में बदलने के लिए .toString, और फिर प्रत्येक पंक्ति और बिटवाइज़ के साथ कैसवर्क या लाइन द्वारा आउटपुट लाइन बनाने के लिए। लाइनों की एक सूची आउटपुट करता है।

n=>[2,3,1].map(d=>[...'10'+n.toString(4)+'10'].map(q=>(q|d)>2?"|":" ").join` `)

f = n=>[2,3,1].map(d=>[...'10'+n.toString(4)+'10'].map(q=>(q|d)>2?"|":" ").join` `)

console.log(f(19623))
console.log(f(4095))
console.log(f(4096))
console.log(f(7313145))

Comments

मानचित्र और बिटवाइज़ के साथ शांत दृष्टिकोण या! आप `10${n.toString(4)}10`

— क्रिस एम

Answer 18

बैश + कोरुटिल्स, 71 67 बाइट्स

dc -e4ddon?np|sed 's/./& /g;h;y/01/23/;G;y/12/21/;H;x;y/0123/ | |/'

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

व्याख्या

dcआधार 4, prepending और एक साथ जोड़कर करने के लिए थोड़ा और धर्मान्तरित 4(में बदल जाता है 10उत्पादन में) और का उपयोग कर nएक पंक्ति में सब कुछ रखने के लिए।

बाकी में होता है sed:

s/./& /g;     Add a space after each digit
h;            Make a copy in hold space
y/01/23/;     Prepare up the second row (2/3 will turn to pipes)
G;y/12/21/;   Append what will be the third row and prep it (1/3 will turn to pipes)
H;x;          Prepend hold space
y/0123/ | |/  Make 1 and 3 pipes, 0 and 2 spaces

Comments

डीसी के बाद भाग को पूरी तरह से सेड में बदलने से

— Kritii Lithos

बहुत अच्छा! मैंने ऐसा कुछ करने की कोशिश की, लेकिन मैंने xउन्हें संशोधित करने के लिए होल्ड / पैटर्न रिक्त स्थान के साथ चतुर होने के विभिन्न तरीकों की कोशिश की और फिर sसभी को एक ही बार में किया, और कुछ भी कम नहीं हुआ।

— सोफिया लेचनर

@Cowsquack मैं भी अपने विचार के आधार पर एक और दो बाइट्स प्राप्त करने में कामयाब रहा!

— सोफिया लेचनर

ट्रांसलिटरेशन के संयोजन का अच्छा विचार, +1

— क्रिति लिथोस

Answer 19

रेटिना , 83 बाइट्स

.+
$*
+`(1+)\1{3}
${1};
^
1;;
$
;1;;
1*;
$.&
.+
$&¶$&¶$&
T`13` `^.+
T`12` `.+$
\d
|

इसे ऑनलाइन आज़माएं! लिंक में तेज परीक्षण के मामले शामिल हैं। स्पष्टीकरण:

.+
$*

यूनीरी में बदलें।

+`(1+)\1{3}
${1};

आधार 4 में कनवर्ट करें क्योंकि ;एस द्वारा अलग किए गए यूनरी नंबर ।

^
1;;

प्रारंभ अनुक्रम प्रस्तुत करें।

$
;1;;

एक संलग्न ;है, यह एक अंकों टर्मिनेटर के बजाय एक विभाजक, और रोकने के अनुक्रम में तब्दील हो।

1*;
$.&

दशमलव में कनवर्ट करें, लेकिन प्रत्येक अंक में 1 जोड़ रहा है।

.+
$&¶$&¶$&

इसे तीन गुना करो।

T`13` `^.+

पहली पंक्ति में, 1s और 3s ( 0s और 2s का प्रतिनिधित्व करते हुए ) स्थान बन जाते हैं।

T`12` `.+$

अंतिम पंक्ति में, 1s और 2s ( 0s और 1s का प्रतिनिधित्व करते हुए ) स्थान बन जाते हैं।

\d
|

अन्य सभी अंक बार बन जाते हैं।

Answer 20

पिप , 33 31 29 27 26 बाइट्स

-Sझंडे के लिए कोड के 25 बाइट्स, +1 ।

Y^aTB4WRt" |"@[y%2oMyy/2]

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

व्याख्या

हम चार बार प्रकारों में एक पैटर्न का निरीक्षण करते हैं:

• पहली पंक्ति एक स्थान है यदि अंक सम है, यदि विषम है तो पाइप।
• दूसरी पंक्ति हमेशा एक पाइप होती है।
• तीसरी पंक्ति एक स्थान है यदि अंक 0 या 1 है, तो पाइप 2 या 3 है।

इसलिए:

                           a is cmdline arg; o is 1; t is 10 (implicit)
  aTB4                     Convert a to base 4
      WRt                  Wrap it before and after with 10
 ^                         Split into a list of digits
Y                          and yank into y
              [         ]  List of:
               y%2          0 if even, 1 if odd for each item in y
                  oMy       1 mapped to y, i.e. constant 1 for each item in y
                     y/2    Each item in y divided by 2 (0, 0.5, 1, or 1.5)
         " |"@             Use the elements of that list as indices into this string
                           Note that indices are truncated to integers!
                           Autoprint, separating rows with newline and elements of
                           each row with space (-S flag)

Answer 21

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

4─10¹:h++{»1F2%¹{Ƨ| W}¹∑ā}⁰H

यह कोशिश करो!

Answer 22

सी (जीसीसी) , 176 बाइट्स

#include<stdio.h>
int n,m;f(n,r){if(n)f(n>>2);printf("%c%c",n?32:10,(n&r||!r)&&n?'|':32);}main(){scanf("%d",&n);m=(n+(4<<(32-__builtin_clz(n)/2*2)))*16+4;f(m,1);f(m,0);f(m,2);}

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

थोड़ा कम बहुत स्वरूपित (कम गोल्फ वाला):

#include<stdio.h>
int n,m;
f(n,r) {
    if(n)
        f(n>>2);
    printf("%c%c",n?32:10,(n&r||!r)&&n?'|':32);
}

main() {
    scanf("%d",&n);
    m=(n+(4<<2*(16-__builtin_clz(n)/2)))*16+4;
    f(m,1);
    f(m,0);
    f(m,2);
}

व्याख्या

सबसे पहले, पूर्णांक पढ़ने के लिए निम्न कोड पर विचार करें और आधार 4 संस्करण का उत्पादन करें:

#include <stdio.h>
int n;
f(n) {if(n)printf("%d\n",n&3,f(n>>2));}
main(){scanf("%d",&n);f(n);}

यह आउटपुट के क्रम को उलटने के लिए टेल रिकर्सन का उपयोग करता है। प्रत्येक पुनरावर्ती चरण बिटशिफ्ट्स 2 से (पिछले 2 बिट्स को बंद करता है और 4 से विभाजित होता है)। यह 3 (0b11) के साथ बिटमास्क किए गए परिणाम को आउटपुट करता है, जो केवल अंतिम दो बिट्स को दर्शाता है, जो कि अंतिम अंक आधार 4 है।

फ़ंक्शन कॉल printfको एक अनुगामी तर्क के रूप में शामिल किया गया है (इसे मुद्रित नहीं किया गया है, लेकिन printfफ़ंक्शन और कॉल को समूहित करने के लिए {} (+2 बाइट्स) का उपयोग करने की आवश्यकता से बचने के लिए ।

यहाँ समाधान इस आधार -4 कोड का विस्तार करता है। सबसे पहले, मी को n के रूप में परिभाषित किया गया है, लेकिन ऐसा है कि आधार 4 में यह 10 पूर्वनिर्मित होगा और इसे जोड़ा जाएगा। हम तो प्रिंट एम।

नियमित रूप से मुद्रण आधार 4 में, हमने अंक प्राप्त करने के लिए 3 के बिटमास्क का उपयोग किया। मेल कोड में, शीर्ष पंक्ति वह है जो डिजिट के लो-ऑर्डर बिट (1 का एक बिटमास्क) और नीचे की लाइन हाई ऑर्डर बिट (2 का एक बिटमास्क) है। तदनुसार, rमें f(n,r)हमारे मुख्य समारोह कॉल - बिटमास्क है f(m,1)पहली पंक्ति के लिए और f(m,2)अंतिम पंक्ति के लिए।

मध्य रेखा को काम करने के लिए (हमेशा प्रिंट "" |), हम ||!rसशर्त में जोड़ते हैं - यदि आर 0 है, तो यह हमेशा सही का मूल्यांकन करेगा और "" | तब हम f(m,0)मध्य रेखा के लिए कहते हैं ।

अंत में, हम व्यवहार के लिए नई रूपरेखा चाहते हैं। printfस्रोत कोड के बाइट्स के जाने तक एक अतिरिक्त शामिल करना महंगा है, इसलिए इसके बजाय हम मौजूदा में एक और% c स्पेसियर जोड़ते हैं printf। n?32:10यदि n 0 (गलत) है, और कोई स्थान है तो एक नई रेखा प्रिंट करता है। बाइट्स को बचाने के लिए '\ n' और '' के बजाय 32 और 10 का उपयोग किया जाता है।

Comments

यदि आप चेतावनी नहीं देते हैं तो आप इसे 146 तक ले जा सकते हैं:f(n,r){n&&f(n>>2);printf("%c%c",n?32:10,(n&r|!r)&&n?'|':32);}main(n){scanf("%d",&n);f(n=(n+(4<<(32-__builtin_clz(n)/2*2)))*16+4,1);f(n,0);f(n,2);}

— गैस्ट्रोपनर

Answer 23

आम लिस्प, 191 बाइट्स

(lambda(n &aux(k`(1 0,@((lambda(n &aux r f)(do()((= n 0)f)(setf(values n r)(floor n 4))(push r f)))n)1 0)))(format t"~3{~{~:[  ~;| ~]~}~%~}"`(,(mapcar'oddp k),k,(mapcar(lambda(c)(> c 1))k))))

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

Answer 24

PHP, 99 + 1 बाइट्स

for($n=10 .base_convert($argn,10,4). 104;(~$c=$n[$i++])||3>$y+=$i=1;)echo" | ||  |||||

"[$c*3+$y];

PHP> = 5.5 के लिए शाब्दिक स्ट्रिंग अनुक्रमण और <7.1 की आवश्यकता है ताकि अनुक्रमण के लिए चेतावनी न मिले।

ऑनलाइन के साथ पाइप के रूप में चलाएं -nRया इसे आज़माएं ।

एक अनुगामी पाने के लिए एक और नई रेखा डालें।

Comments

चेतावनी: लाइन में [...] [...] में एक गैर-संख्यात्मक मान मिला

— RedClover

@Soaku PHP संस्करण 5.5 से 7.0 तक होना चाहिए

— टाइटस

Answer 25

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

B=lambda n:n<4and`n`or B(n/4)+`n%4`
def F(i):
 for r in 0,1,2:print' '.join(" |"[(int(x)%2,1,x>'1')[r]]for x in'10'+B(i)+'10') 

Ovs के लिए बड़ा धन्यवाद!

मैंने अन्य उत्तरों के तरीकों और ... नकल करने की कोशिश नहीं की।

Comments

128 बाइट्स

— ओव्स

Answer 26

सी # (.NET कोर) , 160 बाइट्स

i=>{string s=$"10{B(i)}10",a="";for(int y=0;y<3;y++,a+="\n")foreach(var t in s)a+=t<51&y!=1&t-(y>>1)!=49?"  ":"| ";return a;string B(int n)=>n>0?B(n/4)+n%4:"";}

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

मुझे यकीन है कि मैंने कुछ सुधारों को याद किया है।

DeGolfed

i=>{
    string s = $"10{B(i)}10", // prepend and append 10 to the base 4 number
           a="";

    for (int y=0; y<3; y++, a+="\n") // go through each row
        foreach (var t in s)         // go through each char digit
            a += t<51 & y != 1 & t-(y>>1) != 49 ? "  " : "| "; // check if bar or space occurs

    return a;

    string B(int n) => n>0? B(n/4) + n%4 : ""; // convert int to base 4
}

t<51 & y != 1 & t-(y>>1) != 49 यह जाँचता है कि चार '3' नहीं है, दूसरी पंक्ति नहीं है, और फिर यह देखने के लिए कि क्या पहली या तीसरी पंक्ति में कोई बाइनरी मैजिक होना चाहिए।

Answer 27

Zsh , 156 154 151 133 बाइट्स

y(){for i (${(s//)$(echo 10$(([##4]x))10)});printf "$a[(i+1)] ";echo};a=(' ' '|' ' ' '|');y;a[1]='|';a[3]='|';y;a=(' ' ' ' '|' '|');y

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

आधार -10 इनपुट को var से लेता है $x

Answer 28

जाप , 42 बाइट्स

s4 +A iA)d1"|| "0" | "2" ||"3'|³ ò3 miR ·y

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

Comments

प्रत्येक ईमानदार बार के बीच में 1 जगह होनी चाहिए

— एर्ग आउटफॉलफर

Answer 29

पायथ , 32 बाइट्स

jjL;CmXX1jk_d1`T"| ".DR2sj[4Q4)4

यहाँ कोशिश करो!

Answer 30

सी, 120 बाइट्स

अफसोस की बात है कि केवल विंडोज पर काम किया itoaजाता है , क्योंकि मानक होने के लिए बहुत अधिक सुविधा है।

char*p,s[21]="10";g(a){for(p=s;*p;)printf(!a|*p++&a?" |":"  ");puts(p);}f(n){strcat(itoa(n,s+2,4),"10");g(1);g(0);g(2);}