Đối với một số nguyên nthỏa mãn n > 0, hãy viết giá trị của nó dưới dạng đường dẫn giảm dần phải dựa trên biểu diễn nhị phân của nó.

Quy tắc

• Bit thiết lập đầu tiên (quan trọng nhất) luôn nằm ở góc trên cùng bên trái.
• Khi bit tiếp theo được đặt (a 1), vẽ một ký tự ("điền") trên dòng tiếp theo trong cùng cột với ký tự trước đó được vẽ. Cố gắng sử dụng khoảng trắng ("trống") để điền, nhưng bất kỳ ký tự nào cũng sẽ làm miễn là nó luôn giống nhau.
• Khi bit tiếp theo không được đặt (a 0), vẽ một ký tự ("điền") trên cùng một dòng ngay bên phải của ký tự trước đó được vẽ.
• Mã của bạn phải hỗ trợ các số có ít nhất 20 bit đáng kể.
• Viết một chương trình đầy đủ, một chức năng, lambda, v.v. nhưng không có đoạn trích.
• Không có khoảng trắng hàng đầu (hoặc "trống" char) / dòng được phép
• Bất kỳ số lượng dấu cách (hoặc "trống" char) / dòng được phép
• Bất kỳ loại đầu vào 1D nào cũng được chấp nhận: số, chuỗi, mảng booleans, v.v ... Giữ nguyên thứ tự các bit không được chạm tới.
• Bất kỳ loại đầu ra 2D trực quan nào đều được chấp nhận: trên thiết bị xuất chuẩn, một chuỗi (với bất kỳ hai giá trị riêng biệt nào đại diện cho "đầy" và "trống"), bạn thậm chí có thể xuất ma trận nếu muốn. Một danh sách các con số có vẻ khó đối chiếu với quy tắc "không có không gian tiêu đề", nhưng tôi sẽ mở nó nếu bạn tìm cách sử dụng nó. Lưu ý: nếu bạn chọn in hoặc trả về một chuỗi, các ký tự được sử dụng phải là các ký tự ASCII trong phạm vi mã hóa [32-126].
• Sơ hở tiêu chuẩn bị cấm.
• Đây là codegolf nên mã ngắn nhất sẽ thắng.

Ví dụ

Đầu vào: 1

*

Đầu vào: 2

**

Đầu vào: 3

*
*

Đầu vào: 4

***

Đầu vào: 5

**
 *

Đầu vào: 6

*
**

Đầu vào: 7

*
*
*

Đầu vào: 25

*
***
  *

Đầu vào: 699050

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

Đầu vào: 1047552

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

Đầu vào: 525311

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

Thạch , 8 byte

¬œṗ+\Ṭz0

Một liên kết monadic chấp nhận một số như một danh sách của những người thân và số không (ví dụ như 13là [1,1,0,1]) trả về một danh sách liệt kê của những người thân và số không ở đâu danh sách đầu tiên là hàng đầu tiên.

Hãy thử trực tuyến! hoặc xem một bộ kiểm tra định dạng

Làm sao?

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

Tạo đầu ra đồ họa dưới dạng đường dẫn bắt đầu từ tọa độ (0,0). Hãy thử nó tại MATL Online! Hoặc xem một số ví dụ ngoại tuyến bên dưới:

• Đầu vào 7:

  

  Đầu ra:

  

• Đầu vào 699050:

  

  Đầu ra:

  

Nếu bạn thích, bạn có thể xem đường dẫn dưới dạng tọa độ phức tạp cho 9 byte :

J_iB^YsJ+

Hãy thử trực tuyến!

Giải trình

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?

Nhập một mảng các chữ số nhị phân. Xuất ra một ma trận.

Hãy thử trực tuyến!

Giải trình

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:]

Hãy thử trực tuyến!

Phiên bản đệ quy:

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''

Hãy thử trực tuyến!

Than , 22 20 19 11 10 byte

Ｆ⮌Ｓ¿Ｉι↑*←*

Chỉ có câu trả lời Char than thứ hai của tôi cho đến nay.

Lấy đầu vào là chuỗi nhị phân (tức 699050là 10101010101010101010).

-9 byte nhờ @Neil đề xuất lặp lại.

Hãy thử trực tuyến.

Giải trình:

Đọc STDIN dưới dạng chuỗi theo thứ tự đảo ngược:

Reverse(InputString())
⮌Ｓ

Lặp lại các chữ số nhị phân của nó dưới dạng chuỗi ι:

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

Nếu ιđúc trở lại một số là 1, in *hướng lên trên, mặt khác in *về phía bên trái.

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

C # (Lõi .NET) , 155 123 120 113 101 byte

Đã lưu 32 byte do đầu vào có thể được nhận dưới dạng một mảng bit.
Đã lưu 7 byte nhờ @auhmaan.
Đã lưu 10 byte nhờ @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;}

Hãy thử trực tuyến!

05AB1E , 18 17 14 byte

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

Hãy thử trực tuyến!

Giải trình

γ€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 nhờ @Emigna

Giải thích của 05AB1E

Python 2 , 59 byte

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

Hãy thử trực tuyến!

Dựa trên giải pháp của TFeld .

Haskell , 65 byte

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

Hãy thử trực tuyến!

Đưa đầu vào như một danh sách các booleans.

Cà ri PAKCS, 70 byte

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

Cổng câu trả lời của Haskell, nhưng vì <-không hoạt động ở Curry, chúng tôi cần thực hiện chức năng trợ giúp u. Chúng ta cũng cần thêm một khoảng trắng ở giữa fvà .để Curry phân tích nó dưới dạng một sáng tác chứ không phải là một dấu chấm.

Điều này cũng hoạt động trong MCC Curry, nhưng không hoạt động trong Sloth Curry (là người duy nhất được TIO hỗ trợ).

Haskell , 74 70 67 62 byte

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

Hãy thử trực tuyến! Lấy danh sách các số 0 và số 0 làm đầu vào và trả về một chuỗi phân tách dòng mới.

Lấy cảm hứng từ câu trả lời của xnor .

Biểu tượng cảm xúc , 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🍉

Hãy thử trực tuyến!

Đây chắc chắn không phải là một giải pháp chơi gôn, nhưng không có ai còn sống sẽ coi mã Emoji là ngôn ngữ chơi gôn. Tuy nhiên, trong quá trình chịu đựng sự khủng khiếp của cú pháp mã biểu tượng cảm xúc để dạy cho bản thân sự quái dị của ngôn ngữ này, tôi đã ngạc nhiên khi thấy nó có thể mạnh mẽ và hiệu quả đến mức nào

Giải thích:

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

Định dạng I / O tương tự và logic giống như phiên bản đệ quy bên dưới.

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

Hãy thử trực tuyến!

Hoặc 42 byte nếu định dạng này được chấp nhận.

Phiên bản đệ quy, 56 byte

Lấy đầu vào dưới dạng một mảng các số nguyên (0 hoặc 1). Công dụng0 cho đầy và không gian trống.

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

Hãy thử trực tuyến!

Đã bình luận

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

Tiện ích Bash + GNU, 38

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

Ở đây ^Kvà ^Hlà các ký tự điều khiển tab dọc và backspace theo nghĩa đen. Chúng không hiển thị tốt trên các trình duyệt, vì vậy tập lệnh này có thể được tạo lại như sau:

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

Chạy trong một thiết bị đầu cuối. Đầu vào là thông qua STDIN.

Câu trả lời này có thể kéo dài các thông số kỹ thuật quá xa - trên thực tế không có ký tự đầu nào trên mỗi dòng đầu ra - tất cả định vị được thực hiện với các ký tự điều khiển. Nếu điều này là quá nhiều, thì đầu ra có thể được chuyển sang |col -x|tacthêm 11 byte.

Mẻ, 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

Lấy danh sách các bit làm đối số dòng lệnh. Công dụng+ thay *vì bởi vì *có một ý nghĩa đặc biệt bên trong %s:...=...%mở rộng.

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

Lấy một mảng các booleans và trả về một Chuỗi 0trống,1 s được điền). Dùng thử trực tuyến tại đây .

Nhờ vào Olivier Grégoire vì đã giúp tôi chơi golf nhiều hơn một chút và cảnh báo tôi về thực tế là định dạng đầu ra của tôi không đúng với thông số kỹ thuật.

Phiên bản bị đánh cắp:

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

Hãy thử trực tuyến!

• Hỗ trợ tối đa 20 bit.
• Nhập như int[]
• Đầu ra như 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]]

Nhập dưới dạng danh sách các số 0 và số. Chuyển đổi số thành bù bằng x↦[1-x,x]và tính tổng một phần. Đầu ra cuối cùng được thực hiện với hai cách hiểu danh sách lồng nhau.

Hãy thử trực tuyến!

R , 59 byte

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

Hãy thử trực tuyến!

Đưa đầu vào như một mảng bit.

Trả về một ma trận boolean của TRUEvà FALSEđại diện cho a *và a tương ứng .

Cũng có một số nội dung trong phần chân trang để in một ma trận tương ứng với các thông số kỹ thuật ở trên, để dễ kiểm tra.

APL + THẮNG, 65 hoặc 46 byte

Lời nhắc cho đầu vào của số nguyên

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

hoặc cho vectơ số của biểu diễn nhị phân của số nguyên

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

giả sử tôi đã đọc các bình luận cho một số câu trả lời chính xác và đầu vào sau được cho phép.

Bình thường, 23 byte

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

Hãy thử nó ở đây

Giải trình

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

Hãy thử trực tuyến!

Cắt nó xuống sau khi tôi nhận ra rằng đầu vào có thể là một chuỗi 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

Bit cao nhất (bit dấu) được chọn và nếu là 1, vị trí X sẽ tăng. Nếu bit dấu nhỏ hơn vị trí X (nghĩa là bit dấu là 0 và X không bằng 0) thì vị trí Y tăng.

Chuyển động đầu tiên sẽ luôn luôn theo chiều ngang, do đó chuyển động Y bị chặn cho đến sau chuyển động X đầu tiên. Điều này đảm bảo rằng vị trí Y không tăng trong 0 bit hàng đầu.

Sau đó N được dịch chuyển sang trái và điều này lặp lại cho đến khi N đạt 0.

Ruby , 63 byte

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

Hãy thử trực tuyến!

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.

Lấy đầu vào là một mảng các bit, ví dụ [1,0,1], đầu ra "thay vì *.
Cạo hai byte nhờ Oliver .

Hãy thử trực tuyến!

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)

Không chắc chắn nếu cái này được tính (nó xuất ra một mảng của mỗi dòng), nhưng nếu vậy thì tôi sẽ thay đổi số byte của mình thành 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]

Nhắc nhở cho một danh sách boolean, trả về ma trận 0 và 1.

Đi qua danh sách, tăng X nếu 'bit' tiếp theo là 0, thay đổi Y theo cách khác, sau đó thêm 1 vào ma trận tại vị trí đó và trả về ma trận ở cuối.

TI-Basic là một lanug tokenized .

• 1 byte : Prompt , L* 6, (dòng mới) * 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
• Tổng cộng: 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

Tương tự như các quy trình như trên, nhưng sử dụng đầu ra đồ họa (giới hạn bởi kích thước màn hình: 10 hàng, 26 cột, vì vậy tối đa 10 1s và 25 0) như vậy, thay vì thêm vào ma trận.

Bình thường, 30 byte

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

Hãy thử trực tuyến!

Sử dụng "thay vì* .

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,⎕

Hãy thử trực tuyến!