对于n满足的整数，请n > 0根据其二进制表示形式将其值写为右降路径。

规则

• 第一个（最高有效）置位总是在左上角。
• 设置下一位（a 1）后，在与上一个绘制的字符相同的列中的下一行绘制一个字符（“填充”）。尝试使用空格（“空”）进行填充，但是只要字符始终相同，任何字符都可以。
• 当下一位未设置（a 0）时，在同一行上紧接着绘制的上一个字符的右侧绘制一个字符（“填充”）。
• 您的代码必须支持至少20个有效位的数字。
• 编写完整的程序，函数，lambda等，但不要编写任何代码段。
• 不允许前导空格（或“空”字符）/行
• 允许任意数量的尾随空格（或“空”字符）/行
• 可以接受任何类型的一维输入：数字，字符串，布尔数组等。不过，请保持位的顺序不变。
• 可以接受任何形式的可视2D输出：在stdout上，是一个字符串（任何两个不同的值分别表示“ filled”和“ empty”），如果需要，您甚至可以输出矩阵。数字列表似乎很难与“无标题空间”规则相协调，但是如果您找到使用它的方法，我将持开放态度。注意：如果选择打印或返回字符串，则使用的字符必须是代码点范围[32-126]中的ASCII字符。
• 禁止出现标准漏洞。
• 这是codegolf，所以最短的代码获胜。

例子

输入1

*

输入2

**

输入3

*
*

输入4

***

输入5

**
 *

输入6

*
**

输入7

*
*
*

输入：25

*
***
  *

输入：699050

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

输入：1047552

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

输入：525311

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

果冻，8 字节

¬œṗ+\Ṭz0

单数链接接受一个数字作为一和零的列表（例如13is [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

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

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

Python 2中，100个 99 81 78 73 66字节

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

在线尝试！

递归版本：

Python 2中，71个 69 67字节

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

在线尝试！

木炭，22 20 19 11 10 字节

Ｆ⮌Ｓ¿Ｉι↑*←*

到目前为止，我只有第二个木炭回答。

将输入作为二进制字符串（即699050as 10101010101010101010）。

-9个字节，感谢@Neil建议向后循环。

在线尝试。

说明：

以相反的顺序将STDIN读取为字符串：

Reverse(InputString())
⮌Ｓ

将其二进制数字作为字符串循环ι：

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

如果ι将数字强制转换为1，则*向上打印，否则*向左打印。

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

C＃（.NET核心），155 123 120 113 101字节

由于能够以位数组形式接收输入，因此节省了32个字节。
感谢@auhmaan，节省了7个字节。
感谢@KevinCruijssen，节省了10个字节。

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

在线尝试！

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字节感谢@Emigna

05AB1E帆布的解释

Python 2，59个字节

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

在线尝试！

基于TFeld的解决方案。

Haskell，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

Haskell答案的端口号，但是由于<-在Curry中不起作用，我们需要创建一个辅助函数u。我们还需要在f和之间添加一个空格，.以便Curry将其解析为一个组合而不是一个点。

这也适用于MCC Curry，但不适用于Sloth Curry（这是TIO唯一支持的一种）。

Haskell，74 70 67 62字节

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

在线尝试！接受零和一的列表作为输入，并返回换行符分隔的字符串。

受到xnor的回答的启发。

表情符号，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🍉

在线尝试！

这绝对不是打高尔夫球的解决方案，但是没有一个人会考虑将Emoji代码编码为打高尔夫球的语言。但是，在让自己经受表情符号代码语法的恐惧之后，才告诉自己这种语言的怪异之处，让我感到惊喜的是它的强大和高效😀

说明：

🐋 🚂 🍇    👴 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个字节

与下面的递归版本相同的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

Bash + GNU实用程序，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个字节。

批处理，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:...=...%扩展内部具有特殊含义。

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

接受一个布尔数组并返回一个String（0s为空，1s被填充）。在这里在线尝试。

感谢OlivierGrégoire帮助我进一步打高尔夫球，并提醒我注意我的输出格式不符合规范。

非高尔夫版本：

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字节

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

在线尝试！

• 最多支持20位。
• 输入为 int[]
• 输出为 int[][]

Haskell，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]]

输入为零和一的列表。将数字转换为offset x↦[1-x,x]并计算部分和。最终输出是通过两个嵌套列表推导完成的。

在线尝试！

R，59个字节

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

在线尝试！

将输入作为位数组。

返回一个布尔矩阵TRUE和FALSE表示*和一个分别。

页脚中还有一些东西可以打印与上述规格相对应的矩阵，以便于测试。

APL + WIN，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

假设我已正确阅读某些答案的注释，并且允许后者输入。

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

Perl 5中 -p，54 36个字节

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

在线尝试！

在意识到输入可能是一个字符串之后，将其削减。

SmileBASIC，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位期间Y位置不会增加。

然后N左移，重复直到N达到0。

红宝石，63字节

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

在线尝试！

Japt，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]，将输出"代替*。
多亏了奥利弗，剃光了两个字节。

在线尝试！

Python 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

TI基本（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，则将X递增，否则将Y更改，然后在该位置的矩阵上添加1，最后返回矩阵。

TI-Basic是一种标记化语言。

• 1个字节：Prompt ，L* 6，（换行符）* 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个字节
• 2个字节： Delvar ，[A] * 5 = 12个字节
• 总计：85个字节

TI基本（TI-84 Plus CE），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），而不是添加到矩阵中。

Pyth，30个字节

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

在线尝试！

用"代替*。

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字节

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字节

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

在线尝试！