숫자 n이 주어지면 이 패턴 의 처음 n 열을 생성하십시오 .

                               #
               #               #
       #       #       #       #
   #   #   #   #   #   #   #   #
 # # # # # # # # # # # # # # # #
################################ ...

(1 인덱싱 된) n 에서 열의 높이는 n 의 이진 표현 에있는 후행 0비트 수에 1을 더한 값입니다. 결과적으로 맨 아래 레이어에는 모든 열이 채워지고 두 번째 레이어는 두 번째 열마다, 세 번째 레이어는 네 번째 열마다

규칙

• 표준 방법을 통해 입력 및 출력 할 수 있습니다.
• 입력이 1에서 999 사이의 정수라고 가정 할 수 있습니다.
• 패턴에 손상이없는 한 출력에 공백이 포함될 수 있습니다.
• 패턴은 1- 색인이어야하며 여기에 표시된 것과 동일한 형식이어야합니다.
• 대신 공백이 아닌 단일 문자 #를 사용할 수 있지만 공백 문자는 변경할 수 없습니다.

테스트 사례

1
#

2
 #
##

3
 # 
###

4
   #
 # #
####

5
   # 
 # # 
#####

7
   #   
 # # # 
#######

32
                               #
               #               #
       #       #       #       #
   #   #   #   #   #   #   #   #
 # # # # # # # # # # # # # # # #
################################

몇 가지 더 큰 테스트 사례는 여기 에서 찾을 수 있습니다 .

채점

이것은 code-golf 이므로 각 언어에서 가장 짧은 바이트 단위의 코드가 이깁니다.

파이썬 2 , 54 바이트

i=n=input()
while i:i-=1;print((' '*~-2**i+'#')*n)[:n]

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

많은 선행 공백으로 인쇄합니다. i에서 카운트 다운하는 각 행 n은 2**i-1공백 패턴과 그 뒤에 반복되는 패턴을 반복 합니다 #. 이 패턴은 입력자인 자의 너비까지 반복됩니다 n. 패턴 문자열에 곱하고 n첫 n문자를로 사용하면 [:n]됩니다.

동일한 길이의 대안으로 문자열 형식을 지정하여 패턴을 만들 수 있습니다.

i=n=input()
while i:i-=1;print('%%%ds'%2**i%'#'*n)[:n]

귀여운 슬라이싱 방법이 더 깁니다.

n=input();s=~-2**n*' '+'#'
exec"s=s[1::2]*2;print s[:n];"*n

파이썬 3 , 74 바이트

n=int(input())
a=1
while a<n:a*=2
while a:print(("%%%dd"%a%4*n)[:n]);a//=2

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

V , 17 , 16 바이트

é#Àñä}Är {ñÎÀlD

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

16 진 덤프 :

00000000: e923 c0f1 e416 7dc4 7220 7bf1 cec0 6c44  .#....}.r {...lD

1 바이트를 절약 한 @KritixiLithos에 감사합니다!

이 알고리즘은 끔찍하게 비효율적이지만 이론적으로 모든 크기의 입력에서 작동합니다.

다음 패턴 의 첫 번째 n 반복을 생성하여 작동합니다 .

#

 #
##

   #
 # #
####

       #
   #   #
 # # # #
########

               #
       #       #
   #   #   #   #
 # # # # # # # #
################

                               #
               #               #
       #       #       #       #
   #   #   #   #   #   #   #   #
 # # # # # # # # # # # # # # # #
################################

그런 다음 첫 번째 n 열을 제외한 모든 열 을 잘라냅니다 . 따라서 이로 인해 많은 선행 공백이 생성되지만 OP는 다음과 같이 말했습니다.

패턴에 손상이없는 한 출력에 공백이 포함될 수 있습니다.

설명:

é#                      " Insert an '#'
  Àñ           ñ        " 'N' times:
    ä<C-v>}             "   Duplicate every line blockwise (duplicating horizontally instead of vertically)
           Ä            "   Duplicate the top line. This conveniently puts us on the first non-whitespace character (that is, '#')
            r           "   Replace this character with a space
              {         "   Move to the beginning of the buffer
                Î       " On every line:
                 Àl     "   Move 'N' characters to the right ('l' for right, makes sense, right?)
                   D    "   And delete everything after the cursor

자바 스크립트 (ES6), 61 58 바이트

f=(n,c=n,s='')=>c?f(n,c>>1,s+s+' ')+`
`+(s+1).repeat(c):''

@ETHProductions 덕분에 1 바이트를 절약 한 다음 모든 문자를 사용할 수 있음을 알았을 때 2 바이트를 더 절약했습니다.

재귀 솔루션.

테스트 사례 :

f=(n,c=n,s='')=>c?f(n,c>>1,s+s+' ')+`
`+(s+1).repeat(c):''

console.log(f(32));
console.log(f(1));  
console.log(f(5));  
console.log(f(7));  

생기:

f=(n,c=n,s='')=>c?f(n,c>>1,s+s+' ')+`
`+(s+1).repeat(c):''

for(let i = 1 ; i < 64 ; i++) {
  setTimeout(_=>document.querySelector('pre').textContent=f(i), i*40);
}

<pre>

APL (Dyalog) , 21 바이트

'# '[1+⊖0⍪∨⍀⊖2⊥⍣¯1⍳⎕]

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

'# '[…`]로 문자열을 색인

 ⎕ 입력 받기

 ⍳ 그 많은 내가 ntegers

 2⊥⍣¯1 필요한만큼의 숫자를 사용하여 이진수로 변환합니다 (각 열에 하나씩 )

 ⊖ 거꾸로 뒤집다

 ∨⍀ 수직 누적 OR 감소

 0⍪ 상단에 0을 연결

 ⊖ 거꾸로 뒤집습니다 (즉, 다시 백업)

 1+ 하나 추가 (1 기반 색인 작성)

젤리 , 11 10 바이트

Rọ2‘4ẋz⁶ṚY

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

OP 후 1 바이트가 절약되어 문자가 필요하지 않은 완화를 추가했습니다 #.

옥타브, 45 바이트

@(n)[[sort(cummin(de2bi(g=0:n)'));g|1]+32 '']

Octave Online 에서 사용해보십시오 !

'#'인쇄 대신 '!'.

PHP , 139 바이트

for($f=array_fill(0,$l=1+log($a=$argn,2)," ");$n++<$a;)for($h=1+strspn(strrev(decbin($n)),$i=0);$i<$h;)$f[$l-++$i][$n]=3;echo join("
",$f);

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

apt , 20 17 바이트

@Shaggy 및 @ETHproductions 덕분에 3 바이트 절약

õ_¤q1 o Ä ço÷z w

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

설명:

입력 : 5

õ_¤q1 o Ä ço÷z w
õ           Ã       // Create a range [1...Input] [1,2,3,4,5]
 _                  // Map; At each item:
  ¤                 //   Convert to binary        ["1","10","11","100","101"]
   q1               //   Split on "1"             [["",""],["","0"],["","",""],["","00"],["","0",""]]
      o             //   Get the last item        ["","0","","00",""]
        Ä           //   Add 1                    [["1","01","1","001","1"]]
          ço        //   Fill with "o"            ["o","oo","o","ooo","o"]
             ·      // Join with new-lines        ["o\noo\no\nooo\no"]
              z     // Rotate 90 degrees          ["ooooo\n o o \n o   "]
                w   // Reverse                    ["   o \n o o \nooooo"]

C, 84 74 바이트

f(i,l,m){putchar(32+3*!(i&m));i<l?f(i+1,l,m):m?putchar(10),f(1,l,m>>1):1;}

언 골프 드 :

void f(int counter, int length, int mask) {
    putchar((counter&mask) ? ' ' : '#');
    if(counter<length) {
        f(counter+1, length, mask);
    } else if(mask) {
        putchar('\n');
        f(1, length, mask>>1);
    }
}

다음을 사용하여 테스트하십시오.

int main() {
    f(1, 32, 1023);
    putchar('\n');
    f(1, 1, 1023);
    putchar('\n');
    f(1, 999, 1023);
    putchar('\n');
}

설명

다시 한번, 재귀는 반복보다 C에서 문자가 덜 걸리므로 두 개의 루프는 두 개의 재귀 호출로 표현됩니다.

또한 C는 부울 식을 사용하여 트릭을 재생하는 데 유용한 언어로, 공백으로 넣을지 또는 #표현으로 표현할 지를 결정할 수 있습니다 32+3*!(i&m). 공백은 ASCII 값이 32이고 #ASCII는 35이므로 마스크의 비트가에 설정되어 있으면 공백이됩니다 i.

피스 , 15 바이트

j_.tm*Nhx_.Bd1S

시도 해봐!

설명

j_.tm*Nhx_.Bd1S
    m         SQ   # map over the numbers from 0 to the implicit input (lambda variable: d)
          .Bd      # Convert d to a binary string: (12 -> 1100)
         _         # reverse: (1100 -> 0011)
        x    1     # get the location of the first 1 ( 2 )
     *Nh           # make one more than that " quotation marks (""")
 _.t               # transpose the list of quotation mark strings and reverse it
j                  # join on newline

파이썬 2 , 47 바이트

f=lambda n:n and' '.join(f(n/2))+'\n'+n*'#'or''

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

자바 스크립트 (ES8), 71 바이트

padStart () 함수는 ECMAScript를 2017 년에 도입되었다!

N=>eval(`for(s='',n=1;n<=N;n*=2)s='\\n'+'#'.padStart(n).repeat(N/n)+s`)

f=
N=>eval(`for(s='',n=1;n<=N;n*=2)s='\\n'+'#'.padStart(n).repeat(N/n)+s`)

console.log(f(+prompt()))

자바 스크립트 (ES6), 77 바이트

N=>eval(`for(s='',n=1;n<=N;n*=2)s='\\n'+(' '.repeat(n-1)+'#').repeat(N/n)+s`)

f=
N=>eval(`for(s='',n=1;n<=N;n*=2)s='\\n'+(' '.repeat(n-1)+'#').repeat(N/n)+s`)

console.log(f(+prompt()))

수학, 69 바이트

Rotate[Grid["#"~Table~#&/@(IntegerExponent[2*#,2]&/@Range[#])],Pi/2]&

( WESRRMICGSE ) : 237 바이트

IF(ROW()<=FLOOR(LOG(COUNTA(R1C:R[-1]C,R[1]C:R[1024]C)+1,2),1)+2,LEFT(REPT(REPT(" ",FLOOR(POWER(2,LOG(COUNTA(R1C:R[-1]C,R[1]C:R[1024]C)+1,2)-ROW()+2),1)-1) &"#",COUNTA(R1C:R[-1]C,R[1]C:R[1024]C)+1),COUNTA(R1C:R[-1]C,R[1]C:R[1024]C)+1),"")

좋구나. '불쾌한 시간.

먼저 모든 것을 COUNTA(R1C:R[-1]C,R[1]C:R[1024]C)+1간단하게 교체하십시오.[i] 입력을 . 토큰은 셀을 포함하지 않고 셀을 포함하는 셀 수를 계산 한 다음 셀을 포함하여 셀을 포함합니다. WESRRMICGSE는 입력 한 입력에 따라 수식을 끌기 때문에이 토큰은 항상 입력이됩니다.

우리는 :

IF(ROW()<=FLOOR(LOG([i],2),1)+3,LEFT(REPT(REPT(" ",FLOOR(POWER(2,LOG([i],2)-ROW()+2),1)-1) &"#",[i]),[i]),"")

이것은 훨씬 더 읽기 쉽습니다. 당신은 FLOOR(LOG([i],2),1)토큰을 많이 보게 될 것입니다 . 이는 단순히 입력 ( [i]) 숫자 보다 작은 2의 가장 가까운 거듭 제곱을 취하는 것을 의미합니다 . 예 : 4->4, 5->4, 6->4, 7->4, 8->8 ...etc. 나는 그걸로 바꿀 것이다.GS[[i]]

IF(ROW()<=GS[[i]]+3,LEFT(REPT(REPT(" ",,FLOOR(POWER(2,LOG([i],2)-ROW()+2),1),1)-1) &"#",[i]),[i]),"")

보다 나은. if 절을 분류하면 GS[[i]]+3모든 눈금자의 높이가 GS [[i]] + 1과 같기 때문에 행이보다 작거나 같은지 테스트합니다. 이렇게하면 행 의 높이와 같은 행이 선택됩니다. 지배자. +11- 인덱싱 행의 경우+1 WESRRMICGSE 오프셋에 대해 다시.

FALSE결과는 빈 셀 ( ""), 그리고 진정한 결과 수익률을 산출LEFT(REPT(REPT(" ",,FLOOR(POWER(2,LOG([i],2)-ROW()+2),1),1)-1) &"#",[i]),[i])

현재 편집 중이며 계속 지켜봐 주시기 바랍니다

하스켈 , 64 62 바이트

l m=([2..2^m]>>" ")++'#':l m
f n=unlines$take n.l<$>[n,n-1..0]

온라인으로 사용해보십시오! 사용법 예 : f 10.

k, 33 바이트

`0:|" #"{(1+!x){~y!x}/:(x>)(2*)\1}

이것은 AW의 통역사 에서만 작동하는 것 같습니다 .

온라인으로 시도 할 수있는 oK 버전 에는 버그가있는 것으로 보이며 작동하려면 약간의 변경이 필요합니다.

`0:|" #"{(1+!x){~y!x}/:{x>y}[x](2*)\1}

C #, 174 바이트

이 방법에는 눈금자 길이에 대한 입력과 눈금자 인 문자열 출력이 있습니다.

골프 :

void R(int n,out string s){var l=new int[++n];int i,x=n,y=0;for(s="";x-->1;)for(i=0;0==(l[x]=(x>>i++&1)*i);y=y<i?i:y);for(y++;y-->0;s+='\n')for(x=0;++x<n;s+=y<l[x]?'#':' ');}

들여 쓰기 :

void R(int n,out string s){                       // Return the result in an out parameter.
    var l=new int[++n];                           // Use a 1-based array.
    int i,x=n,y=0;                                //
    for(s="";x-->1;)                              // For each number x on the ruler
        for(i=0;0==(l[x]=(x>>i++&1)*i);y=y<i?i:y) // ... find lowest set bit of x, counting the maximum value.
            ;                                     //
    for(y++;y-->0;s+='\n')                        // Count down each line.
        for(x=0;++x<n;s+=y<l[x]?'#':' ')          // Output # for numbers that are tall enough.
            ;                                     //
}

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

숯 , 27 23 바이트

↶Ｆ…·¹Ｎ«Ｊι⁰#Ｗ¬﹪鲫Ａ÷ι²ι#

온라인으로 사용해보십시오! 링크는 자세한 버전의 코드입니다. 편집 :로 전환하여 4 바이트를 저장했습니다 JumpTo.

J, 38 바이트

3 :'|.|:''#''#~,.(1+|.i.1:)@#:"0>:i.y'

안좋아. 바이트 수가 꺼져 있으면 Lmk입니다. 전화를 받고 있습니다.

자바 (OpenJDK 8) , 91 바이트

n->{int i=10,j;String s="";for(;i-->0;s+="\n")for(j=0;j++<n;)s+=j>>i<<i<j?' ':35;return s;}

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

언 골프 드 :

n->{
    int i=10,j; // Since we are allowed extra whitespace, set columns always to 10
    String s = "";
    for(;i-->0;s+="\n")      // Every iteration add a newline, i=9..0
        for(j=0;j++<n;)      // j=1..n+1
            s+= j>>i<<i<j    // if j has less than i trailing 0s in binary form
                ?' '         // add a space else
                :35          // # (java handles ternary return types weirdly)
}

CJam, 34 바이트

ri{2bW%0+0#)}%_'#f*\:e>f{Se]}zW%N*

Meh.

C (gcc) , 70 바이트

f(x,l,n){for(l=512;l/=2;)for(n=0;n++<=x;)putchar(n^x+1?n%l?32:35:10);}

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

펄 5 , 60 + 1 (-n) = 61 바이트

$n=0|1+(log)/log 2;say(($"x(2**$n-1),X)x($_/2**$n))while$n--

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