Per un numero intero nche soddisfa n > 0, scrivi il suo valore come un percorso discendente a destra in base alla sua rappresentazione binaria.

Regole

• Il primo bit (più significativo) impostato è sempre nell'angolo in alto a sinistra.
• Quando viene impostato il bit successivo (a 1), disegna un carattere ("riempito") sulla riga successiva nella stessa colonna del carattere precedente disegnato. Prova a usare gli spazi ("vuoti") per riempire, ma qualsiasi personaggio lo farà purché sia ​​sempre lo stesso.
• Quando il bit successivo non è impostato (a 0), disegna un carattere ("riempito") sulla stessa linea immediatamente a destra del carattere precedente disegnato.
• Il tuo codice deve supportare numeri con almeno 20 bit significativi.
• Scrivi un programma completo, una funzione, una lambda, ecc., Ma senza frammenti.
• Non sono ammessi spazi iniziali (o caratteri "vuoti") / linee
• Qualsiasi numero di spazi finali (o carattere "vuoto") / righe consentiti
• È accettato qualsiasi tipo di input 1D: numero, stringa, matrice di valori booleani, ecc. Tuttavia, l'ordine dei bit rimane invariato.
• È accettato qualsiasi tipo di output 2D visivo: su stdout, una stringa (con due valori distinti che rappresentano "riempito" e "vuoto"), puoi anche generare una matrice se vuoi. Un elenco di numeri sembra difficile da conciliare con la regola "nessuno spazio di intestazione", ma sono aperto ad esso se trovi un modo per usarlo. Nota: se si sceglie di stampare o restituire una stringa, i caratteri utilizzati devono essere caratteri ASCII nell'intervallo dei punti di codice [32-126].
• Le scappatoie standard sono vietate.
• Questo è codegolf, quindi vince il codice più corto.

Esempi

Ingresso: 1

*

Ingresso: 2

**

Ingresso: 3

*
*

Ingresso: 4

***

Ingresso: 5

**
 *

Ingresso: 6

*
**

Ingresso: 7

*
*
*

Ingresso: 25

*
***
  *

Ingresso: 699050

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

Ingresso: 1047552

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

Ingresso: 525311

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

Gelatina , 8 byte

¬œṗ+\Ṭz0

Un collegamento monadico che accetta un numero come un elenco di quelli e zeri (ad es. 13È [1,1,0,1]) che restituisce un elenco di elenchi di quelli e zeri in cui il primo elenco è la prima riga.

Provalo online! o vedere una suite di test formattata

Come?

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

J_iB^YsJ+'o-'&XG

Produce un output grafico come percorso che inizia dalle coordinate (0,0). Provalo su MATL Online! Oppure vedi alcuni esempi offline di seguito:

• Input 7:

  

  Produzione:

  

• Input 699050:

  

  Produzione:

  

Se preferisci, puoi vedere il percorso come coordinate complesse per 9 byte :

J_iB^YsJ+

Provalo online!

Spiegazione

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 byte

YsG~YsQ1Z?

Immette una matrice di cifre binarie. Emette una matrice.

Provalo online!

Spiegazione

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 byte

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

Provalo online!

Versione ricorsiva:

Python 2 , 71 69 67 byte

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

Provalo online!

Carbone , 22 20 19 11 10 byte

Ｆ⮌Ｓ¿Ｉι↑*←*

Finora solo la mia seconda risposta al carbone.

Accetta l'input come stringa binaria (ovvero 699050come 10101010101010101010).

-9 byte grazie a @Neil che suggerisce di tornare indietro.

Provalo online.

Spiegazione:

Leggi STDIN come stringa in ordine inverso:

Reverse(InputString())
⮌Ｓ

Passa sopra le sue cifre binarie come stringhe ι:

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

Se ιriportato a un numero è 1, stampa *verso l' alto, altrimenti stampa *verso sinistra.

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

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

32 byte salvati grazie all'input che può essere ricevuto come una matrice di bit.
Salvato 7 byte grazie a @auhmaan.
10 byte salvati grazie a @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;}

Provalo online!

05AB1E , 18 17 14 byte

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

Provalo online!

Spiegazione

γ€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 byte grazie a @Emigna

05AB1E spiegazione della tela

Python 2 , 59 byte

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

Provalo online!

Basato sulla soluzione di TFeld .

Haskell , 65 byte

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

Provalo online!

Accetta input come un elenco di valori booleani.

CAK PAKCS, 70 byte

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

Port of the Haskell risponde, ma poiché <-non funziona in Curry dobbiamo fare una funzione di supporto u. Dobbiamo anche aggiungere uno spazio tra fe. modo che Curry lo analizzi come un composit piuttosto che un punto.

Questo funziona anche in MCC Curry, ma non funziona in Sloth Curry (che è l'unico supportato da TIO).

Haskell , 74 70 67 62 byte

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

Provalo online! Prende un elenco di zero e uno come input e restituisce una stringa separata da nuova riga.

Ispirato dalla risposta di xnor .

Emojicode , 251 byte

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

Provalo online!

Questa non è sicuramente una soluzione da golf, ma non esiste una persona viva che consideri il codice Emoji un linguaggio da golf. Tuttavia, nel processo di sottomettermi agli orrori che sono la sintassi del codice emoji in un effore per insegnarmi questa mostruosità di un linguaggio, sono stato piacevolmente sorpreso da quanto possa essere potente ed efficiente 😀

spiegazione:

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

Stesso formato I / O e stessa logica della versione ricorsiva di seguito.

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

Provalo online!

O 42 byte se questo formato è accettabile.

Versione ricorsiva, 56 byte

Accetta l'input come una matrice di numeri interi (0 o 1). Utilizza 0per riempito e spazio per vuoto.

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

Provalo online!

Commentate

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

Utilità Bash + GNU, 38

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

Qui ^Ke ^Hsono letterali caratteri di controllo di tabulazione verticale e backspace. Questi non vengono visualizzati correttamente sui browser, quindi questo script può essere ricreato come segue:

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

Corri in un terminale. L'ingresso è tramite STDIN.

Questa risposta può allungare troppo le specifiche - in realtà non ci sono caratteri iniziali su ciascuna riga di output - tutto il posizionamento viene eseguito con caratteri di controllo. Se si tratta di un tratto eccessivo, è possibile eseguire il piping dell'output |col -x|tacper ulteriori 11 byte.

Lotto, 113 byte

@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

Prende un elenco di bit come argomenti della riga di comando. Usi +anziché *perché *ha un significato speciale all'interno delle %s:...=...%espansioni.

Java 10, 100 106 byte

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

Accetta una matrice di valori booleani e restituisce una stringa ( 0i messaggi sono vuoti, 1i messaggi sono riempiti). Provalo online qui .

Grazie a Olivier Grégoire per avermi aiutato a giocare a golf un po 'di più e mi ha avvisato del fatto che il mio formato di output non era all'altezza delle specifiche.

Versione non golfata:

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 byte

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

Provalo online!

• Supporta al massimo 20 bit.
• Inserisci come int[]
• Uscita come int[][]

Haskell , 126 byte

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

Inserire come un elenco di zero e uno. Trasforma il numero in offset di x↦[1-x,x]e calcola le somme parziali. L'output finale viene eseguito con due comprensioni dell'elenco nidificato.

Provalo online!

R , 59 byte

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

Provalo online!

Accetta l'input come una matrice di bit.

Restituisce una matrice booleana di TRUEe che FALSErappresenta a *e a , rispettivamente.

Ha anche alcune cose nel piè di pagina per stampare una matrice corrispondente alle specifiche sopra, per facilità di test.

APL + WIN, 65 o 46 byte

Richiede l'immissione dell'intero

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

o per vettore numerico della rappresentazione binaria dell'intero

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

supponendo di aver letto correttamente i commenti a determinate risposte e che sia consentito l'ultimo input.

Pyth, 23 byte

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

Provalo qui

Spiegazione

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 36 byte

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

Provalo online!

Riducilo dopo che mi sono reso conto che l'input potrebbe essere una stringa di bit.

SmileBASIC, 64 59 57 byte

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

Viene controllato il bit più alto (segno bit) e, se è 1, la posizione X aumenta. Se il bit del segno è inferiore alla posizione X (ovvero, il bit del segno è 0 e X non è 0) la posizione Y aumenta.

Il primo movimento sarà sempre in orizzontale, quindi il movimento Y viene bloccato fino a dopo il primo movimento X. Ciò garantisce che la posizione Y non aumenti durante i 0 bit iniziali.

Quindi N viene spostato a sinistra e questo si ripete fino a quando N raggiunge 0.

Rubino , 63 byte

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

Provalo online!

Japt , 19 17 byte

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

Prende l'input come una matrice di bit, ad esempio [1,0,1]output "anziché *.
Rimozione di due byte grazie a Oliver .

Provalo online!

Python 2, 113 byte

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)

Non sono sicuro se questo conta (genera un array di ciascuna delle linee), ma in tal caso cambierò il mio conteggio dei byte in 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

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

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]

Richiede un elenco booleano, restituisce una matrice di 0 e 1.

Passa attraverso l'elenco, incrementando X se il 'bit' successivo è 0, modificando Y in caso contrario, quindi aggiungendo 1 alla matrice in quella posizione e restituendo la matrice alla fine.

TI-Basic è un lanugage tokenizzato .

• 1 byte: Prompt , L* 6, (nuova riga) * 12 1* 5, →* 7, X* 5, Y* 5, sum(, _L* 5, {, Ans* 2, ,* 5, -, +* 3, dim(* 3, (* 4, For(, I* 3, 2, not(,End = 73 byte
• 2 byte: Delvar ,[A] * 5 = 12 byte
• Totale: 85 byte

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

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

Stessi processi di cui sopra, ma utilizzando l'output grafico (limitato dalle dimensioni dello schermo: 10 righe, 26 colonne, quindi max 10 1s e 25 0s), invece di aggiungerlo a una matrice.

Pyth, 30 byte

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

Provalo online!

usi " invece di* .

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 byte

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 Classic) , 18 byte

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

Provalo online!