एक संख्या से एक बाइनरी पथ आउटपुट

22

पूर्णांक के लिए nजो संतुष्ट करता है n > 0, इसके मूल्य को द्विआधारी प्रतिनिधित्व के आधार पर एक सही-अवरोही पथ के रूप में लिखें।

नियम

  • पहला (सबसे महत्वपूर्ण) सेट बिट हमेशा ऊपरी-बाएँ कोने में होता है।
  • जब अगला बिट सेट हो जाता है (ए 1), तो पिछले पंक्ति में खींचे गए चरित्र के समान कॉलम में अगली पंक्ति पर एक वर्ण ("भरा हुआ") खींचें। भरने के लिए रिक्त स्थान ("खाली") का उपयोग करने का प्रयास करें, लेकिन कोई भी चरित्र तब तक करेगा जब तक वह हमेशा एक ही हो।
  • जब अगला बिट अनसेट (a 0) हो, तो उसी वर्ण पर एक वर्ण ("भरा हुआ") खींचिए जो पिछले खींचे गए अक्षर के दाईं ओर है।
  • आपके कोड को कम से कम 20 महत्वपूर्ण बिट्स के साथ संख्याओं का समर्थन करना चाहिए।
  • एक पूर्ण कार्यक्रम, एक फ़ंक्शन, एक लैम्ब्डा, आदि लिखें, लेकिन कोई स्निपेट नहीं।
  • कोई अग्रणी स्थान (या "खाली" चार) / लाइनों की अनुमति नहीं है
  • अनुगामी रिक्त स्थान की कोई संख्या (या "रिक्त" वर्ण) / लाइनें अनुमत हैं
  • किसी भी तरह के 1 डी इनपुट को स्वीकार किया जाता है: संख्या, स्ट्रिंग, बूलियन की सरणी आदि। हालांकि बिट्स के क्रम को अछूता रखें।
  • किसी भी तरह के दृश्य 2 डी आउटपुट को स्वीकार किया जाता है: स्टैडआउट पर, एक स्ट्रिंग ("भरे हुए" और "खाली" का प्रतिनिधित्व करने वाले किसी भी दो अलग-अलग मूल्यों के साथ), आप चाहें तो एक मैट्रिक्स भी आउटपुट कर सकते हैं। संख्याओं की एक सूची "नो हेडिंग स्पेस" नियम के साथ सामंजस्य स्थापित करना कठिन लगता है, लेकिन अगर आप इसका उपयोग करने का कोई तरीका ढूंढते हैं तो मैं इसके लिए खुला हूं। नोट: यदि आपने एक स्ट्रिंग को प्रिंट या वापस करने का विकल्प चुना है, तो उपयोग किए जाने वाले अक्षर कोडपॉइंट रेंज में ASCII वर्ण [32-126] होना चाहिए।
  • मानक खामियों पर रोक लगाई जाती है।
  • यह कोडगोल्फ है इसलिए सबसे छोटा कोड जीतता है।

उदाहरण

इनपुट: १

*

इनपुट: २

**

इनपुट: ३

*
*

इनपुट: ४

***

इनपुट: ५

**
 *

इनपुट: ६

*
**

इनपुट: 7

*
*
*

इनपुट: २५

*
***
  *

इनपुट: 699050

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

इनपुट: 1047552

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

इनपुट: 525311

**********
         *
         *
         *
         *
         *
         *
         *
         *
         *
         *
code-golf  number 
— ओलिवियर ग्रेजायर
स्रोत
— ओलिवियर ग्रेजायर
क्या "बूलियन्स के इनपुट एरे को अनुमति दी गई" का अर्थ है कि एरे की अनुमति के रूप में संख्या के बाइनरी प्रतिनिधित्व के रूप में इनपुट लेना है?
— नाइट
3
@ किसी भी तरह का 1D इनपुट न करें। इसलिए यदि संख्या 5 है, तो आपके पास इनपुट सरणी समान हो सकती है [1,0,1], हाँ।
— ओलिवियर ग्रेगोइरे
तो वह प्रारूप वास्तव में कितना स्वतंत्र है? मैं एक संख्या को बाइनरी अंकों के रूप में लेना चाहता हूं क्योंकि पहले 1 के अंत तक ले जाया गया था, इसलिए जब 9से 1001मैं चाहूंगा कि मेरा इनपुट हो 0011। क्या वह ठीक है?
— टन हास्पेल
पहले बिट होने के बाद पहली 1चुनौती का हिस्सा है, और (फिर से) कि बिट चुनौती चुनौती दे रहा होगा ताकि मुझे डर है कि मैं तुम्हें नहीं कहना होगा, @TonHospel। आप इसे प्रोग्राम में अपने इनपुट से हटा सकते हैं, हालांकि।
— ओलिवियर ग्रेजायर

जवाबों:

7

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

¬œṗ+\Ṭz0

एक monadic लिंक वाले और शून्य की एक सूची के रूप में एक संख्या को स्वीकार करने (जैसे 13है [1,1,0,1]) लोगों को और शून्य की सूची की एक सूची लौट जहां पहली सूची पहली पंक्ति है।

इसे ऑनलाइन आज़माएं! या एक स्वरूपित परीक्षण-सूट देखें

कैसे?

¬œṗ+\Ṭz0 - Link: list L           e.g. [1,1,0,0,1,1,0,1] (i.e. 205)
¬        - logical NOT L               [0,0,1,1,0,0,1,0]
    \    - cumulative reduce L by:
   +     -   addition                  [1,2,2,2,3,4,4,5]
 œṗ      - partition @ truthy indices  [[1,2],[2],[2,3,4],[4,5]]
     Ṭ   - un-truth (vectorises)       [[1,1],[0,1],[0,1,1,1],[0,0,0,1,1]]
      z0 - transpose with filler 0     [[1,0,0,0],[1,1,1,0],[0,0,1,0],[0,0,1,1],[0,0,0,1]]
         -                        i.e.  1000
                                        1110
                                        0010
                                        0011
                                        0001
— जोनाथन एलन
स्रोत
11

MATL , 14 बाइट्स

J_iB^YsJ+'o-'&XG

निर्देशांक (0,0) पर शुरू होने वाले पथ के रूप में ग्राफिकल आउटपुट का उत्पादन करता है। MATL ऑनलाइन पर यह कोशिश करो ! या नीचे कुछ ऑफ़लाइन उदाहरण देखें:

  • इनपुट 7:

    यहां छवि विवरण दर्ज करें

    आउटपुट:

    यहां छवि विवरण दर्ज करें

  • इनपुट 699050:

    यहां छवि विवरण दर्ज करें

    आउटपुट:

    यहां छवि विवरण दर्ज करें

यदि आप चाहें, तो आप 9 बाइट्स के लिए जटिल निर्देशांक के रूप में पथ देख सकते हैं :

J_iB^YsJ+

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

व्याख्या

J_      % Push -1j (minus imaginary unit)
i       % Push input number
B       % Convert to binary. Gives an array of 0 and 1 digits
^       % Power, element-wise. A 0 digit gives 1, a 1 digit gives -1j
Ys      % Cumulative sum. Produces the path in the complex plane
J+      % Add 1j, element-wise. This makes the complex path start at 0
'o-'    % Push this string, which defines plot makers
&XG     % Plot
— लुइस मेंडो
स्रोत
7

Matl , 10 बाइट्स

YsG~YsQ1Z?

बाइनरी अंकों की एक सरणी इनपुट। एक मैट्रिक्स आउटपुट।

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

व्याख्या

Ys    % Implicit input: array of binary digits. Cumulative sum. This gives the
      % row coordinates
G     % Push input again
~     % Negate: change 0 to 1 and 1 to 0
Ys    % Cumulative sum
Q     % Add 1. This gives the column coordinates
1Z?   % Matrix containing 1 at those row and column coordinates and 0 otherwise.
      % Implicit display
— लुइस मेंडो
स्रोत
6

चारकोल , 22 20 19 11 10 बाइट्स

Ｆ⮌Ｓ¿Ｉι↑*←*

केवल मेरा दूसरा चारकोल उत्तर इस प्रकार अब तक।

इनपुट को बाइनरी-स्ट्रिंग (जैसे 699050कि 10101010101010101010) के रूप में लेता है ।

-9 बाइट्स के लिए धन्यवाद @Neil को पीछे की तरफ लूप देने का सुझाव।

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

स्पष्टीकरण:

उल्टे क्रम में स्ट्रिंग के रूप में STDIN पढ़ें:

Reverse(InputString())
⮌Ｓ

तार के रूप में अपने द्विआधारी अंकों पर लूप करें ι:

For(Reverse(InputString()))
Ｆ⮌Ｓ

यदि ιकिसी संख्या पर वापस जाती है 1, तो *ऊपर की ओर प्रिंट करें , अन्यथा *बाईं ओर प्रिंट करें ।

If(Cast(i)) Print(:Up,"*"); Else Print(:Left,"*");
¿Ｉι↑*←*
— केविन क्रूज़सेन
स्रोत
1
यह तब तक आधा होगा जब आप स्ट्रिंग को रिवर्स में प्रिंट करते हैं, अंत में शुरू करते हैं और काम करते हैं और छोड़ देते हैं।
— नील
@ नील ओके, अब इसे ठीक किया जाना चाहिए। धन्यवाद! -8 बाइट्स
— केविन क्रूज़सेन
1
{}एस हटाकर एक और बाइट बचाएं ।
— नील
1
Baseकेवल लागत 1 बाइट आप की जरूरत नहीं है के रूप में Castसभी एक ही: Ｆ⮌↨Ｎ²¿ι↑*←*।
— नील
1
@KevinCruijssen देर से जवाब के लिए क्षमा करें, लेकिन आपके सवालों का जवाब देने के लिए: कोई उल्टा नहीं है -v, क्योंकि चारकोल को एक गोल्फ भाषा के रूप में डिज़ाइन किया गया था, और मैंने इसे टाइप करने और समझने में आसान बनाने के लिए वर्बोज़ मोड जोड़ा। (यदि आप चाहें तो एक जोड़ सकते हैं)। -aके लिए कम है --ast, मैंने इसे (PyTek btw से लिया गया प्रारूप) जोड़ा है ताकि मुझे यथासंभव कम प्रयास के साथ सक्सेज कोड को समझने में मदद मिल सके: P (और यह वास्तव में मदद करता है जब आपने गलती से तर्क क्रम गड़बड़ कर दिया हो)। इसके अलावा, यह -lएक अलग विकल्प नहीं है। ( -hकमांड लाइन आर्ग्स के विवरणों पर सहायता के लिए भी करें )
— केवल
6

सी # (.NET कोर) , 155 123 120 113 101 बाइट्स

सहेजे गए 32 बाइट्स इनपुट के कारण बिट्स के एक सरणी के रूप में प्राप्त करने में सक्षम हैं।
@ बहीमान के लिए 7 बाइट्स से बचा।
सहेजे गए 10 बाइट @KevinCruijssen की बदौलत।

n=>{var m="";for(int i=0,c=1;i<n.Length;)m+=n[i++]<1?c++%1+"":(i>1?"\n":"")+"0".PadLeft(c);return m;}

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

— इयान एच।
स्रोत
आप (7 बाइट्स बचाता है) +new string(' ',c)+"*"को बदल नहीं सकते हैं +"*".PadLeft(c)?
— अनुहाम
@ गौमन तुम सही हो, धन्यवाद!
— इयान एच।
-4 मुद्रण द्वारा बाइट्स 0के बजाय *: if(n[i++]<1){m+="*";c++;}करने के लिए if(n[i++]<1)m+=c++%1;और "*".PadLeft(c);करने के लिए"0".PadLeft(c);
— केविन Cruijssen
सुधार, यह वास्तव में -12 बाइट्स है क्योंकि m+=अब एक टर्नरी हो सकता है-यदि:m+=n[i++]<1?c++%1+"":(i>1?"\n":"")+"0".PadLeft(c);
— केविन क्रूज़सेन
1
@KevinCruijssen धन्यवाद, टेनेरी 0ऑपरेटर का उपयोग वास्तव में स्मार्ट है! मैंने भी मामले को तय कर दिया 699060, बस cएक शुरुआत के लिए सेट करके , मैंने परीक्षण के मामलों की जांच करते समय याद किया।
— इयान एच।
5

05AB1E , 18 17 14 बाइट्स

γ€gć¸s>«1IÔ·ÌΛ

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

व्याख्या

γ€g             # Push the input as the array as chuncks of consecutive elements, map with length
   ć¸s>«        # Increment each value except the first one
        1I      # Push 1 and the input       
          Ô     # Push connected uniquified input (first elements of each chunck of consecutive elements in the input)
           ·Ì   # Map each with 2 * a + 2
             Λ  # Draw canvas :-)
  • 3 बाइट्स @Eignign के लिए धन्यवाद

05AB1E कैनवास की व्याख्या

— Kaldo
स्रोत
1
γ€gć¸s>«1IÔ·ÌΛ4 बाइट बचाना चाहिए।
— एमिगा
@Eigna शानदार, धन्यवाद! पूरी तरह से भूल गए कि वहाँ एक + 2 बिलियन ओ था:
— कलडो
3

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

f(a:b)|a="*":f b|(x:y)<-f b=('*':x):map(' ':)y
f[]=["*"]
f.tail

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

बुलियन की सूची के रूप में इनपुट लेता है।

करी PAKCS, 70 बाइट्स

u(a:b)=('*':a):map(' ':)b
f(a:b)|a="*":f b|1>0=u$f b
f[]=["*"]
f .tail

पोर्ट ऑफ हास्केल उत्तर, लेकिन क्योंकि <-करी में काम नहीं करता है इसलिए हमें एक सहायक कार्य करने की आवश्यकता है u। हमें बीच में एक स्थान भी जोड़ना होगाf और के. ताकि करी डॉट के बजाय कंपोज़ के रूप में इसे तैयार कर सके।

यह MCC करी में भी काम करता है, लेकिन स्लॉथ करी में काम नहीं करता है (जो केवल TIO द्वारा समर्थित है)।

— गेहूं का जादूगर
स्रोत
3

हास्केल , 74 70 67 62 बाइट्स

tail.("\n"%)
s%(x:r)=([1..x]>>s)++'*':(s++[' '|x<1])%r
s%[]=""

इसे ऑनलाइन आज़माएं! इनपुट के रूप में शून्य और लोगों की एक सूची लेता है और एक नई पंक्ति अलग स्ट्रिंग लौटाता है।

Xnor के जवाब से प्रेरित ।

— Laikoni
स्रोत
1
— गेहूं जादूगर
1
@ user56656 आपकी बारी फिर से :)
— लैकोनी
3

इमोजीकोड , 251 बाइट्स

🐖🎅🏿🍇🍦b🔡🐕2🍦c🔤*🔤🍮e🔤🔤🍮y🔤🔤🍦k🍡b🔂i k🍇🍊😛🔡i🔤1🔤🍇🍊😛y e🍇🍉🍓🍇😀y🍉🍮y🔤🔤🍮y🍪e c🍪🍉🍓🍇🍮y🍪y c🍪🍮e🍪🔤 🔤 e🍪🍉🍉😀y🍉

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

यह निश्चित रूप से एक गोल्फ समाधान नहीं है, लेकिन एक व्यक्ति जीवित नहीं है जो इमोजी-कोड को एक गोल्फ भाषा पर विचार करेगा। हालाँकि, अपने आप को उन भयावहताओं के अधीन करने की प्रक्रिया में, जो किसी भाषा में खुद को सिखाने के लिए इमोर-कोड के वाक्य-विन्यास में एक ख़ुशबू रखते हैं, मुझे बस इस बात से सुखद आश्चर्य हुआ है कि यह कितना शक्तिशाली और कुशल हो सकता है of

explaination:

🐋 🚂 🍇    👴 Define Class
🐖🎅🏿🍇    👴 Define Method
🍦b🔡🐕2    👴Convert Input integer to binary string
🍦c🔤*🔤    👴 asterisk string
🍮e🔤🔤    👴 Spacing string
🍮y🔤🔤    👴 output string
🍦k🍡b    👴 translate to iteratable
🔂i k🍇    👴 for-in loop to iterate over each digit 
🍊😛🔡i🔤1🔤🍇    👴 if digit is 1:
🍊😛y e🍇🍉    👴 don't print initial newline
🍓🍇😀y🍉    👴 print spaces + asterisks
🍮y🔤🔤    👴 reset output string
🍮y🍪e c🍪🍉    👴 add correct number of spaces and one asterisk
🍓🍇    👴 if digit is 0:
🍮y🍪y c🍪    👴 add an asterisk to the output string
🍮e🍪🔤 🔤 e🍪    👴 add another space to the space string
🍉🍉
😀y    👴 print one last output string
🍉🍉
🏁🍇    👴 Start Program
 🎅🏿 699050    👴 Call Method
🍉
— X1M4L
स्रोत
2

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

उसी I / O प्रारूप और नीचे दिए गए पुनरावर्ती संस्करण के समान तर्क।

a=>a.map((n,i)=>n?i&&p+0:+(p+=' '),p=`
`).join``

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

या 42 बाइट्स अगर यह प्रारूप स्वीकार्य है।

पुनरावर्ती संस्करण, 56 बाइट्स

पूर्णांक के एक सरणी के रूप में इनपुट लेता है (0 या 1)। 0खाली के लिए भरा और स्थान के लिए उपयोग करता है ।

f=([n,...a],p=`
`,x=0)=>1/n?(n?x+0:+(p+=' '))+f(a,p,p):a

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

टिप्पणी की गई

f = (               // f = recursive function taking:
  [n, ...a],        //   n = current bit; a[] = remaining bits
  p = `\n`,         //   p = padding string, initialized to a linefeed
  x = 0             //   x = 0 on the 1st iteration / equal to p after that
) =>                //
  1 / n ?           // if n is defined:
    ( n ?           //   if n = 1:
        x + 0       //     append x + 0 --> either the integer 0 on the first iteration
                    //                      or the padding string followed by a '0'
      :             //   else:
        +(          //     append the integer 0 (whitespace coerced to a number)
          p += ' '  //     and append a space to the padding string
        )           //
    ) + f(a, p, p)  //   append the result of a recursive call with x = p
  :                 // else:
    a               //   append the empty array a[], forcing coercion to a string
— Arnauld
स्रोत
2

बैश + जीएनयू उपयोगिताओं, 38

dc -e?2op|sed 's/\B1/^K^H*/g;s/[10]/*/g'

यहाँ ^Kऔर ^Hशाब्दिक ऊर्ध्वाधर-टैब और बैकस्पेस नियंत्रण वर्ण हैं। ये ब्राउज़र पर अच्छी तरह से प्रस्तुत नहीं करते हैं, इसलिए इस स्क्रिप्ट को इस प्रकार बनाया जा सकता है:

base64 -d <<< ZGMgLWU/Mm9wfHNlZCAncy9cQjEvCwgqL2c7cy9bMTBdLyovZyc= > binpath.sh

एक टर्मिनल में चलाएं। इनपुट STDIN के माध्यम से है।

यह उत्तर विशिष्टताओं को बहुत दूर तक ले जा सकता है - वास्तव में आउटपुट की प्रत्येक पंक्ति पर कोई अग्रणी वर्ण नहीं हैं - सभी स्थिति नियंत्रण वर्णों के साथ की जाती हैं। यदि यह बहुत अधिक खिंचाव है, तो आउटपुट को |col -x|tacअतिरिक्त 11 बाइट्स के लिए पाइप किया जा सकता है ।

— डिजिटल आघात
स्रोत
2

बैच, 113 बाइट्स

@set s=
:l
@shift
@if %1.==0. set s=%s%+&goto l
@echo %s%+
@if not %s%.==. set s=%s:+= %
@if %1.==1. goto l

कमांड-लाइन तर्क के रूप में बिट्स की एक सूची लेता है। +इसके बजाय का उपयोग करता है *क्योंकि विस्तार के *अंदर एक विशेष अर्थ है %s:...=...%।

— नील
स्रोत
2

जावा 10, 100 106 बाइट्स

b->{var s="";int i=0,j;for(var c:b){if(c)for(s+="\n",j=i;j-->0;)s+=0;else++i;s+=1;}return s.substring(1);}

मल की एक सरणी लेता है और एक स्ट्रिंग लौटाता है ( 0s खाली हैं, 1एस भरे हुए हैं)। इसे यहाँ ऑनलाइन आज़माएँ ।

ओलिवियर ग्रेजायर का धन्यवाद लिए मुझे इसमें थोड़ा और मदद करने के लिए और इस तथ्य के लिए सचेत किया कि मेरा आउटपुट प्रारूप कल्पना तक नहीं था।

Ungolfed संस्करण:

b -> { // lambda taking an array of booleans as argument
    var s = ""; // the output String
    int i = 0,  // the number of "empty" characters to output
    j;          // iterator variable for outputting the "empty" characters
    for(var c : b) { // iterate over the boolean array (the binary digits)
        if(c) // if it's a '1'
            for(s += "\n", // output a newline
            j = i; j-- > 0;) s += 0; // output the "empty" characters
        else // if it's a '0'
            ++i; // move one to the right on the next line
        s += 1; // output the "filled" character
    }
    return s.substring(1); // output the constructed String, minus the leading newline
}
— OOBalance
स्रोत
मैंने 5 बाइट्स गॉल्फ़ किए:{if(c){s+="\n";for(j=i;j-->0;)s+=0;}else++i;s+=1;}
— ओलिवियर
आगे भी:{if(c)for(s+="\n",j=i;j-->0;)s+=0;else++i;s+=1;}
— ओलिवियर ग्रैओयर
हालाँकि, आप पहली पंक्ति पर नहीं बल्कि दूसरे पर प्रिंट करते हैं। चुनौती से: "कोई अग्रणी स्थान (या" खाली "चार) / लाइनों की अनुमति नहीं है"
— ओलिवियर ग्राएगोइरे
@ ओलिवियरग्रेगायर धन्यवाद। मैंने संपादित किया है।
— ओबैलेंस
1

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

(#)n=maximum.map(!!n)
f l|s<-scanl1(zipWith(+))$(\a->[1-a,a])<$>l=unlines[[last$' ':['#'|elem[x,y]s]|x<-[0..0#s]]|y<-[1..1#s]]

शून्य और लोगों की एक सूची के रूप में इनपुट। द्वारा ऑफसेट में संख्या बदल देता हैx↦[1-x,x] और आंशिक रकम की गणना करता है। अंतिम आउटपुट दो नेस्टेड सूची समझ के साथ किया जाता है।

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

— Angs
स्रोत
1

आर , 59 बाइट्स

function(n,x=sum(n|1))matrix(1:x^2%in%cumsum((n-1)%%x+1),x)

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

बिट्स की एक सरणी के रूप में इनपुट लेता है।

की एक बूलियन मैट्रिक्स रिटर्न TRUEऔर FALSEएक का प्रतिनिधित्व करने *के लिए और एक क्रमशः।

परीक्षण में आसानी के लिए, ऊपर दिए गए स्पेक्स के अनुरूप मैट्रिक्स प्रिंट करने के लिए पाद लेख में कुछ सामान है।

— ग्यूसेप
स्रोत
1

एपीएल + विन, 65 या 46 बाइट्स

पूर्णांक के इनपुट के लिए संकेत

n←+/i←((1+⌊2⍟n)⍴2)⊤n←⎕⋄m←(n,n)⍴' '⋄m[⊂[2](+\i),[1.1]1++\~i]←'*'⋄m

या पूर्णांक के द्विआधारी प्रतिनिधित्व के संख्यात्मक वेक्टर के लिए

m←(2⍴+/n←⎕)⍴' '⋄m[⊂[2](+\i),[1.1]1++\~i]←'*'⋄m

यह मानते हुए कि मैंने कुछ उत्तरों के लिए टिप्पणियों को सही ढंग से पढ़ा है और बाद के इनपुट की अनुमति है।

— ग्राहम
स्रोत
1

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

p\*VtQINp+b*Zd.?=hZ)p\*

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

व्याख्या

p\*VtQINp+b*Zd.?=hZ)p\*
p\*                       Print the leading *.
   VtQ                    For each bit (excluding the leading 1)...
      IN      .?   )      ... If the bit is set...
        p+b*Zd            ... Print a newline and a bunch of spaces...
                =hZ       ... Otherwise, increase the count of spaces...
                    p\*   ... Then print the next *.
1

स्माइलबासिक, 64 59 57 बाइट्स

INPUT N@L
GPSET X,Y
B=N<0X=X+B
Y=Y+(X>B)N=N<<1ON!N GOTO@L

उच्चतम बिट (साइन बिट) की जाँच की जाती है, और यदि यह 1 है, तो X स्थिति बढ़ जाती है। यदि साइन बिट X स्थिति से कम है (अर्थात, साइन बिट 0 है और X 0 नहीं है) तो Y स्थिति बढ़ जाती है।

पहला आंदोलन हमेशा क्षैतिज रूप से होगा, इसलिए Y आंदोलन पहले X आंदोलन के बाद तक अवरुद्ध है। यह सुनिश्चित करता है कि वाई स्थिति अग्रणी 0 बिट्स के दौरान नहीं बढ़ती है।

तब N को बाएँ स्थानांतरित कर दिया जाता है, और यह N को 0 तक पहुँचने तक दोहराता है।

— 12Me21
स्रोत
1

जाप , 19 17 बाइट्स

Ë?R+Tî +Q:°T©Qìx
Ë?                 // Map over the input and if the current value is 1:
  R+               // Return a new line and
    Tî +           // a space repeated T (with initial value 0) times and
        Q          // a \".
         :         // If the current value is 0:
          °T       // Increment T
            ©Q     // and return \".
              Ã    // When all of that is done,
               ¬   // turn the array into a string
                x  // and trim it, removing the excess new line at the start.

बिट्स के एक सरणी के रूप में इनपुट लेता है, उदाहरण के लिए [1,0,1], "इसके बजाय आउटपुट *। ओलिवर की
बदौलत दो बाइट शेव की गईं ।

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

— लीख
स्रोत
अच्छा है। आप के SpTसाथ बदल सकते हैं Tî- îके समान है p, सिवाय इसके कि इसमें चूक है " "। इसके अलावा, इसके लिए एक शॉर्टकट है q :¬
— Oliver
@ ओलिवर धन्यवाद, मुझे पता नहीं था î, निश्चित रूप से बहुत आसान है। मैं अक्सर शॉर्टकट का उपयोग करने के अवसरों की जांच करता हूं, लेकिन मैं अभी भी हमेशा उनमें से कुछ को याद करता हूं, आपकी मदद के लिए बहुत बहुत धन्यवाद।
— निट
1

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

def f(a):
 o='*';r=[o]
 for i in bin(a)[3:]:
  if'0'<i:r+=[' '*len(r[-1][1:])]
  r[-1]+=o
 print'\n'.join(r)

यकीन नहीं होता कि यह एक मायने रखता है (यह प्रत्येक पंक्ति की एक सरणी को आउटपुट करता है), लेकिन अगर ऐसा है तो मैं अपनी बाइट की संख्या को 103 में बदल दूंगा:

def f(a):
 o='*';r=[o]
 for i in bin(a)[3:]:
  if'0'<i:r+=[' '*len(r[-1][1:])]
  r[-1]+=o
 print r
— sonrad10
स्रोत
1

टीआई-बेसिक (TI-84 Plus CE), 85 बाइट्स

Prompt L
1→X
1→Y
DelVar [A]
sum(LL
{Ans,1-Ans+dim(LL→dim([A]
1→[A](Y,X
For(I,2,dim(LL
Y+LL(I→Y
X+not(LL(I→X
1→[A](Y,X
End
[A]

बूलियन सूची के लिए संकेत, 0 और 1 का मैट्रिक्स लौटाता है।

सूची के माध्यम से जाता है, एक्स को बढ़ाता है अगर अगला 'बिट' 0 है, तो वाई को अन्यथा बदलना, फिर उस स्थान पर मैट्रिक्स में 1 जोड़ना, और अंत में मैट्रिक्स लौटाता है।

टीआई-बेसिक एक टोकन लैनुज है ।

  • 1 बाइट: Prompt , L* 6, (newline) * 12, 1* 5, →* 7, X* 5, Y* 5, sum(, L* 5, {, Ans* 2, ,* 5, -, +* 3, dim(* 3, (* 4, For(, I* 3, 2, not(, End73 बाइट्स =
  • 2 बाइट्स: Delvar , [A]* 5 = 12 बाइट्स
  • कुल: 85 बाइट्स

टीआई-बेसिक (टीआई -84 प्लस सीई), 56 बाइट्स

Prompt L
1→X
1→Y
Output(Y,X,"*
For(I,2,dim(LL
Y+LL(I→Y
X+not(LL(I→X
Output(Y,X,"*
End

उपरोक्त प्रक्रियाएं, लेकिन मैट्रिक्स में जोड़ने के बजाय, ग्राफ़िकल आउटपुट (स्क्रीन आकार द्वारा सीमित: 10 पंक्तियों, 26 कॉलम, इसलिए अधिकतम 10 1s और 25 0s) का उपयोग करना।

— pizzapants184
स्रोत
1

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

JZFG.BQIsGIJk)p+*ZdN.?pN=hZ)=J

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

के "बजाय का उपयोग करता है* ।

पायथन 3 अनुवाद: 
Q=eval(input())
Z=0
J=Z
for G in "{0:b}".format(Q):
    if int(G):
        if J:
            print()
        print(Z*' '+'"',end='')
    else:
        print('"',end='')
        Z+=1
    J=Q
— hakr14
स्रोत
1

x86 .COM, 32 बाइट्स

00h: 66 D1 E6 66 0F BD CE BF 24 AD 8E DF 41 66 0F A3 
10h: CE 19 DB 81 E3 9E 00 8D 79 02 C6 05 2A E2 EE C3 

fun:
shl esi, 1
bsr ecx, esi
mov di, $ad24
mov ds, di
inc cx
lab2:
bt esi, ecx
sbb bx,bx
and bx,158
lea di,[di+2+bx]
mov [di],byte '*'
lab1:loop lab2
ret
— l4m2
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.