बाइनरी ब्रांच

Question

एक द्विआधारी संख्या को देखते हुए, आपका कार्य 2 की गहराई के साथ, उस संख्या की 'शाखा' बनाना है।

उदाहरण के लिए, 0इनपुट के रूप में दिया गया है, आपको इसका बिल्कुल उत्पादन करना चाहिए:

     /000
  /00
 /   \001
0
 \   /010
  \01
     \011

यह शाखाएं कैसे बनाई जानी चाहिए, इसकी काफी आत्म व्याख्यात्मक होनी चाहिए। गहराई 2 का मतलब है कि हम 2 नंबर तक की संख्या के लिए शाखाओं की गणना करते हैं। हम क्रम में शाखाओं की गणना भी करते हैं, शीर्ष पर शून्य और सबसे नीचे वाले।

अधिक परीक्षण के मामले:

0

     /000
  /00
 /   \001
0
 \   /010
  \01
     \011

1

     /100
  /10
 /   \101
1
 \   /110
  \11
     \111

00

       /0000
   /000
  /    \0001
00
  \    /0010
   \001
       \0011

01

       /0100
   /010
  /    \0101
01
  \    /0110
   \011
       \0111

10

       /1000
   /100
  /    \1001
10
  \    /1010
   \101
       \1011

11

       /1100
   /110
  /    \1101
11
  \    /1110
   \111
       \1111

नियम

• आपको इनपुट के अलावा 1और वर्ण कभी नहीं मिलेंगे 0।
• 0 < length of input < 11।
• अनुगामी व्हाट्सएप को लाइनों के अंत में अनुमति दी गई।

Comments

0 < length of input < 11है 11दशमलव या द्विआधारी? : P

— ETHproductions

@ETHproductions दशमलव: P

— Okx

Answer 1

जेली , 39 38 बाइट्स

L⁶ẋ,W;“/0¶\1 ”ṃ@“ð&ẏ{×ẏĊfẏȷ®ỤṪ⁻ʠaƇGⱮȷ’

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

कैसे?

मुद्रित होने की कला है:

L  L /N00
L /N0
L/ L \N01
N
L\ L /N10
L \N1
L  L \N11

Nइनपुट स्ट्रिंग कहां है औरL की लंबाई के रिक्त स्थान की एक स्ट्रिंग है।

ऐसे में यह आठ घटक होते हैं ( L, N, /, 0, न्यू लाइन चरित्र, \, 1, और अंतरिक्ष चरित्र) और इसलिए एक आधार -8 संख्या (जो जेली में एक आधार-250 संख्या के रूप में संकुचित हो सकती है) के रूप में जमा किया जा सकता है। ṃपरमाणु जोड़ती आधार रूपांतरण और एक सूची में अनुक्रमण (प्रभावी रूप से एक मनमाना अंक परिभाषित कर सकते हैं इस्तेमाल किया जा करने के लिए)।

L⁶ẋ,W;“/0¶\1 ”ṃ@“ð&ẏ{×ẏĊfẏȷ®ỤṪ⁻ʠaƇGⱮȷ’ - Main link: binary string s  e.g. "100"
 ⁶                                     - space character
  ẋ                                    - repeat by:
L                                      -     length(s)                    [' ',' ',' ']
    W                                  - wrap s in a list                 [['1','0','0']]
   ,                                   - pair               [[' ',' ',' '],['1','0','0']]
      “/0¶\1 ”                         - char list: ['/','0',<newline>,'\',','1',' ']

     ;                                 - concatenate        [[' ',' ',' '],['1','0','0'],'/','0',<newline>,'\',','1',' ']
                “ð&ẏ{×ẏĊfẏȷ®ỤṪ⁻ʠaƇGⱮȷ’ - base 250 number: 91531517467460683226372755994113932025707662527
              ṃ@                       - base decompression [reversed @arguments]
                                        -     this uses the concatenated list above as
                                        -     the 8 digits of that number in base 8.
                                        - implicit print

Answer 2

बैच, 178 170 159 बाइट्स

@set/pb=
@set s=%b:0= %
@set s=%s:1= %
@set e=@echo %s%
%e%  %s% /%b%00
%e% /%b%0
%e%/ %s% \%b%01
@echo %b%
%e%\ %s% /%b%10
%e% \%b%1
%e%  %s% \%b%11

संपादित करें: 11 बाइट्स @ ConorO'Brien के लिए धन्यवाद सहेजा गया।

Comments

मैं केवल 149 बाइट्स गिनता हूं ।

— इंजीनियर टोस्ट

मुझे लगता है कि नील लाइन को विंडोज-स्टाइल CRLF के रूप में गिन रहा है जबकि TIO उन्हें LF के रूप में गिन रहा है। मुझे यकीन नहीं है कि LF विंडोज पर बैच के लिए काम करता है या नहीं।

— एलेक्स ए।

Answer 3

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

s=>`22   /300
2 /30
2/2  4301
3
242  /310
2 431
22   4311`.replace(/./g,n=>[s.replace(/./g,' '),s,'\\'][n-2]||n)

डेमो

let f =

s=>`22   /300
2 /30
2/2  4301
3
242  /310
2 431
22   4311`.replace(/./g,n=>[s.replace(/./g,' '),s,'\\'][n-2]||n)

console.log(f('0'))
console.log(f('11'))
console.log(f('101'))

Comments

क्यों नहीं [n,n,s.replace(/./g,' '),s,'\\'][n]?

— tsh

@tsh को गैर-संख्यात्मक वर्णों को अनदेखा करने के /\d/gबजाय खोजना होगा /./g।

— अरनुलद

Answer 4

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

lambda k:'ll   /g00\nl /g0\nl/l  \g01\ng\nl\l  /g10\nl \g1\nll   \g11'.replace('l',' '*len(k)).replace('g',k)

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

• जोनाथनअलन (लैम्ब्डा फ़ंक्शन का उपयोग) के लिए 8 बाइट्स धन्यवाद

मुद्रित होने पर प्रारूप स्ट्रिंग जैसा दिखता है:

ll   /g00
l /g0
l/l  \g01
g
l\l  /g10
l \g1
ll   \g11

यह पहले से ही 1. की लंबाई के स्ट्रिंग के लिए अच्छा लगता है। हमें बस इतना करना है कि l को g के बराबर लंबाई के स्थानों से बदल दिया जाए और निश्चित रूप से, g को मूल स्ट्रिंग द्वारा प्रतिस्थापित किया जाना है

Comments

आप एक अनाम लैम्ब्डा का उपयोग करके एक बाइट को बचा सकते हैं, जिसका अर्थ यह भी है कि आप प्रिंट से छुटकारा पा सकते हैं (क्योंकि स्ट्रिंग को स्वीकार्य होना चाहिए) और एक और सात बाइट्स बचाएं। तब आप एक मल्टीलाइन स्ट्रिंग का उपयोग करके आपको 107 तक नीचे लाकर

— जोनाथन एलन

Answer 5

पायथन 3.6, 172 153 128 बाइट्स

शाब्दिक रूप से इससे अधिक सीधा नहीं मिलता है ... यह वास्तव में एक एल्गोरिथ्म के साथ इसे उत्पन्न करने के मेरे मूल प्रयास से कम है। कितने उदास हैं।

k=input()
l=len(k)
b=' '*l
print(f'{b*2}   /{k}00\n{b} /{k}0\n{b}/ {b}\\{k}01\n{k}\n{b}\\ {b}/{k}10\n{b} \\{k}1\n{b*2} \\{k}01')

-19 बाइट्स @Leo
-25 बाइट्स के लिए @ L3viathan को धन्यवाद

Comments

मुझे लगता है कि ए, सी, और डी को छोड़ना और अंतिम स्ट्रिंग में केवल बी और रिक्त स्थान का उपयोग करना कम होगा। (a b*2+' '))

— सिंह

अजीब, अभी भी मेरे लिए 172 बाइट्स लगता है।

— प्रोग्रामर

@ programmer5000 क्षमा करें, ऐसा इसलिए होगा क्योंकि मैं स्वयं कोड अपडेट करना भूल गया था।

— हाइपरनेत्रिनो

प्रारूप स्ट्रिंग के साथ 26 अक्षरों को सहेजें:print(f'{a}/{k}00\n{b} /{k}0\n{b}/ {b}\\{k}01\n{k}\n{b}\\ {b}/{k}10\n{b} \\{k}1\n{b*2} \\{k}01')

— L3viathan

@ L3viathan क्या आप उस पर वाक्य रचना की जांच कर सकते हैं? यह मुझे एक वाक्यविन्यास त्रुटि दे रहा है।

— हाइपरएनुट्रिनो

Answer 6

सी, 170 168 बाइट्स

दो बाइट बचाने के लिए @ नील का धन्यवाद!

n;f(char*s){n=strlen(s);printf("%*c%s00\n%*c%s0\n %*c%*c%s01\n%s\n %*c%*c%s10\n%*c%s1\n%*c%s11",2*n+4,47,s,n+2,47,s,n,47,n+3,92,s,s,n,92,n+3,47,s,n+2,92,s,2*n+4,92,s);}

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

Comments

मुद्रण के बजाय /या ` padded to width n + 1 , why not print a space, and then a / `या \चौड़ाई तक गद्देदार n?

— नील

उह, मुझे फिर से कोशिश करते हैं। चौड़ाई को मुद्रित करने /या \गद्देदार करने के बजाय n+1, एक स्थान क्यों नहीं मुद्रित किया जाता है, और फिर एक /या \गद्देदार चौड़ाई n?

— नील

Answer 7

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

lambda s:"""   /00
 /0
/  \01

\  /10
 \1
   \11""".translate([s,' '*len(s),s])

इसे ऑनलाइन आज़माएं! अचूक अक्षर सही ढंग से प्रदर्शित नहीं होते हैं; स्ट्रिंग स्वरूप है officialaimm के रूप में एक ही साथ लेकिन, \x01के लिए lऔर \x02के लिए g।

ll   /g00
l /g0
l/l  \g01
g
l\l  /g10
l \g1
ll   \g11

पायथन 3 के लचीलेपन केtranslate साथ स्ट्रिंग प्रतिस्थापन का उपयोग करता है । अनुवाद सूची [s,' '*len(s),s]मैप्स \x01को ' '*len(s)और \x02को s। कोई भी बड़ा पात्र अपरिवर्तित है, क्योंकि वे ऐसे संकेत देते हैं जो सूची के लिए आउट-ऑफ-बाउंड हैं। \x00उपयोग नहीं किया जा सका क्योंकि एक अशक्त बाइट को प्रोग्राम अंत के रूप में पढ़ा जाता है, इसलिए पहली प्रविष्टि बर्बाद हो जाती है।

Answer 8

PHP , 128 बाइट्स

केवल एक साधारण आउटपुट

<?=$b=str_pad("",strlen($a=$argn)),"$b   /{$a}00\n$b /{$a}0\n$b/$b  \\{$a}01\n$a\n$b\\$b  /{$a}10\n$b \\{$a}1\n$b$b   \\{$a}11";

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

Answer 9

ढेर , 81 बाइट्स

{!n#'' '*@s's  s /n00
s /n0
s/ s \n01
n
s\ s /n10
s \n1
s  s \n11' '\l'$#~1/repl}

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

बहुत दिलचस्प नहीं, दुर्भाग्य से। यहाँ सबसे दिलचस्प हिस्सा है:

'\l'$#~1/repl
         repl     replace all
'\l'              letters
    $#~           by evaluating
       1/         over one argument (otherwise, it would evaluate the "last" thingy)

यह मूल रूप से स्ट्रिंग इंटरपोलिंग है, लेकिन बिलिन की तुलना में 10 बाइट्स छोटे हैं।

Answer 10

/// , 116 बाइट्स

/[/\\\///x///*/[y\\0[ y\/\/y\\1[ y\//**********/y///s/yx//~/  /~ ss[x00
 s[x0
s[~s\\x01
x
s\\~s[x10
 s\\x1
~ ss\\x11

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

इनपुट इस प्रकार है:

/[/\\\///x/INPUT HERE!!!!!!!!//*/[y\\0[ y\/\/y\\1[ y\//**********/y///s/yx//~/  /~ ss[x00
 s[x0
s[~s\\x01
x
s\\~s[x10
 s\\x1
~ ss\\x11

एक मूल टेम्पलेट का उपयोग करके काम करता है, और जहां आवश्यक हो वहां रिक्त स्थान और वर्ण जोड़ते हैं।

बाइट की गिनती बढ़ गई क्योंकि अर्जन जोहान्सन ने महसूस किया कि इसने पहली बार रिक्ति को नहीं संभाला। लेकिन समस्या तय है।

Comments

मैंने आपको जाँचने से पहले एक संकेत दिया कि यह काम कर रहा है - लेकिन आप लंबाई के लिए रिक्ति को समायोजित नहीं कर रहे हैं। मैं इस तरह के शाब्दिक इनपुट प्रारूप के साथ ऐसा करने का एक सुसंगत तरीका नहीं देखता।

— अर्जन जोहान्सन

या रुको, यह पूरी तरह से निराशाजनक नहीं है क्योंकि वहाँ 11. की इनपुट लंबाई सीमा है

— senrrn जोहान्सन

जैसे कुछ /*/\/y0\/ y\/\/y1\/ y\//**********/y///s/yx/और फिर आप के साथ रिक्ति हो s।

— अर्जन जोहान्सन

@ GotrjanJohansen उफ़, स्पेसिंग के बारे में भूल गया ... धन्यवाद। मैं आपके कोड को उत्तर में कैसे शामिल करूंगा?

— कॉमरेड स्पार्कलपनी

एफडब्ल्यूआईडब्ल्यू /00/0|0//01/0|1//10/1|0//11/1|1//|/<\\y>//z/<y>x//<y>0/ //<y>1/ //<\\y\>///s/z/मनमानी लंबाई को संभाल सकता है।

— अर्जन जोहान्सन

Answer 11

पायथन 2 , 101,91 बाइट्स 113 बाइट्स

lambda y:'   ++/_00\n +/_0\n+/  +\\_01\n_\n+\\  +/_10\n +\\_1\n   ++\\_11'.replace('_',y).replace('+',' '*len(y))

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

इनपुट 0 की एक स्ट्रिंग है और 1 की लंबाई 1 या 2 है! वह 0,01,10 या 11 है!

+12 बाइट्स - लंबाई में दो इनपुट के लिए रिक्ति को सही किया।

Comments

आपका आउटपुट स्ट्रिंग की लंबाई के अनुसार समायोजित नहीं होता है।

— अधिकारिक

... और प्रश्न " 0 < length of input < 11" निर्दिष्ट करता है ।

— जोनाथन एलन

@officialaimm ओह यस। अभी ध्यान दिया। धन्यवाद। मेरे उत्तर को अपडेट करेगा! जोनाथन .. वह एक टाइपो था। धन्यवाद मैंने इसे सही किया।

— कीर्तन प्रभाकरन

Answer 12

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

Ｐ<³←⮌θＦ²«Ｊ³⁻×⁴ι²θＰ<²Ｉι↗Ｆ²«Ｐ⁺⁺θικ↓↓

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

Ｐ<³

/एस और \एस के बाएं जोड़े को प्रिंट करें ।

←⮌θ

वर्तमान स्थिति में सही-सही इनपुट को प्रिंट करें।

Ｆ²«

शाखाओं के माध्यम से लूप।

Ｊ³⁻×⁴ι²

शाखा की स्थिति को स्थानांतरित करें। हम ऐसा कर सकते हैं क्योंकि रूट को सही-सही मुद्रित किया गया था ताकि मध्य शाखा हमेशा एक ही निरपेक्ष स्थिति में हो।

θ

इनपुट प्रिंट करें।

Ｐ<²

का सही जोड़ी प्रिंट /और \।

Ｉι

शाखा प्रत्यय प्रिंट करें।

↗

पहले पत्ते पर जाएँ।

Ｆ²«

पत्तियों के माध्यम से लूप।

Ｐ⁺⁺θικ

इनपुट और शाखा और पत्ती प्रत्यय प्रिंट करें।

↓↓

अगले पत्ते पर जाएँ। नोट: यदि अनुगामी व्हाट्सएप स्वीकार्य था तो Ｆ²⁺⁺⁺θι궶एक बाइट को बचाएगा।