एक बाइनरी दीवार बनाएं

33

आधार 10 में सकारात्मक पूर्णांक की एक सरणी को देखते हुए, जहां n > 0, एक द्विआधारी दीवार के उनके प्रतिनिधित्व को आउटपुट करता है।

यह कैसे काम करता है?

  1. प्रत्येक संख्या को बाइनरी प्रतिनिधित्व में बदलें।
  2. पैड सबसे लंबे समय तक एक यानी की लंबाई के शून्यों प्रमुख के साथ प्रतिनिधित्व 1, 2-> 1, 10-> 01, 10।
  3. एक दीवार बनाएँ जहाँ 1s ईंटें हैं और 0s ईंटें गायब हैं।

एक दीवार पात्रों का एक खंड है जहां कोई भी मुद्रण योग्य चरित्र एक ईंट का प्रतिनिधित्व करता है और एक स्थान ( 32) एक लापता ईंट का प्रतिनिधित्व करता है। आप ईंट के लिए किसी भी पात्र का चयन कर सकते हैं, यह दीवार के पार तब तक अलग नहीं होना चाहिए जब तक कि यह सफेद स्थान का पात्र न हो। लापता ईंट का पात्र एक स्थान होना चाहिए। नीचे दिए गए उदाहरण के लिए मैंने *ईंटों का उपयोग किया है ।

उदाहरण

इनपुट:

[ 15, 7, 13, 11 ]
  1. [ 1111, 111, 1101, 1011 ]
  2. [ 1111, 0111, 1101, 1011 ]

  3. आउटपुट:

    ****
 ***
** *
* **

नियम

  • इनपुट बेस 10 में लिया जाना चाहिए, यदि आपकी भाषा अन्य आधारों को स्वीकार करती है तो आप उनका उपयोग नहीं कर सकते हैं।
  • नई लाइनों के लिए अग्रणी और अनुगामी की अनुमति है।
  • इनपुट को पूर्णांकों, अलग-अलग तर्कों या किसी उचित प्रारूप की सूची के रूप में लिया जा सकता है।
  • आउटपुट किसी भी उचित प्रारूप में हो सकता है: नई लाइन अलग स्ट्रिंग, लाइनों की सरणी, 2 डी सरणी आदि।
  • मानक खामियों को अस्वीकार कर दिया जाता है।

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

ध्यान दें कि पहले परीक्षण के मामले में सभी परतों के अंत में एक खाली ईंट है।

[ 14, 4, 6, 2 ]

*** 
 *  
 ** 
  * 

[ 1, 2, 4, 8, 16 ]

    *
   * 
  *  
 *   
*

[ 15, 11, 15, 15 ]

****
* **
****
****

[ 11, 10, 9, 8 ]

* **
* * 
*  *
*

यह कोड गोल्फ इतना कम कोड जीतता है!

code-golf  ascii-art  binary 
— TheLethalCoder
स्रोत
क्या आउटपुट लाइनों की एक सरणी या वर्णों की 2d सरणी हो सकती है?
— २१
@ovs क्षमा करें, मैंने निर्दिष्ट किया है कि, हाँ आप किसी सरणी या 2d सरणी आदि को आउटपुट कर सकते हैं।
— TheLethalCoder
2 डी सरणी के मामले में, क्या हम पात्रों के बजाय ईंटों के लिए संख्याओं का उपयोग कर सकते हैं? जैसे[[1, " ", 1, " "], ...]
— Arnauld
@ अर्नुलद हाँ जो ठीक लगता है।
— द लीथेलकोडर
1
@Giuseppe नई लाइनें केवल, अन्यथा यह खाली ईंटों के लिए भ्रमित हो जाएगा।
— TheLethalCoder

जवाबों:

13

MATL , 5 बाइट्स

B42*c

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

व्याख्या

B     % Implicitly input an array of numbers. Convert to binary. 
      % Gives a matrix with each row corresponding to a number
42    % Push 42 (ASCII code of '*')
*     % Multiply
c     % Convert to char. Char 0 is displayed as space. Implicitly display
— लुइस मेंडो
स्रोत
आप ईंट के लिए किसी भी पात्र का चयन कर सकते हैं, यह दीवार के पार तब तक अलग नहीं होना चाहिए जब तक कि यह सफेद स्थान का पात्र न हो। हाँ, इसका मतलब है कि आपको शायद ज़रूरत नहीं है 42*या कुछ और ...
— एरिक आउटगोल्फर
@EriktheOutgolfer मैं कोई अन्य नंबर चुन सकता था, लेकिन मुझे लगता है कि मुझे उन तीन बाइट्स की आवश्यकता है।
— लुइस मेंडू
क्या होगा अगर 1-बाइट बिलिन के लिए 100या किसी अन्य संख्या में हो?
— एरिक आउटगोलर
8

ऑक्टेव, 22 बाइट्स

@(x)[dec2bin(x)-16,'']

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

स्पष्टीकरण:

लुइस मेंडो के लिए धन्यवाद कुछ बाइट्स सहेजे गए! इसके अलावा, मैंने ध्यान नहीं दिया कि मैं दीवार के निर्माण के लिए किस पात्र को चुन सकता हूं, न केवल *।

@(x)                    % Take the input as a column vector
    dec2bin(x)          % Convert each row of the input to a string with 1 and 0
                        % It gets automatically padded with zeros, to fit the longest number
    dec2bin(x)-16       % Subtract 16, to get from the ASCII-values of 1/0 (48/49)
                        % to 32/33 (space and !)
@(x)[dec2bin(x)-16,'']  % Concatenate with the empty string to convert it to a string.

या साथ de2bi:

स्पष्टीकरण:

@(x)                          % Take the input as a column vector
               de2bi(x)       % Convert each row of the input to a binary number.
                              % Gets automatically padded to fit the longest number
            42*de2bi(x)       % Multiply the matrix by 42, which is the ASCII-value for *
           [42*de2bi(x),'']   % Concatenate the matrix with the empty string to convert
                              % it to a string. 0 are automatically displayed as spaces
@(x)fliplr([42*de2bi(x),''])

7 बाइट्स के लिए TIO पर निम्नलिखित काम करता है:

@(x)fliplr([42*(dec2bin(x)>48),''])

इसे यहाँ आज़माएँ

— स्टीवी ग्रिफिन
स्रोत
5

पायथन 3 , 88 84 71 74 72 बाइट्स

एक लैम्ब्डा जो स्ट्रिंग्स की एक सूची देता है, प्रत्येक पंक्ति का प्रतिनिधित्व करता है।

lambda n:[bin(x)[2:].replace(*'0 ').rjust(len(bin(max(n)))-2)for x in n]

इसे ऑनलाइन आज़माएं! (न्यूलाइन अलग संस्करण के लिए लिंक)

व्याख्या

  • lambda n:- एक (अनाम) लैम्ब्डा बनाता है, एक पैरामीटर के साथ n। निहित रूप से लौटता है।

  • [...] - एक सूची समझ पैदा करता है।

  • bin(x)[2:] - संख्याओं का द्विआधारी निरूपण करता है।

  • .replace(*'0 ')- 0एक स्थान के साथ सभी घटनाओं की जगह।

  • .rjust(len(bin(max(n)))-2) - सबसे लंबे समय तक की लंबाई के लिए बाइनरी अभ्यावेदन पैड।

  • for x in n- nचर के साथ, के माध्यम से Iterates x।

बदलाव का

  • - 1 - 3 बाइट्स @Rod, -(...)+2= 2-(...), के उपयोग के लिए धन्यवादrjust()

  • bin()इसके बजाय एक संस्करण जोड़ा गया , जो अमान्य था क्योंकि यह काम नहीं करता था 1और 2।

  • बग का उपयोग कर ऊपर फिक्स्ड format()।

  • स्ट्रिंग्स की सूची में बदले हुए प्रकार, क्योंकि यह ओपी द्वारा अनुमति दी गई थी।

  • अभी तक एक और बग का उपयोग करके rjust()और bin()@Rod द्वारा स्पॉट किया और तय किया गया है।

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

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

रिक हिचकॉक द्वारा सुझाए गए ईंटों के लिए पात्रों के बजाय संख्या का उपयोग करके 2 बाइट्स सहेजे गए

ईंटों के लिए 1 के साथ एक 2 डी सरणी देता है।

f=(a,b=[],x=1)=>a.every(n=>n<x)?a.map(n=>b.map(i=>n&i?1:' ')):f(a,[x,...b],x*2)

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

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

— Arnauld
स्रोत
4

रूबी, 63 59 बाइट्स

एलेक्सिस एंडरसन की मदद से -4 बाइट्स

->*n{puts n.map{|i|("%#{('%b'%n.max).size}b"%i).tr'0',' '}}

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

— daniero
स्रोत
1
आपको स्ट्रिंग प्रारूप में 0 की आवश्यकता नहीं है। आप को बदल कर एक बाइट दाढ़ी सकता है n.max.to_s(2).sizeके साथ ('%b'%n.max).sizeऔर आप वास्तव में बदलने के लिए की जरूरत नहीं है 1के साथ*
— एलेक्सिस एंडरसन
@AlexisAndersen धन्यवाद :)
— daniero
4

आर , 87 88 बाइट्स

दीवार ब्लॉक एक द्वारा प्रतिनिधित्व किया 8 , क्योंकि, बहुत सारे आठों ने किया है।

write(ifelse((I=sapply(scan(),intToBits))[(M=max(which(I>0,T)[,1])):1,],8,' '),1,M,,'')

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

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

कम की गई सरणी तब आउटपुट का उपयोग कर रही है write और एक कॉलम की चौड़ाई जो निर्धारित की गई थी जब सरणी को ट्रिम किया गया था।

ifelse() एकमात्र IF विकल्प है जो दुर्भाग्य से वैक्टर पर काम करता है।

— MickyT
स्रोत
@ वेलो ने बताया कि आप आउटपुट फाइल के 1बजाय उपयोग कर सकते हैं । ""write
— Giuseppe
@Giuseppe टिप के लिए धन्यवाद
— मिकी
3

एपीएल (डायलॉग) , 30 22 20 14 बाइट्स

सहेजे गए 6 बाइट्स @ Adám की बदौलत

' *'[⍉2⊥⍣¯1⊢⎕]

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

(मान लिया गया है ⎕IO←0 कि यह कई मशीनों पर डिफ़ॉल्ट है)

यह एक सरणी के रूप में इनपुट लेता है और *एस के साथ एक मैट्रिक्स लौटाता है एस के ।

व्याख्या

2⊥⍣¯1⊢⎕       Convert input to binary (returns a transposed matrix of 1s and 0s)
⍉              Transpose
' *'[ ... ]    Index into this string
— क्रिकटी लिथोस
स्रोत
6 बाइट्स बचाएं' *'[⍉2⊥⍣¯1⊢⎕]
— Adám
@ Adám सुझावों के लिए धन्यवाद, मुझे नहीं पता था कि मैं इसे हटा सकता हूं ¨।
— क्रिति लिथोस
3

टी-एसक्यूएल, 290 बाइट्स

declare @ int;select @=max(log(a,2))+1from @i;with t as(select convert(varchar(max),a%2)b,a/2c,@-1m,ROW_NUMBER()over(order by(select 1))r from @i union all select convert(varchar(max),concat(c%2,b))b,c/2c,m-1,r from t where m>0)select replace(b,0,' ')from t where m=0group by r,b order by r

1ईंट के टुकड़े के लिए उपयोग , मान लिया गया है कि तालिका से इनपुट आता है@

कुछ स्पष्टीकरण के साथ, अपुष्ट

-- assume input is presented in an input table
declare @input table (a int)
insert into @input values (15), (7), (13), (11)

---- start here

-- figure out how many characters are needed, by taking log2
declare @max int
select @max = max(log(a, 2)) + 1
from @input

-- recursive cte
-- will join against itself, recursively finding each digit in the binary string
;with cte as
(
    select 
        convert(varchar(max), a % 2) as b, -- is the least significant bit 1 or 0
        a / 2 as c, -- remove least significant bit, for the next run
        @max - 1 as max, -- keep track of iterations left
        ROW_NUMBER() over (order by (select 1)) as rn -- keep the order of the input
    from @input

    union all -- recursive loop
              -- below columns follow the same pattern

    select convert(varchar(max), 
        concat(cte.c % 2, cte.b)) as b, -- prepend the current binary string with the newest least significant bit
        cte.c / 2 as c, 
        cte.max - 1, 
        cte.rn
    from cte
    where cte.max > 0
)
select replace(b, 0, ' ') -- swap 0s for space
from cte
where max = 0 -- only take the last iteration
group by rn, b -- grab each unique input, 
               -- need to group by row number so it can be ordered by
               -- need to group by binary string, so it can be selected
order by rn -- sort by the order the input arrived in
— ब्रायन जे
स्रोत
3

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

Grid@PadLeft@IntegerDigits[#,2]/. 0->""&

ईंटें 1s हैं

मैथेमेटिका, 48 बाइट्स

Grid@PadLeft@IntegerDigits[#,2]/.{0->"",1->"#"}&

ईंटें # हैं

— J42161217
स्रोत
आपको केवल एक स्लैश चाहिए //.। ( /.इसका अर्थ है "एक बार बदलें", का //.अर्थ है "प्रतिस्थापन को तब तक करते रहें जब तक कि चीज़ बदलना बंद न हो जाए।"
— एक पेड़ नहीं
ठीक-ठीक-धन्यवाद
— J42161217
IntegerDigits फ़ंक्शन में अल्पविराम के बाद आपको स्थान की आवश्यकता नहीं है।
— मार्क एस।
हाँ, मुझे पता है, यह तब होता है जब आप नोटबुक से कॉपी / पेस्ट करते हैं।
— उपर
2

सी # (.NET कोर) , 112 + 18 = 130 86 + 41 = 127 बाइट्स

a=>a.Select(n=>C.ToString(n,2).Replace("0"," ").PadLeft(C.ToString(a.Max(),2).Length))

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

बाइट काउंट में 41 बाइट्स शामिल हैं using System.Linq;using C=System.Convert;। 1दीवार के लिए चरित्र के रूप में उपयोग करता है । बहरहाल, यह C # के लिए बहुत लंबा रास्ता है ...

— चार्ली
स्रोत
namespace System.Linq{}कुछ बाइट बचाने के लिए जगह । है a.Max()सच होने की गारंटी (: पी मुझे यकीन है कि यह है मैं सिर्फ द्विआधारी साथ होशियार नहीं हूँ हूँ)? चाहेंगे class Convert{}किसी भी बाइट्स बचाने?
— TheLethalCoder
1
यदि मैं किसी दिए गए नाम स्थान पर कार्यक्रम रखता हूं, तो क्या मुझे सिर्फ एक मेमने के बजाय पूरे कार्यक्रम को प्रस्तुत नहीं करना चाहिए? मुझे उस नियम पर यकीन नहीं है ...
— चार्ली
मैं आमतौर पर सिर्फ नाममात्र के साथ मेमने के साथ रखा जाता हूं। मुझे नहीं लगता कि इसके बारे में कभी कोई सवाल आया है और यह C # टिप्स पेज में है।
— TheLethalCoder
मुझे नहीं लगता कि यह मान्य है, क्योंकि आप इसे स्थिर आयात का उपयोग किए बिना संकलित नहीं कर सकते।
— मेटाकॉलन
2
@ मीता कोलोन यही कारण है कि मैंने using System.Linq;using C=System.Convert;बाइट को बाइट की गिनती में जोड़ा , क्योंकि usingकोड को संकलित करने के लिए उन दो निर्देशों की आवश्यकता होती है।
— चार्ली
2

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

.+
$*#<
+`(#+)\1
$1 
 #
#
{T`<`_`^(<.+(¶|$))+$
m`^<
 <
(.)<
<$1

इसे ऑनलाइन आज़माएं! स्पष्टीकरण:

.+
$*#<

एकरी में रूपांतरित करें और एक प्रत्यय <।

+`(#+)\1
$1 
 #
#

बाइनरी में कनवर्ट करें।

{T`<`_`^(<.+(¶|$))+$

एक बार जब सभी <बाईं ओर पहुंच गए, तो उन सभी को हटा दें।

m`^<
 <

किसी भी <एस से पहले एक जगह डालें जो पहले से ही बाईं ओर पहुंच चुके हैं।

(.)<
<$1

सभी <चरणों को एक कदम छोड़ दें। धोये और दोहराएं।

— नील
स्रोत
2

शक्ति कोशिका , 100 बाइट्स

$args|%{if(($c=($a=[convert]::ToString($_,2)).length)-gt$l){$l=$c}$a-replace0,' '}|%{$_.padleft($l)}

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

ऊग, convertपॉवरशेल में बाइनरी के लिए आईएनजी इतना दर्दनाक है। साथ ही .lengthy को कॉल करता -replaceहै0 रिक्त स्थान साथ साथ .padLeft()ही उन सभी को समान बनाने के लिए एक लंबी कॉल.length , सभी एक लंबे सबमिशन तक जोड़ता है।

100 से नीचे आने के गोल्फिंग सुझावों का स्वागत है।

— AdmBorkBork
स्रोत
2

PHP, 84 बाइट्स

while(++$i<$argc)echo strtr(sprintf("\n%".-~log(max($argv),2).b,$argv[$i]),10,"* ");

सौभाग्य से, बिट ऑपरेशन कास्ट करता है log इंट परिणाम देता है। यहाँ काम नहीं करेगा।

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

— टाइटस
स्रोत
2

क्लोजर, 185 बाइट्स

(fn[i](let[b(map #(Long/toBinaryString %)i)](map #(clojure.string/replace(clojure.string/replace(format(str"%0"(reduce(fn[l i](max l(count i)))0 b)"d")(read-string %))"1""#")"0"" ")b)))

Ungolfed संस्करण:

(fn [i]
    (let [b (map #(Long/toBinaryString %) i)]
        (map
            #(clojure.string/replace
                (clojure.string/replace
                    (format
                        (str "%0"
                            (reduce
                                (fn [l i] (max l(count i))) 0 b)
                            "d")
                        (read-string %))
                        "1"
                        "#")
                "0"
                " ")
        b)))

अनाम फ़ंक्शन जो सूची के रूप में तर्क लेता है। सूची के रूप में लाइनें लौटाता है।

अन्य उत्तरों को पढ़ना, मुझे यकीन है कि यह छोटा हो सकता है। clojure.string/replaceलिखने के लिए एक अश्लील राशि लेता है।

— यहोशू
स्रोत
2

जाप , 33 30 बाइट्स

¡'0p(¡X¤lÃn o)-X¤l)+X¤)£" *"gX

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

सहेजे गए 3 बाइट्स के लिए धन्यवाद @Justin मेरिनर के बचा

व्याख्या

¡                              // map input integers
    (¡X¤lÃn o)                 // longest binary string length
              -X¤l)            // minus current binary string length
 '0p                           // repeat zero
                   +X¤)        // concat with current binary string
                       £       // map chars of binary string
                        " *"gX // swap 0 and 1 with ' ' and '*'
— powelles
स्रोत
आप अंतिम 3 वर्णों को केवल स्ट्रिंग के एक सरणी को वापस करने के लिए छोड़ सकते हैं, और -Rन्यूलाइन में शामिल आउटपुट को देखने के लिए ध्वज (बाइट संख्या में नहीं जोड़ा गया) का उपयोग कर सकते हैं: यहां ।
— जस्टिन मेरिनर
2

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

lambda a:[' '*(len(bin(max(a)))-len(i)-2)+i for i in[bin(i)[2:].replace(*'0 ')for i in a]]

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

लाइनों की एक सूची देता है। उन्हें स्टैक करना दिखाता है कि वे वास्तव में ठीक से संरेखित करते हैं।

['111 ', ' 1  ', ' 11 ', '  1 ']
>>>
 111 
  1  
  11 
   1

विभाजन

आवश्यक रूप से सरणी को बाइनरी में कनवर्ट करता है, फिर सभी 0 के स्थान के साथ बदलता है। Nप्रत्येक पंक्ति के सामने स्थान की संख्या जोड़ी जाती है जहांN = [length of longest line] - [length of line] ।

-1 bytes श्री Xoder को धन्यवाद

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

— Graviton
स्रोत
आपके पास आउटपुट में अग्रणी या अनुगामी स्थान नहीं हो सकता है।
— लीथलॉकर
@TheLethalCoder ओह, नियमों को गलत समझना चाहिए! उस पकड़ने के लिए धन्यवाद।
— ग्रेविटन
90 बाइट्स , के '0',' 'साथ बदलें *'0 '।
— मिस्टर एक्सकोडर
@ Mr.Xcoder आह दिलचस्प, उस बारे में कभी नहीं सोचा होगा। धन्यवाद!
— Graviton
2

जाप , 11 बाइट्स

m¤z3 z ·r0S

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

व्याख्या

m¤z3 z ·r0S  Implicit input of array
m¤           Map the array to binary strings
  z3 z       Rotate right 270° and then right 90°. This adds left padding to each string
       ·r0S  Join with newlines and replace 0s with spaces
— जस्टिन मेरिनर
स्रोत
के साथ अच्छा शोषण z3 z। यकीन नहीं होता कि y yवहां काम क्यों नहीं होता, मैं बाद में इस पर गौर करूंगा ...
— ETHproductions
2

जावा 7, 130 108 88 बाइट्स

22 धन्यवाद @ @LethalCoder के लिए 20 धन्यवाद @Xanderhall के लिए सहेजा गया

void a(int[]b){for(int i:b)System.out.println(Long.toBinaryString(i).replace('0',' '));}

Ungolfed:

void a(int[]b){
    for(int i:b)
        System.out.println(Long.toBinaryString(i).replace('0', ' '));       
}
— जावा गोंजर
स्रोत
1
पोस्ट वेतन वृद्धि iपर b[i]एक बाइट को बचाने के लिए। तुम उत्पादन के साथ रख सकते हैं 1तो कोई ज़रूरत नहीं है के लिए .replace('1','*')। बजाय जावा 8 का उपयोग करें और बाइट्स को बचाने के लिए एक लैम्ब्डा के लिए संकलन करें। यदि आप ऐसा नहीं करना चाहते हैं जो int[]bएक बाइट बचाता है।
— द लीथेलकोडर
धन्यवाद! क्या आप बता सकते हैं कि बाइट को बचाने के लिए मैं किस पद को बढ़ाता हूं [ख]। माध्यम?
— जावा गोंजेर
i++iतब मूल्यांकन ++iकरता है कि यह वृद्धि करता है (जबकि विपरीत होता है) ताकि आप लूप से i++बाहर निकल सकें forऔर b[i++]इसके बजाय उपयोग कर सकें । ओह, और जब हम उस पर होते हैं तो आपके लूप के अंदर एक ही लाइन होती है ताकि ब्रेस की जरूरत न पड़े।
— द लीथलकोडर
सच! कमाल है, शुक्रिया
— जावा गोंजेर
2
आप अपने लूप को एक फॉर्च लूप में बदलकर कुछ बाइट्स बचा सकते हैं। for(int x:i)इसके अलावा, आप Long.toBinaryString3 बाइट्स को बचाने के लिए इंटेगर संस्करण के बजाय उपयोग कर सकते हैं ।
— Xanderhall
1

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

2 घंटे की कोडिंग के बाद मैंने फैसला किया, कि इसके लिए सुन्न बुरा विचार है

import numpy as n
i=n.loadtxt("i")
o=[n.copy(i)]
o[0].fill(10)
while n.count_nonzero(i)>0:
 o.append(i%2+32)
 i=n.vectorize(lambda x:x//2)(i)
print n.fliplr(n.array(o).T).astype('uint8').view('c').tostring().decode()

उबंटू में उपयोग

सुन्न स्थापित करें

python2 -m pip install numpy

नाम से फ़ाइल बनाएँ iप्रारूप में इनपुट के साथ14 4 6 2

रन

python2 prog.py
— Оввгений Новиков
स्रोत
1

8 वें , 232 254 250 बाइट्स

कोड

0 >r a:new swap ( nip 2 base drop >s decimal s:len r> n:max >r a:push ) a:each drop a:new swap ( nip '0 G:c# r@ G:#> s:fmt a:push ) a:each drop rdrop a:new swap ( nip /0/ " " s:replace! a:push ) a:each drop ( nip /1/ "*" s:replace! . cr ) a:each drop

टिप्पणियों के साथ अनप्लग्ड संस्करण

\ convert to binary and save longest string length
: f 0 >r a:new swap ( nip 2 base drop >s decimal s:len r> n:max >r a:push ) a:each drop ;

\ pad binary number with zero
: f1 a:new swap ( nip '0 G:c# r@ G:#> s:fmt a:push ) a:each drop rdrop ;

\ replace every 0 with space
: f2 a:new swap ( nip /0/ " " s:replace! a:push ) a:each drop ;

\ replace every 1 with * and print each line of bricks
: f3 ( nip /1/ "*" s:replace! . cr ) a:each drop ;

इन शब्दों को अनुक्रम में लागू किया जाना चाहिए (उदाहरण देखें)

उपयोग और उदाहरण

ok> [15,7,13,11] 0 >r a:new swap ( nip 2 base drop >s decimal s:len r> n:max >r a:push ) a:each drop a:new swap ( nip '0 G:c# r@ G:#> s:fmt a:push ) a:each drop rdrop a:new swap ( nip /0/ " " s:replace! a:push ) a:each drop ( nip /1/ "*" s:replace! . cr ) a:each drop
****
 ***
** *
* **

या अधिक स्पष्ट रूप से

ok> [15,11,15,15] f f1 f2 f3
****
* **
****
****
— अराजकता मनोर
स्रोत
1

एक्सेल VBA, 170 161 बाइट्स

golfed

बेनामी VBE तत्काल विंडो फ़ंक्शन जो 1 2 3 .. nरेंज से प्रारूप का इनपुट लेता है [A1]और संबंधित द्विआधारी दीवार को VBE तत्काल विंडो रेंज के माध्यम से आउटपुट करता है[B1,C1,2:2]

n=Split([A1]):[A2].Resize(1,UBound(n)+1)=n:[C1]="=Int(1+Log(B1,2))":For Each i In n:[B1]=i:?Replace(Replace([Right(Rept(0,C1)&Dec2Bin(B1),C1)],1,"*"),0," "):Next

प्रारूपित:

n=Split([A1])
[A2].Resize(1,UBound(n)+1)=n
[C1]="=Int(1+Log(B1,2))"
For Each i In n
[B1]=i
?Replace(Replace([Right(Rept(0,C1)&Dec2Bin(B1),C1)],1,"*"),0," ")
Next

Ungolfed

पूर्ण Subदिनचर्या जो प्रारूप का इनपुट लेती है Array(1, 2, 3...)और संबंधित बाइनरी दीवार को रेंज के माध्यम से VBE तत्काल विंडो में आउटपुट करती है[A1,B1,2:2]

Sub a(ByRef n As Variant)
    Let Range("A1").Resize(1,UBound(n)+1) = n
    Let Range("C1").Value = "=Int(1+Log(A1,2))"
    Dim i As Integer
    For Each i In n
        Let Range("A1").Value = i
        Debug.Print Replace(
                            Replace(
                                    [Right( Rept( 0, C1) & Dec2Bin( B1), C1)],
                                    1,
                                    "*"
                            ),
                            0,
                            " "
                    )
    Next
End Sub
— टेलर स्कॉट
स्रोत
1

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

ＷＳ«⸿≔ＩιιＷι«←§ *ι≧÷²ι

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। प्रत्येक इनपुट नंबर को बाइनरी में मैन्युअल रूप से परिवर्तित करके काम करता है लेकिन इसे दाएं-से-बाएं क्रम में प्रिंट करता है। मैं इनपुट को न्यूलाइन टर्मिनेटेड स्ट्रिंग के रूप में लेता हूं क्योंकि चारकोल के पास सूचियों को इनपुट करने का एक अच्छा तरीका नहीं है अन्यथा मैं कुछ ऐसा लिखूंगा जो दुर्भाग्य से वर्तमान में 21 बाइट लेता है:

ＷＳ⊞υＩιＷ⌈υ«Ｅυ﹪κ²↓⸿≧÷²υ

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। यह संस्करण इनपुट सरणी पर वेक्टर करता है, हालांकि इसका आउटपुट एस को हार्डकोड किया गया है -जो बाइट बचाता है।

— नील
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.