Cho một số n , tạo n cột đầu tiên của mẫu này:

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

Chiều cao của cột tại (1-index) n là số 0bit theo sau trong biểu diễn nhị phân của n , cộng với một. Kết quả là, lớp dưới cùng có mỗi cột được điền vào, lớp thứ hai mỗi cột thứ hai, lớp thứ ba mỗi cột thứ tư, v.v.

Quy tắc

• Bạn có thể nhập và xuất thông qua bất kỳ phương pháp tiêu chuẩn.
• Bạn có thể giả sử đầu vào là một số nguyên nằm trong khoảng từ 1 đến 999.
• Đầu ra có thể chứa bất kỳ khoảng trắng nào, miễn là mẫu còn nguyên vẹn.
• Mẫu phải được lập chỉ mục 1 và có cùng định dạng như được hiển thị ở đây.
• Bạn có thể sử dụng bất kỳ ký tự không phải khoảng trắng nào thay thế #, nhưng bạn không thể thay đổi ký tự khoảng trắng .

Các trường hợp thử nghiệm

1
#

2
 #
##

3
 # 
###

4
   #
 # #
####

5
   # 
 # # 
#####

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

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

Một vài trường hợp thử nghiệm lớn hơn có thể được tìm thấy ở đây .

Chấm điểm

Đây là mã golf , vì vậy mã ngắn nhất tính theo byte trong mỗi ngôn ngữ sẽ thắng.

Python 2 , 54 byte

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

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

In với rất nhiều khoảng trắng hàng đầu. Mỗi hàng iđếm ngược từ nlặp lại một mô hình 2**i-1không gian theo sau là a #. Mẫu này được lặp lại cho đến chiều rộng của thước, đó là đầu vào n. Điều này được thực hiện bằng cách nhân chuỗi mẫu bằng cách nlấy các nký tự đầu tiên với [:n].

Mẫu có thể được thực hiện bằng cách định dạng chuỗi cho một sự thay thế có độ dài bằng nhau.

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

Một phương pháp cắt lát dễ thương là lâu hơn.

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

Python 3 , 74 byte

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

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

V , 17 , 16 byte

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

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

Hexdump:

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

Cảm ơn @KritixiLithos đã lưu một byte!

Thuật toán này là không hiệu quả khủng khiếp , nhưng nó nên hoạt động trên lý thuyết cho bất kỳ kích thước đầu vào.

Nó hoạt động bằng cách tạo n lần lặp đầu tiên của mẫu sau:

#

 #
##

   #
 # #
####

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

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

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

Và sau đó cắt bỏ tất cả trừ n cột đầu tiên . Như vậy, điều này sẽ tạo ra một tấn khoảng trắng hàng đầu, nhưng OP cho biết:

Đầu ra có thể chứa bất kỳ khoảng trắng nào, miễn là mẫu còn nguyên

Giải trình:

é#                      " 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

JavaScript (ES6), 61 58 byte

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

Đã lưu 1 byte nhờ @ETH Productstions, sau đó thêm 2 byte khi tôi thấy rằng bất kỳ ký tự nào cũng có thể được sử dụng.

Một giải pháp đệ quy.

Các trường hợp thử nghiệm:

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

Hoạt hình:

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 byte

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

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

'# '[Sấu `] lập chỉ mục chuỗi với

 ⎕ nhận đầu vào

 ⍳ mà nhiều i ntegers

 2⊥⍣¯1 chuyển đổi thành nhị phân, sử dụng bao nhiêu chữ số nếu cần (một số trong mỗi cột )

 ⊖ lộn ngược

 ∨⍀ tích lũy dọc HOẶC giảm

 0⍪ số không nối trên đầu trang

 ⊖ lộn ngược (tức là sao lưu lại)

 1+ thêm một (để lập chỉ mục dựa trên 1)

Thạch , 11 10 byte

Rọ2‘4ẋz⁶ṚY

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

Lưu 1 byte sau khi OP thêm thư giãn mà nhân vật không cần phải có #.

Octave, 45 byte

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

Hãy thử nó trên Octave Online!

Thay vì '#'in '!'.

PHP , 139 byte

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

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

Japt , 20 17 byte

Đã lưu 3 byte nhờ @Shaggy và @ETHproductions

õ_¤q1 o Ä ço÷z w

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

Giải trình:

Đầu vào: 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 byte

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

Ung dung:

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

Kiểm tra với:

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

Giải trình

Một lần nữa, đệ quy mất ít ký tự trong C hơn lặp lại, do đó hai vòng lặp được thể hiện dưới dạng hai lần gọi đệ quy.

Ngoài ra, C là một ngôn ngữ tuyệt vời để chơi các thủ thuật với các biểu thức boolean, cho phép quyết định đặt trống hay a #được thể hiện bằng biểu thức 32+3*!(i&m). Một khoảng #trắng có giá trị ASCII là 32, là ASCII 35, vì vậy chúng ta sẽ có một khoảng trống nếu có bất kỳ bit nào trong mặt nạ được đặt i.

Bình , 15 byte

j_.tm*Nhx_.Bd1S

Thử nó!

giải trình

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

Python 2 , 47 byte

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

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

JavaScript (ES8), 71 byte

Hàm padStart () đã được giới thiệu trong 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()))

JavaScript (ES6), 77 byte

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

Toán học, 69 byte

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

( WESRRMICGSE ): 237 byte

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),"")

Ổn thỏa. 'thời gian nối.

Trước hết, thay thế mọi thứ COUNTA(R1C:R[-1]C,R[1]C:R[1024]C)+1đơn giản [i], cho đầu vào. mã thông báo đếm số lượng ô, không bao gồm chính nó, có chứa một công thức, sau đó thêm một ô, để bao gồm chính nó. Vì WESRRMICGSE kéo một công thức theo đầu vào bạn cung cấp cho nó, mã thông báo này luôn dẫn đến kết quả đầu vào.

chúng ta có:

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

Điều này dễ đọc hơn nhiều. Bạn sẽ thấy FLOOR(LOG([i],2),1)mã thông báo rất nhiều, điều đó chỉ có nghĩa là lấy công suất gần nhất bằng 2, nhỏ hơn số đầu vào ( [i]). ví dụ : 4->4, 5->4, 6->4, 7->4, 8->8 ...etc. Tôi sẽ thay thế nó bằngGS[[i]]

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

tốt hơn. phá vỡ mệnh đề if, chúng tôi đang kiểm tra xem hàng có nhỏ hơn hoặc bằng không GS[[i]]+3, bởi vì chiều cao của tất cả các thước đo đều bằng GS [[i]] + 1, điều này chọn các hàng bằng với chiều cao của cái thước.+1cho các hàng 1 chỉ mục và +1một lần nữa cho phần bù WESRRMICGSE.

Các FALSE kết quả mang lại một ô trống ( ""), và sản lượng kết quả đúngLEFT(REPT(REPT(" ",,FLOOR(POWER(2,LOG([i],2)-ROW()+2),1),1)-1) &"#",[i]),[i])

Hiện tại vẫn đang chỉnh sửa, hãy theo dõi

Haskell , 64 62 byte

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

Hãy thử trực tuyến! Ví dụ sử dụng : f 10.

k, 33 byte

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

Điều này dường như chỉ hoạt động trong thông dịch viên của AW .

Phiên bản oK (mà bạn có thể thử trực tuyến) dường như có một lỗi, yêu cầu một chút thay đổi để làm cho nó hoạt động:

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

C #, 174 byte

Phương thức này có hai tham số, một đầu vào cho độ dài của thước và một đầu ra là thước dưới dạng chuỗi.

Chơi gôn

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]?'#':' ');}

Thụt lề:

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

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

Than , 27 23 byte

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Chỉnh sửa: Đã lưu 4 byte bằng cách chuyển sang JumpTo.

J, 38 byte

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

Không tốt. Lmk nếu số byte bị tắt - Tôi đang ở trên điện thoại của mình.

Java (OpenJDK 8) , 91 byte

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

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

Ung dung:

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 byte

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

Meh.

C (gcc) , 70 byte

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

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

Perl 5 , 60 + 1 (-n) = 61 byte

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

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