Para un número entero nque satisface n > 0, escriba su valor como una ruta descendente a la derecha en función de su representación binaria.

Reglas

• El primer bit de ajuste (más significativo) siempre está en la esquina superior izquierda.
• Cuando se establece el siguiente bit (a 1), dibuje un carácter ("relleno") en la línea siguiente en la misma columna que el carácter anterior dibujado. Intenta usar espacios ("vacíos") para rellenar, pero cualquier personaje funcionará siempre que sea igual.
• Cuando el siguiente bit no está establecido (a 0), dibuje un carácter ("relleno") en la misma línea inmediatamente a la derecha del carácter anterior dibujado.
• Su código debe admitir números con al menos 20 bits significativos.
• Escriba un programa completo, una función, una lambda, etc. pero sin fragmento.
• No se permiten espacios iniciales (o caracteres "vacíos") / líneas
• Cualquier número de espacios finales (o caracteres "vacíos") / líneas permitidas
• Se acepta cualquier tipo de entrada 1D: número, cadena, matriz de booleanos, etc. Sin embargo, mantenga el orden de los bits intactos.
• Se acepta cualquier tipo de salida visual 2D: en stdout, una cadena (con dos valores distintos que representan "lleno" y "vacío"), incluso puede generar una matriz si lo desea. Parece difícil conciliar una lista de números con la regla "sin espacios de encabezado", pero estoy abierto si encuentra una manera de usarla. Nota: si elige imprimir o devolver una cadena, los caracteres utilizados deben ser caracteres ASCII en el rango de puntos de código [32-126].
• Las lagunas estándar están prohibidas.
• Este es codegolf, por lo que gana el código más corto.

Ejemplos

Entrada: 1

*

Entrada: 2

**

Entrada: 3

*
*

Entrada: 4

***

Entrada: 5

**
 *

Entrada: 6

*
**

Entrada: 7

*
*
*

Entrada: 25

*
***
  *

Entrada: 699050

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

Entrada: 1047552

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

Entrada: 525311

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

Jalea , 8 bytes

¬œṗ+\Ṭz0

Un enlace monádico que acepta un número como una lista de unos y ceros (por ejemplo, 13es [1,1,0,1]) que devuelve una lista de listas de unos y ceros donde la primera lista es la primera fila.

Pruébalo en línea! o ver un conjunto de pruebas formateado

¿Cómo?

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

J_iB^YsJ+'o-'&XG

Produce una salida gráfica como una ruta que comienza en las coordenadas (0,0). ¡Pruébalo en MATL Online! O vea algunos ejemplos fuera de línea a continuación:

• Entrada 7:

  

  Salida:

  

• Entrada 699050:

  

  Salida:

  

Si lo prefiere, puede ver la ruta como coordenadas complejas para 9 bytes :

J_iB^YsJ+

Pruébalo en línea!

Explicación

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 bytes

YsG~YsQ1Z?

Introduce una matriz de dígitos binarios. Emite una matriz.

Pruébalo en línea!

Explicación

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 bytes

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

Pruébalo en línea!

Versión recursiva:

Python 2 , 71 69 67 bytes

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

Pruébalo en línea!

Carbón , 22 20 19 11 10 bytes

Ｆ⮌Ｓ¿Ｉι↑*←*

Solo mi segunda respuesta de Carbón hasta ahora.

Toma la entrada como cadena binaria (es decir, 699050como 10101010101010101010).

-9 bytes gracias a @Neil que sugiere hacer un bucle hacia atrás.

Pruébalo en línea.

Explicación:

Lea STDIN como cadena en orden inverso:

Reverse(InputString())
⮌Ｓ

Pase sobre sus dígitos binarios como cadenas ι:

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

Si se ιdevuelve a un número 1, imprima *hacia arriba, de lo contrario, imprima *hacia la izquierda.

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

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

Se guardaron 32 bytes debido a que la entrada se puede recibir como una matriz de bits.
Guardado 7 bytes gracias a @auhmaan.
Guardado 10 bytes gracias 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;}

Pruébalo en línea!

05AB1E , 18 17 14 bytes

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

Pruébalo en línea!

Explicación

γ€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 bytes gracias a @Emigna

05AB1E explicación del lienzo

Python 2 , 59 bytes

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

Pruébalo en línea!

Basado en la solución de TFeld .

Haskell , 65 bytes

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

Pruébalo en línea!

Toma datos como una lista de booleanos.

Curry PAKCS, 70 bytes

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

Puerto de la respuesta de Haskell, pero debido a <-que no funciona en Curry, necesitamos hacer una función auxiliar u. También necesitamos agregar un espacio entre fy .para que Curry lo analice como una composición en lugar de un punto.

Esto también funciona en MCC Curry, pero no funciona en Sloth Curry (que es el único compatible con TIO).

Haskell , 74 70 67 62 bytes

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

Pruébalo en línea! Toma una lista de ceros y unos como entrada y devuelve una cadena separada por una nueva línea.

Inspirado por la respuesta de xnor .

Emojicode , 251 bytes

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

Pruébalo en línea!

Definitivamente, esta no es una solución de golf, pero no hay una persona viva que considere el código Emoji como un lenguaje de golf. Sin embargo, en el proceso de someterme a los horrores que son la sintaxis del código emoji en un esfuerzo por enseñarme esta monstruosidad de un idioma, me sorprendió gratamente lo poderoso y eficiente que puede ser 😀

Explicación:

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

El mismo formato de E / S y la misma lógica que la versión recursiva a continuación.

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

Pruébalo en línea!

O 42 bytes si este formato es aceptable.

Versión recursiva, 56 bytes.

Toma la entrada como una matriz de enteros (0 o 1). Usos 0para llenado y espacio para vacío.

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

Pruébalo en línea!

Comentado

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 utilidades, 38

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

Aquí ^Ky ^Hson literales caracteres de tabulación vertical y de control de retroceso. Estos no se procesan bien en los navegadores, por lo que este script se puede recrear de la siguiente manera:

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

Corre en una terminal. La entrada es a través de STDIN.

Esta respuesta puede extender las especificaciones demasiado: de hecho, no hay caracteres iniciales en cada línea de salida; todo el posicionamiento se realiza con caracteres de control. Si esto es demasiado, entonces la salida se puede canalizar |col -x|tacpor 11 bytes adicionales.

Lote, 113 bytes

@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

Toma una lista de bits como argumentos de línea de comandos. Utiliza en +lugar de *porque *tiene un significado especial dentro de las %s:...=...%expansiones.

Java 10, 100 106 bytes

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

Toma una matriz de booleanos y devuelve una cadena ( 0s están vacías, 1s están llenas). Pruébalo en línea aquí .

Gracias a Olivier Grégoire por ayudarme a jugar al golf un poco más y alertarme sobre el hecho de que mi formato de salida no estaba a la altura de las especificaciones.

Versión sin golf:

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 bytes

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

Pruébalo en línea!

• Admite como máximo 20 bits.
• Entrada como int[]
• Salida como int[][]

Haskell , 126 bytes

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

Ingrese como una lista de ceros y unos. Transforma el número en desplazamiento x↦[1-x,x]y calcula las sumas parciales. La salida final se realiza con dos comprensiones de listas anidadas.

Pruébalo en línea!

R , 59 bytes

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

Pruébalo en línea!

Toma la entrada como una matriz de bits.

Devuelve una matriz booleana de TRUEy que FALSErepresenta a *y a , respectivamente.

También tiene algunas cosas en el pie de página para imprimir una matriz correspondiente a las especificaciones anteriores, para facilitar la prueba.

APL + WIN, 65 o 46 bytes

Solicita la entrada del entero

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

o para el vector numérico de la representación binaria del entero

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

Suponiendo que he leído los comentarios de ciertas respuestas correctamente y se permite la última entrada.

Pyth, 23 bytes

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

Pruébalo aquí

Explicación

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 bytes

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

Pruébalo en línea!

Cortarlo después de que me di cuenta de que la entrada podría ser una cadena de bits.

SmileBASIC, 64 59 57 bytes

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

El bit más alto (bit de signo) está marcado y, si es 1, la posición X aumenta. Si el bit de signo es menor que la posición X (es decir, el bit de signo es 0 y X no es 0), la posición Y aumenta.

El primer movimiento siempre será horizontal, por lo que el movimiento Y se bloquea hasta después del primer movimiento X. Esto asegura que la posición Y no aumente durante los 0 bits iniciales.

Entonces N se desplaza a la izquierda, y esto se repite hasta que N alcanza 0.

Ruby , 63 bytes

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

Pruébalo en línea!

Japt , 19 17 bytes

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

Toma la entrada como una matriz de bits, por ejemplo [1,0,1], salidas en "lugar de *.
Afeitado dos bytes gracias a Oliver .

Pruébalo en línea!

Python 2, 113 bytes

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)

No estoy seguro de si este cuenta (genera una matriz de cada una de las líneas), pero si es así, cambiaré mi recuento de bytes a 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 bytes

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]

Solicita una lista booleana, devuelve una matriz de 0 y 1.

Recorre la lista, incrementa X si el siguiente 'bit' es 0, cambia Y de lo contrario, luego agrega un 1 a la matriz en esa ubicación y devuelve la matriz al final.

TI-Basic es un idioma tokenizado .

• 1 byte: Prompt , L* 6, (salto de línea) * 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 bytes
• 2 bytes: Delvar , [A]* 5 = 12 bytes
• Total: 85 bytes

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

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

Los mismos procesos que el anterior, pero usando salida gráfica (limitada por el tamaño de la pantalla: 10 filas, 26 columnas, por lo tanto, 10 1s y 25 0s como máximo), en lugar de agregar a una matriz.

Pyth, 30 bytes

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

Pruébalo en línea!

Usos " lugar 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 bytes

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 bytes

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

Pruébalo en línea!