รับตัวเลขnสร้างคอลัมน์nแรกของรูปแบบนี้:

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

ความสูงของคอลัมน์ที่ (ทำดัชนี 1) nคือจำนวน0บิตต่อท้ายในการแสดงเลขฐานสองของnบวกหนึ่ง เป็นผลให้เลเยอร์ด้านล่างมีทุกคอลัมน์ที่กรอกข้อมูลในชั้นที่สองทุกคอลัมน์ที่สองชั้นที่สามทุกคอลัมน์ที่สี่ ฯลฯ

กฎระเบียบ

• คุณสามารถอินพุตและเอาต์พุตด้วยวิธีมาตรฐานใด ๆ
• คุณอาจสมมติว่าการป้อนข้อมูลเป็นจำนวนเต็มระหว่าง 1 ถึง 999 รวม
• ผลลัพธ์อาจมีช่องว่างจำนวนเท่าใดก็ได้ตราบใดที่รูปแบบยังคงอยู่
• รูปแบบต้องมีการจัดทำดัชนี 1 และในรูปแบบเดียวกับที่แสดงที่นี่
• คุณสามารถใช้อักขระที่ไม่ใช่ช่องว่างเดียวแทนได้#แต่คุณไม่สามารถเปลี่ยนอักขระช่องว่างได้

กรณีทดสอบ

1
#

2
 #
##

3
 # 
###

4
   #
 # #
####

5
   # 
 # # 
#####

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

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

ไม่กี่กรณีทดสอบขนาดใหญ่สามารถพบได้ที่นี่

เกณฑ์การให้คะแนน

นี่คือโค้ดกอล์ฟดังนั้นโค้ดที่สั้นที่สุดเป็นไบต์ในแต่ละภาษาจะชนะ

Python 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

Python 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

ลองออนไลน์!

hexdump:

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

ขอบคุณ @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

JavaScript (ES6), 61 58 ไบต์

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

บันทึกแล้ว 1 ไบต์ขอบคุณ @ETHProductions จากนั้นอีก 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 แปลงเป็นเลขฐานสองโดยใช้ตัวเลขมากเท่าที่ต้องการ (หนึ่งหมายเลขในแต่ละคอลัมน์ )

 ⊖ พลิกคว่ำ

 ∨⍀ การสะสมหรือการลดลงในแนวตั้ง

 0⍪ เชื่อมต่อศูนย์ที่ด้านบน

 ⊖ พลิกคว่ำ (เช่นกลับขึ้นไปอีกครั้ง)

 1+ เพิ่มหนึ่งรายการ (สำหรับการจัดทำดัชนีแบบ 1 ฐาน)

เจลลี่ , 11 10 ไบต์

Rọ2‘4ẋz⁶ṚY

ลองออนไลน์!

1 ไบต์บันทึกไว้หลังจาก OP #เพิ่มความผ่อนคลายที่ตัวอักษรที่ไม่จำเป็นต้องเป็น

อ็อกเทฟ 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);

ลองออนไลน์!

Japt , 20 17 ไบต์

บันทึก 3 ไบต์ด้วย @Shaggy และ @ETHproductions

õ_¤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;}

Ungolfed:

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 มากกว่าการวนซ้ำดังนั้นทั้งสองลูปจะแสดงเป็นการร้องขอซ้ำสองครั้ง

นอกจากนี้ซีเป็นภาษาที่ดีสำหรับเทคนิคการเล่นที่มีการแสดงออกบูลที่ช่วยให้การตัดสินใจว่าจะใส่หรือเปล่าที่จะแสดงออกโดยการแสดงออก# 32+3*!(i&m)พื้นที่มีค่า ASCII 32 ที่#เป็น ASCII 35 ดังนั้นเราจึงได้รับความว่างเปล่าถ้าใด ๆ iของบิตในหน้ากากตั้งอยู่ใน

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

Python 2 , 47 ไบต์

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

ลองออนไลน์!

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

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

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

Alright 'เวลาสาด

ก่อนอื่นให้แทนที่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)โทเค็นเป็นจำนวนมากซึ่งก็หมายถึงใช้กำลังที่ใกล้ที่สุดของ 2 ซึ่งน้อยกว่าจำนวนอินพุต ( [i]) 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 นี่เป็นการเลือกแถวที่เท่ากับความสูงของ ไม้บรรทัด. +1สำหรับแถวที่ทำดัชนี 1 แถวและ+1อีกครั้งสำหรับ WESRRMICGSE offset

FALSEผลตอบแทนถัวเฉลี่ยเซลล์ว่าง ( "") และอัตราผลตอบแทนผลจริงLEFT(REPT(REPT(" ",,FLOOR(POWER(2,LOG([i],2)-ROW()+2),1),1)-1) &"#",[i]),[i])

ขณะนี้ยังคงแก้ไขอยู่ติดตามความคืบหน้า

Haskell , 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 ถ้าจำนวนไบต์ปิด - ฉันใช้มือถือ

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

ลองออนไลน์!

Ungolfed:

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

ลองออนไลน์!

Perl 5 , 60 + 1 (-n) = 61 ไบต์

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

ลองออนไลน์!