를 n만족 하는 정수 n > 0의 경우 이진 표현을 기반으로 값을 오른쪽 내림차순으로 작성하십시오.

규칙

• 첫 번째 (가장 중요한) 세트 비트는 항상 왼쪽 상단에 있습니다.
• 다음 비트가 설정되면 (a 1), 이전에 그린 문자와 같은 열의 다음 줄에 문자 ( "채워진")를 그립니다. 공백 ( "빈")을 사용하여 채우십시오. 그러나 모든 문자는 항상 같은 길이를 유지합니다.
• 다음 비트가 설정 해제되면 (a 0), 이전에 그린 문자 바로 오른쪽에 같은 줄에 문자 ( "채워진")를 그립니다.
• 코드는 유효 비트가 20 개 이상인 숫자를 지원해야합니다.
• 전체 프로그램, 함수, 람다 등을 작성하지만 스 니펫은 작성하지 마십시오.
• 선행 공백 (또는 "빈"문자) / 라인이 허용되지 않습니다
• 후행 공백 (또는 "빈"문자) / 줄 허용
• 숫자, 문자열, 부울 배열 등 모든 종류의 1D 입력이 허용됩니다. 비트 순서는 그대로 유지하십시오.
• 모든 종류의 시각적 2D 출력이 허용됩니다. stdout에서 문자열 ( "filled"및 "empty"를 나타내는 두 개의 고유 한 값이있는 문자열)에서 원하는 경우 행렬을 출력 할 수도 있습니다. 숫자 목록은 "제목 없음"규칙과 조정하기 어려워 보이지만 사용 방법을 찾으면 열 수 있습니다. 참고 : 문자열을 인쇄하거나 반환하기로 선택한 경우 사용 된 문자는 코드 포인트 범위 [32-126]의 ASCII 문자 여야합니다.
• 표준 허점 은 금지되어 있습니다.
• 이것은 codegolf이므로 가장 짧은 코드가 승리합니다.

예

입력 : 1

*

입력 : 2

**

입력 : 3

*
*

입력 : 4

***

입력 : 5

**
 *

입력 : 6

*
**

입력 : 7

*
*
*

입력 : 25

*
***
  *

입력 : 699050

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

입력 : 1047552

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

입력 : 525311

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

젤리 , 8 바이트

¬œṗ+\Ṭz0

1과 0의리스트로서 참조 수용성 모나드 링크 (예 13이며 [1,1,0,1]제리스트의 첫 번째 행이고 0과리스트의 목록을 반환).

온라인으로 사용해보십시오! 또는 형식화 된 시험 스위트를 참조하십시오

방법?

¬œṗ+\Ṭ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 Online 에서 사용해보십시오 ! 또는 아래 오프라인 예를 참조하십시오.

• 입력 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

파이썬 2 , 100 99 81 78 73 66 바이트

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

온라인으로 사용해보십시오!

재귀 버전 :

파이썬 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 바이트

Ｆ⮌Ｓ¿Ｉι↑*←*

지금까지 나의 두 번째 숯만 대답합니다.

이진 문자열로 입력 (예 : 소요 699050등을 10101010101010101010).

@Neil 덕분에 -9 바이트는 역방향 루프를 제안합니다.

온라인으로 사용해보십시오.

설명:

문자열로 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 :-)

• @Emigna 덕분에 3 바이트

05AB1E 캔버스 설명

파이썬 2 , 59 바이트

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

온라인으로 사용해보십시오!

TFeld의 솔루션을 기반으로합니다 .

하스켈 , 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하고 .그래서 카레가 작성보다는 점으로 그것을 구문 분석.

MCC Curry에서도 작동하지만 Sloth Curry (TIO에서 지원하는 유일한 것)에서는 작동하지 않습니다.

하스켈 , 74 70 67 62 바이트

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

온라인으로 사용해보십시오! 0과 1의 목록을 입력으로 받아서 개행으로 구분 된 문자열을 반환합니다.

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-code를 골프 언어로 생각할 사람은 아직 없습니다. 그러나이 언어의 괴물을 스스로 가르치기 전에 이모티콘 코드의 구문 인 공포에 자신을 적용하는 과정에서 나는 그것이 얼마나 강력하고 효율적일 수 있는지에 놀랐습니다.

설명 :

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

자바 스크립트 (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

배쉬 + 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는 채워짐). 여기에서 온라인으로 사용해보십시오 .

골프를 조금 더 도와주고 출력 형식이 사양에 맞지 않았다는 사실을 알려주는 Olivier Gré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
}

자바 (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[][]

하스켈 , 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]]

0과 1의 목록으로 입력하십시오. 숫자를 오프셋으로 변환 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 *.

펄 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]: "대신 출력 ) *. Oliver
덕분에 2 바이트를 줄 였습니다.

온라인으로 사용해보십시오!

파이썬 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(, End73 바이트 =
• 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 1 및 25 0으로 제한됨)을 사용합니다.

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

온라인으로 사용해보십시오!