Pour un entier nsatisfaisant n > 0, écrivez sa valeur sous la forme d'un chemin descendant droit basé sur sa représentation binaire.

Règles

• Le premier bit (le plus significatif) défini est toujours dans le coin supérieur gauche.
• Lorsque le bit suivant est défini (a 1), dessinez un caractère ("rempli") sur la ligne suivante dans la même colonne que le caractère précédent dessiné. Essayez d'utiliser des espaces ("vides") pour remplir, mais n'importe quel caractère fera aussi longtemps qu'il est toujours le même.
• Lorsque le bit suivant n'est pas défini (a 0), dessinez un caractère ("rempli") sur la même ligne immédiatement à droite du caractère précédent dessiné.
• Votre code doit prendre en charge des nombres avec au moins 20 bits significatifs.
• Écrivez un programme complet, une fonction, un lambda, etc. mais pas d'extrait.
• Aucun espace de tête (ou caractère "vide") / lignes autorisées
• N'importe quel nombre d'espaces de fin (ou caractère "vide") / lignes autorisées
• Tout type d'entrée 1D est accepté: nombre, chaîne, tableau de booléens, etc. Gardez cependant l'ordre des bits intact.
• Tout type de sortie visuelle 2D est accepté: sur stdout, une chaîne (avec deux valeurs distinctes représentant "rempli" et "vide"), vous pouvez même sortir une matrice si vous le souhaitez. Une liste de chiffres semble difficile à concilier avec la règle "sans espace de titre", mais je suis ouvert à elle si vous trouvez un moyen de l'utiliser. Remarque: si vous avez choisi d'imprimer ou de renvoyer une chaîne, les caractères utilisés doivent être des caractères ASCII dans la plage de points de code [32-126].
• Les failles standard sont interdites.
• Il s'agit de codegolf, donc le code le plus court l'emporte.

Exemples

Entrée: 1

*

Entrée: 2

**

Entrée: 3

*
*

Entrée: 4

***

Entrée: 5

**
 *

Entrée: 6

*
**

Entrée: 7

*
*
*

Entrée: 25

*
***
  *

Entrée: 699050

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

Entrée: 1047552

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

Entrée: 525311

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

Gelée , 8 octets

¬œṗ+\Ṭz0

Un lien monadique acceptant un certain nombre en tant que liste de uns et de zéros (par exemple 13est [1,1,0,1]) le renvoi d' une liste de listes de uns et de zéros dans lequel la première liste est la première rangée.

Essayez-le en ligne! ou consultez une suite de tests formatée

Comment?

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

J_iB^YsJ+'o-'&XG

Produit une sortie graphique sous la forme d'un chemin commençant aux coordonnées (0,0). Essayez-le sur MATL Online! Ou voyez quelques exemples hors ligne ci-dessous:

• Entrée 7:

  

  Sortie:

  

• Entrée 699050:

  

  Sortie:

  

Si vous préférez, vous pouvez voir le chemin sous forme de coordonnées complexes pour 9 octets :

J_iB^YsJ+

Essayez-le en ligne!

Explication

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 octets

YsG~YsQ1Z?

Entre un tableau de chiffres binaires. Sort une matrice.

Essayez-le en ligne!

Explication

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 octets

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

Essayez-le en ligne!

Version récursive:

Python 2 , 71 69 67 octets

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

Essayez-le en ligne!

Fusain , 22 20 19 11 10 octets

Ｆ⮌Ｓ¿Ｉι↑*←*

Seulement ma deuxième réponse au charbon jusqu'à présent.

Prend l'entrée en chaîne binaire (c'est-à-dire en 699050tant que 10101010101010101010).

-9 octets grâce à @Neil suggérant de boucler en arrière.

Essayez-le en ligne.

Explication:

Lisez STDIN sous forme de chaîne dans l'ordre inverse:

Reverse(InputString())
⮌Ｓ

Faites une boucle sur ses chiffres binaires sous forme de chaînes ι:

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

Si le ιnombre repoussé à un nombre est 1, imprimez le *haut, sinon imprimez le *vers la gauche.

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

C # (.NET de base) , 155 123 120 113 101 octets

32 octets enregistrés grâce à l'entrée pouvant être reçue sous forme de tableau de bits.
7 octets enregistrés grâce à @auhmaan.
10 octets enregistrés grâce à @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;}

Essayez-le en ligne!

05AB1E , 18 17 14 octets

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

Essayez-le en ligne!

Explication

γ€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 octets grâce à @Emigna

05AB1E explication de la toile

Python 2 , 59 octets

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

Essayez-le en ligne!

Basé sur la solution de TFeld .

Haskell , 65 octets

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

Essayez-le en ligne!

Prend l'entrée comme une liste de booléens.

Curry PAKCS, 70 octets

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

Port de la réponse Haskell, mais parce que <-cela ne fonctionne pas dans Curry, nous devons faire une fonction d'assistance u. Nous devons également ajouter un espace entre fet .pour que Curry le traite comme une composition plutôt qu'un point.

Cela fonctionne également dans MCC Curry, mais ne fonctionne pas dans Sloth Curry (qui est le seul pris en charge par TIO).

Haskell , 74 70 67 62 octets

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

Essayez-le en ligne! Prend une liste de zéros et de uns en entrée et renvoie une chaîne séparée par des sauts de ligne.

Inspiré par la réponse de xnor .

Emojicode , 251 octets

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

Essayez-le en ligne!

Ce n'est certainement pas une solution pour le golf, mais il n'y a pas une personne vivante qui considérerait le code Emoji comme une langue de golf. Cependant, dans le processus de me soumettre aux horreurs qui sont la syntaxe du code emoji dans un effore pour m'apprendre cette monstruosité d'une langue, j'ai été agréablement surpris de voir à quel point il peut être puissant et efficace 😀

Explication:

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

Même format d'E / S et même logique que la version récursive ci-dessous.

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

Essayez-le en ligne!

Ou 42 octets si ce format est acceptable.

Version récursive, 56 octets

Prend l'entrée comme un tableau d'entiers (0 ou 1). Utilise 0pour rempli et espace pour vide.

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

Essayez-le en ligne!

Commenté

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

Utilitaires Bash + GNU, 38

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

Ici ^Ket ^Hsont des caractères de contrôle vertical et tabulation verticale littérale. Ceux-ci ne s'affichent pas bien sur les navigateurs, donc ce script peut être recréé comme suit:

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

Exécuter dans un terminal. L'entrée se fait via STDIN.

Cette réponse peut étirer les spécifications trop loin - il n'y a en fait aucun caractère de tête sur chaque ligne de sortie - tout le positionnement se fait avec des caractères de contrôle. Si cela est trop étiré, la sortie peut être dirigée vers |col -x|tac11 octets supplémentaires.

Lot, 113 octets

@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

Prend une liste de bits comme arguments de ligne de commande. Utilise +au lieu de *car *a une signification particulière à l'intérieur des %s:...=...%extensions.

Java 10, 100 106 octets

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

Prend un tableau de booléens et retourne une chaîne ( 0s sont vides, 1s sont remplis). Essayez-le en ligne ici .

Merci à Olivier Grégoire de m'avoir aidé à jouer au golf un peu plus et de m'avertir du fait que mon format de sortie n'était pas à la hauteur des spécifications.

Version non golfée:

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 octets

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

Essayez-le en ligne!

• Prend en charge au plus 20 bits.
• Entrée en tant que int[]
• Sortie en tant que int[][]

Haskell , 126 octets

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

Saisissez une liste de zéros et de uns. Transforme le nombre en décalage par x↦[1-x,x]et calcule les sommes partielles. La sortie finale se fait avec deux compréhensions de listes imbriquées.

Essayez-le en ligne!

R , 59 octets

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

Essayez-le en ligne!

Prend l'entrée comme un tableau de bits.

Renvoie une matrice booléenne TRUEet FALSEreprésentant un *et un , respectivement.

Il contient également des éléments dans le pied de page pour imprimer une matrice correspondant aux spécifications ci-dessus, pour faciliter les tests.

APL + WIN, 65 ou 46 octets

Invite à saisir l’entier

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

ou pour vecteur numérique de la représentation binaire de l'entier

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

en supposant que j'ai lu correctement les commentaires de certaines réponses et que cette dernière entrée soit autorisée.

Pyth, 23 octets

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

Essayez-le ici

Explication

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 octets

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

Essayez-le en ligne!

Coupez-le bien après avoir réalisé que l'entrée pouvait être une chaîne de bits.

SmileBASIC, 64 59 57 octets

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

Le bit le plus élevé (bit de signe) est vérifié et s'il vaut 1, la position X augmente. Si le bit de signe est inférieur à la position X (c'est-à-dire que le bit de signe est 0 et X n'est pas 0) la position Y augmente.

Le premier mouvement sera toujours horizontal, donc le mouvement Y est bloqué jusqu'après le premier mouvement X. Cela garantit que la position Y n'augmente pas pendant les 0 premiers bits.

Ensuite, N est décalé vers la gauche, et cela se répète jusqu'à ce que N atteigne 0.

Rubis , 63 octets

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

Essayez-le en ligne!

Japt , 19 17 octets

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

Prend l'entrée comme un tableau de bits, par exemple [1,0,1], les sorties "au lieu de *.
Rasé de deux octets grâce à Oliver .

Essayez-le en ligne!

Python 2, 113 octets

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)

Je ne sais pas si celui-ci compte (il génère un tableau de chacune des lignes), mais si c'est le cas, je changerai mon nombre d'octets en 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 octets

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]

Demande une liste booléenne, retourne une matrice de 0 et 1.

Parcourt la liste, incrémente X si le prochain «bit» est 0, modifie Y sinon, puis ajoute un 1 à la matrice à cet endroit et renvoie la matrice à la fin.

TI-Basic est une langue à jeton .

• 1 octet: Prompt , L* 6, (saut de ligne) * 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 octets
• 2 octets: Delvar , [A]* 5 = 12 octets
• Total: 85 octets

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

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

Mêmes processus que ci-dessus, mais en utilisant une sortie graphique (limitée par la taille de l'écran: 10 lignes, 26 colonnes, donc max 10 1 et 25 0) au fur et à mesure, au lieu d'ajouter à une matrice.

Pyth, 30 octets

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

Essayez-le en ligne!

Utilise "au lieu de *.

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 octets

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 octets

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

Essayez-le en ligne!