nTatmin edici bir tamsayı için n > 0, değerini, ikili gösterimini temel alarak sağa inen bir yol olarak yazın.

kurallar

• İlk (en önemli) ayar biti her zaman sol üst köşededir.
• Bir sonraki bit (a 1) olarak ayarlandığında , sonraki satırda çizilen önceki karakterle aynı sütuna bir karakter ("dolgulu") çizin. Boşlukları ("boş") doldurmaya çalışın, ancak herhangi bir karakter her zaman aynı olduğu sürece gerçekleşir.
• Bir sonraki bit ayarlandığında (a 0), çizilen önceki karakterin sağına hemen aynı satırın üzerine bir karakter ("doldurulmuş") çizin.
• Kodunuz en az 20 önemli bit içeren rakamları desteklemelidir.
• Tam bir program, bir işlev, bir lambda, vb. Yazın, ancak snippet yazmayın.
• Baştaki boşluklara (veya "boş" karakterlere) / satırlara izin verilmez
• İstenilen sayıda boşluk (veya "boş" karakter) / satır izin verilir
• Her türlü 1D giriş kabul edilir: sayı, string, booleans dizisi, vb. Ancak, bitlerin sırasına dokunulmaz.
• Her türlü görsel 2B çıktı kabul edilir: stdout'ta, bir dize ("dolu" ve "boş" ifadelerini temsil eden iki farklı değere sahip), isterseniz bir matris bile çıkarabilirsiniz. Sayıların bir listesini "başlık yok" kuralıyla bağdaştırmak zor görünüyor, ancak kullanmanın bir yolunu bulursanız açık olurum. Not: Bir dize yazdırmayı veya döndürmeyi seçtiyseniz, kullanılan karakterler kod noktaları aralığında ASCII karakterleri olmalıdır [32-126].
• Standart boşluklar yasaklandı.
• Bu kod kodudur, en kısa kod kazanır.

Örnekler

Giriş: 1

*

Giriş: 2

**

Giriş: 3

*
*

Giriş: 4

***

Giriş: 5

**
 *

Giriş: 6

*
**

Giriş: 7

*
*
*

Giriş: 25

*
***
  *

Giriş: 699050

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

Giriş: 1047552

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

Giriş: 525311

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

Jöle , 8 bayt

¬œṗ+\Ṭz0

Birler ve sıfırlar bir liste olarak bir numara kabul Bir monadic bağlantı (örn 13olan [1,1,0,1]ilk liste ilk satır olduğu birler ve sıfırlar listelerin bir listesini dönen).

Çevrimiçi deneyin! veya formatlanmış bir test takımını görün

Nasıl?

¬œṗ+\Ṭ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

MATL , 14 bayt

J_iB^YsJ+'o-'&XG

Koordinatlardan başlayarak (0,0) grafiksel çıktı üretir. MATL Online'da deneyin ! Veya aşağıdaki bazı çevrimdışı örnekleri görün:

• Giriş 7:

  

  Çıktı:

  

• Giriş 699050:

  

  Çıktı:

  

İsterseniz yolu 9 bayt için karmaşık koordinatlar olarak görebilirsiniz :

J_iB^YsJ+

Çevrimiçi deneyin!

açıklama

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

MATL , 10 bayt

YsG~YsQ1Z?

İkili basamak dizisini girer. Bir matris çıktılar.

Çevrimiçi deneyin!

açıklama

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

Python 2 , 100 99 81 78 73 66 bayt

a='';x=0
for c in input():a+=('\n'+' '*x)*c+'*';x+=1-c
print a[1:]

Çevrimiçi deneyin!

Özyinelemeli sürümü:

Python 2 , 71 69 67 bayt

f=lambda n,x=0:n and('\n'[:x]+' '*x)*n[0]+'*'+f(n[1:],x+1-n[0])or''

Çevrimiçi deneyin!

Kömür , 22 20 19 11 10 bayt

Ｆ⮌Ｓ¿Ｉι↑*←*

Şimdiye kadar sadece ikinci kömürüm cevabı.

İkili-String olarak girdi (yani Alır 699050olarak 10101010101010101010).

@Neil, -9 byte sayesinde geriye doğru dönmeyi öneriyor.

Çevrimiçi deneyin.

Açıklama:

STDIN'i ters sırada dizge olarak okuyun:

Reverse(InputString())
⮌Ｓ

İkili basamaklarının üzerinde dizge olarak döngü yapın ι:

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

Eğer ιbir numara olduğunu 1'e döküm geri yazdırmak *yukarı, başka baskı *sola doğru.

If(Cast(i)) Print(:Up,"*"); Else Print(:Left,"*");
¿Ｉι↑*←*

C # (.NET Core) , 155 123 120 113 101 bayt

Girişlerin bir bit dizisi olarak alınabilmesi nedeniyle 32 bayt kaydedildi.
@Auhmaan sayesinde 7 bayt kaydedildi.
@KevinCruijssen sayesinde 10 bayt kaydedildi.

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;}

Çevrimiçi deneyin!

05AB1E , 18 17 14 bayt

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

Çevrimiçi deneyin!

açıklama

γ€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 :-)

• @Emigna sayesinde 3 bayt

05AB1E kanvasının açıklaması

Python 2 , 59 bayt

s=p='\n'
for x in input():s+=p*x+'*';p+=' '[x:]
print s[2:]

Çevrimiçi deneyin!

Kapalı göre TFeld çözümüyle .

Haskell , 65 bayt

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

Çevrimiçi deneyin!

Bir boolean listesi olarak girdi alır.

Körili PAKCS, 70 bayt

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

Haskell Limanı cevap verir, ancak Curry'de <-çalışmadığı için yardımcı bir işlev yapmamız gerekir u. Ayrıca arasına bir boşluk eklememiz gerekirf ve .böylece Curry bir oluşturmadeneyimine yerine bir nokta olarak ayrıştırır söyledi.

Bu aynı zamanda MC Curry'de çalışır, ancak (TIO tarafından desteklenen tek kişi) Sloth Curry'de çalışmaz.

Haskell , 74 70 67 62 bayt

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

Çevrimiçi deneyin!Sıfırların ve girişlerin bir listesini alır ve yeni satır ayrılmış bir dize döndürür.

Xnor'ın cevabından ilham aldı .

Emojicode , 251 bayt

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

Çevrimiçi deneyin!

Bu kesinlikle bir golf çözümü değil, ancak Emoji kodunu bir golf dili olarak düşünecek canlı biri yok. Bununla birlikte, kendimi bir dilin bu canavarlığını öğretmek için kendimi emoji kodunun sözdizimi olan korkulara maruz bırakma sürecinde, ne kadar güçlü ve etkili olabileceğine şaşırdım.

Açıklama:

🐋 🚂 🍇    👴 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
🍉

JavaScript (ES6), 48 bayt

Aynı I / O formatı ve aşağıdaki özyinelemeli sürüm ile aynı mantık.

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

Çevrimiçi deneyin!

Ya da 42 bayt halinde bu biçim kabul edilebilir.

Özyinelemeli sürüm, 56 bayt

Bir tamsayı dizisi olarak giriş yapar (0 veya 1). 0Doldurulmuş ve boş bırakılmış alan için kullanır .

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

Çevrimiçi deneyin!

Yorumlananlar

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

Bash + GNU yardımcı programları, 38

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

İşte ^Kve ^Hdeğişmez dikey sekme ve geri alma kontrol karakterleri. Bunlar tarayıcılarda iyi sonuç vermiyor, bu nedenle bu komut dosyası aşağıdaki gibi yeniden oluşturulabilir:

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

Bir terminalde koş. Giriş STDIN üzerinden yapılır.

Bu cevap özellikleri çok uzatabilir - aslında her çıktı satırında baş karakter yoktur - tüm konumlandırma kontrol karakterleriyle yapılır. Bu çok fazla bir esneme ise, çıkış |col -x|tacfazladan 11 baytlık bir boruya bağlanabilir .

Toplu iş, 113 bayt

@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

Komut satırı argümanları olarak bitlerin bir listesini alır. +Bunun yerine kullanır , *çünkü açılımların *içinde özel bir anlamı vardır %s:...=...%.

Java 10, 100 106 bayt

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);}

Bir dizi boolean alır ve bir String döndürür ( 0s boş, 1s dolu). Burada çevrimiçi deneyin .

Olivier Grégoire'a teşekkürler biraz daha bana golf yardım ve benim çıkış biçimi kadar spec olmadığı gerçeğini beni uyarmak için.

Ungolfed versiyonu:

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
}

Java (JDK 10) , 83 bayt

a->{int m[][]=new int[20][20],r=0,i=0;for(int b:a)m[r+=i<1?0:b][i++-r]=1;return m;}

Çevrimiçi deneyin!

• En fazla 20 bit destekler.
• Girişi olarak int[]
• Çıkış olarak int[][]

Haskell , 126 bayt

(#)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]]

Sıfırların ve birlerin listesi olarak giriş yapın. Sayıyı ofsete dönüştürür x↦[1-x,x]ve kısmi toplamları hesaplar. Nihai çıktı iki iç içe liste kavrama ile yapılır.

Çevrimiçi deneyin!

R , 59 bayt

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

Çevrimiçi deneyin!

Girdiyi bir dizi dizisi olarak alır.

A TRUEve FALSEa'nın bir *ve boolean matrisini temsil eder. sırasıyla.

Ayrıca, test kolaylığı için yukarıdaki özelliklere uygun bir matris basmak için altbilgide bazı şeyler vardır.

APL + WIN, 65 veya 46 bayt

Tamsayının girişi için bilgi istemi

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

veya tamsayının ikili gösteriminin sayısal vektörü için

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

Bazı cevaplara yorumları doğru okudum ve ikinci girdiye izin verildi.

Pyth, 23 bayt

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

Burada dene

açıklama

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 *.

Perl 5 -p , 54 bayt

s/./$&?"
".$"x$i.1:++$i&&1/ge;s/.//s

Çevrimiçi deneyin!

Girişin bit dizgisi olabileceğini fark ettikten sonra kesin.

SmileBASIC, 64 59 57 bayt

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

En yüksek bit (işaret biti) kontrol edilir ve 1 ise, X konumu artar. Eğer işaret biti X konumundan daha küçükse (yani işaret biti 0 ve X 0 değil) Y konumu artar.

İlk hareket her zaman yatay olacaktır, bu nedenle Y hareketi ilk X hareketinden sonraya kadar engellenir. Bu, Y konumunun baştaki 0 ​​bit sırasında artmamasını sağlar.

Sonra N sola kaydırılır ve N 0'a ulaşana kadar bu tekrar eder.

Ruby , 63 bayt

->n{s=""
n.to_s(2).gsub(/./){$&==?1?"
"+s+?*:(s+=" ";?*)}[1,n]}

Çevrimiçi deneyin!

Japt , 19 17 bayt

Ë?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.

Girdiyi bir bit dizisi olarak alır, örneğin bunun yerine [1,0,1]çıktılar . Oliver sayesinde iki bayt traş oldu ."*

Çevrimiçi deneyin!

Python 2, 113 Bayt

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)

Bunun sayılacağından emin değilim (satırların her birinin dizisini çıkarır), ancak öyleyse bayt sayımı 103 olarak değiştireceğim:

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

TI-Basic (TI-84 Plus CE), 85 bayt

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]

Bir boolean listesi istemi, 0 ve 1 matrisini döndürür.

Bir sonraki 'bit' 0 ise X'i artırarak, aksi takdirde Y'yi değiştirip ardından o konuma matrisi 1 ekleyerek listeye girer ve sonunda matrisi döndürür.

TI-Basic tokenize bir dildir .

• 1 bayt: Prompt , L* 6, (satır) * 12, 1* 5, →* 7, X* 5, Y* 5, sum(, _L* 5, {, Ans* 2, ,* 5, -, +* 3, dim(* 3, (* 4, For(,I * 3, 2, not(, End73 bayt =
• 2 byte: Delvar ,[A] * 5 = 12 bayt
• Toplam: 85 bayt

TI-Basic (TI-84 Plus CE), 56 bayt

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

Yukarıdaki ile aynı işlemler, ancak bir matrise eklemek yerine grafik çıktısı (ekran boyutuyla sınırlıdır: 10 satır, 26 sütun, bu nedenle maksimum 10 1s ve 25 0s).

Pyth, 30 bayt

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

Çevrimiçi deneyin!

Kullanımları "yerine* .

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

x86 .COM, 32 bayt

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  

APL (Dyalog Klasik) , 18 bayt

+⌿↑1↑¨⍨-+\,¨∘~⍨0,⎕

Çevrimiçi deneyin!