สำหรับจำนวนเต็มบวกใด ๆkให้แสดงว่าจำนวนตัวหารของd(k) kยกตัวอย่างเช่นd(6)เป็น4เพราะ6มี4ตัวหาร (คือ1, 2, 3, 6)

ป.ร. ให้ไว้เป็นจำนวนเต็มบวกNแสดงเป็น "เส้นขอบฟ้า" ในงานศิลปะ ASCII ใช้อักขระคงที่เช่นว่าความสูงของ "อาคาร" ตั้งอยู่ในตำแหน่งแนวนอนkคือสำหรับd(k) k = 1, ..., Nดูกรณีทดสอบด้านล่าง

กฎระเบียบ

• อาจใช้อักขระที่ไม่ใช่ช่องว่างอย่างสม่ำเสมอไม่จำเป็นต้อง#เป็นไปตามที่แสดงในกรณีทดสอบ
• Nอัลกอริทึมในทางทฤษฎีควรจะทำงานให้สูงโดยพลการ ในทางปฏิบัติเป็นที่ยอมรับได้หากโปรแกรมนั้นถูก จำกัด ด้วยเวลาหน่วยความจำขนาดชนิดข้อมูลหรือขนาดหน้าจอ
• อนุญาตให้มีช่องว่างในแนวนอนหรือแนวตั้งหรือแนวต่อท้ายหรือขึ้นบรรทัดใหม่
• input และ output สามารถนำมาโดยใด ๆวิธีการที่เหมาะสม
• โปรแกรมหรือฟังก์ชั่นที่ได้รับอนุญาตในการเขียนโปรแกรมภาษา ช่องโหว่มาตรฐานเป็นสิ่งต้องห้าม
• รหัสที่สั้นที่สุดในหน่วยไบต์ชนะ

กรณีทดสอบ

N = 10:

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

N = 50:

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

N = 200:

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

เยลลี่ขนาด 9 ไบต์

ใช้แทน0#

RÆD0ṁz⁶ṚY

ลองออนไลน์!

C, 99 95 92 91 90 ไบต์

c,l,i,j;f(n){for(j=n;j--;puts(""))for(i=0;i<n;c=!putchar(32|c>j))for(l=++i;l;c+=i%l--<1);}

เห็นมันทำงานที่นี่

คู่, 41 40 32 ไบต์

ขอบคุณ @StewieGriffin บันทึกไว้ 8 ไบต์

@(N)" #"(sort(~mod(k=1:N,k'))+1)

ลองออนไลน์!

คำตอบก่อนหน้า:

@(N)" #"(sort(~bsxfun(@mod,k=1:N,k')+1))

ลองออนไลน์!

@(N)" #"(sort(ismember((k=1:N)./k',k))+1)

ลองออนไลน์!

คำอธิบาย:

N=5;
d = (1:N)./(1:N)'    %divide each of numbers from 1 to N by 1 to N 
                     %a [N by N] matrix created
d =

   1.00   2.00   3.00   4.00   5.00
   0.50   1.00   1.50   2.00   2.50
   0.33   0.66   1.00   1.33   1.66
   0.25   0.50   0.75   1.00   1.25
   0.20   0.40   0.60   0.80   1.00

m = ismember(d,1:N)      %find divisors of each number
m =

  1  1  1  1  1
  0  1  0  1  0
  0  0  1  0  0
  0  0  0  1  0
  0  0  0  0  1

idx = sort(m)                  %sort the matrix

idx =

  0  0  0  0  0
  0  0  0  0  0
  0  0  0  1  0
  0  1  1  1  1
  1  1  1  1  1

" #"(idx+1)     %replace 0 and 1 with ' ' and '#' respectively


   #
 ####
#####

Haskell , 71 ไบต์

fใช้เวลาและผลตอบแทนIntString

f m|l<-[1..m]=unlines[[last$' ':drop(m-i)['#'|0<-mod n<$>l]|n<-l]|i<-l]

ลองออนไลน์!

• mเป็นNของ OP (ตัวแปร Haskell จะต้องเป็นตัวพิมพ์เล็ก)
• ตัวย่อl=[1..m]ถูกใช้ในความเข้าใจของรายการแบบซ้อนสำหรับการวนซ้ำแถว, คอลัมน์, และตัวหารที่เป็นไปได้ทั้งหมด นี่หมายถึงบางแถวเริ่มต้นพิเศษที่เต็มไปด้วยช่องว่าง
• nคือคอลัมน์ (ตรวจสอบหมายเลขด้วย) iคือแถว
• ['#'|0<-mod n<$>l]เป็นรายการของตัวละครที่มีความยาวจำนวนหารของ'#'n

อ็อกเทฟ 61 ไบต์

for i=1:input(''),p(1:nnz(~rem(i,1:i)),i)=35;end,[flip(p),'']

คำอธิบาย:

for i=1:input('')         % Loop, for i from 1 to the input value
 p(1:nnz(~rem(i,1:i)),i)=35;end,[flip(p),'']   
% Breakdown:
         ~rem(i,1:i)      % Return true if the remainder of i divided by any of the values
                          % in the vector 1 - i
     nnz(~rem(i,1:i))     % Check how many of them are non-zero
 p(1:nnz(~rem(i,1:i)),i)=35;end   % Assign the value 35 (ASCII for #) to rows 1
                                  % to the number of divisors of i, in column i
end,              % End loop
[flip(p),'']      % Flip the matrix, and concatenate it with the empty string

บางสิ่งที่ฉันต้องการเน้น

• นำอินพุตเข้าสู่ลูปโดยตรง
  • ไม่ได้กำหนดค่าอินพุตให้กับตัวแปรใด ๆ
• ไม่เริ่มต้นอาร์เรย์ใด ๆ
  • มันสร้างได้ทันทีเพิ่มคอลัมน์และแถวตามความจำเป็น
• ส่งค่า ASCII อัตโนมัติ 0 ถึงช่องว่าง (ASCII-32)

เกิดอะไรขึ้นภายในลูป (สมมติว่าอินพุต6)

p =  35
p =
   35   35
    0   35
p =
   35   35   35
    0   35   35
p =
   35   35   35   35
    0   35   35   35
    0    0    0   35
p =
   35   35   35   35   35
    0   35   35   35   35
    0    0    0   35    0
p =
   35   35   35   35   35   35
    0   35   35   35   35   35
    0    0    0   35    0   35
    0    0    0    0    0   35

1. เริ่มจากเป็น 35 เดี่ยว
2. ขยายหนึ่งคอลัมน์และหนึ่งแถวเพื่อให้มีที่ว่างสำหรับตัวหารสองตัวของ 2
3. ขยายหนึ่งคอลัมน์เพื่อให้มีที่ว่างสำหรับ 3 (ตัวหารสองตัวเท่านั้น)
4. ขยายหนึ่งคอลัมน์และหนึ่งแถวเพื่อให้มีที่ว่างสำหรับตัวหาร 3 ตัว ( 1,2,4)
5. ขยายหนึ่งคอลัมน์เพื่อให้มีที่ว่างสำหรับ 5
6. ขยายหนึ่งคอลัมน์และหนึ่งแถวเพื่อให้มีที่ว่างสำหรับตัวหาร 4 ตัว ( 1,2,3,6)

ในที่สุดเราพลิกมันและแปลงไปสตริงโดยปริยายเปลี่ยน0ไป32:

warning: implicit conversion from numeric to char
ans =
     #
   # #
 #####
######

Python 3 , 111 ไบต์

lambda n:'\n'.join([*map(''.join,zip(*['#'*sum(x%-~i==0for i in range(x))+n*' 'for x in range(1,n+1)]))][::-1])

ลองออนไลน์!

สิ่งนี้ทำให้เกิดช่องว่างแนวตั้งชั้นนำบางส่วน

APL (Dyalog)ขนาด 19 ไบต์

⊖⍉↑'#'⍴¨⍨+⌿0=∘.|⍨⍳⎕

ลองออนไลน์!

⎕ รับอินพุตที่ประเมิน ( N )

⍳ 1 ... N

∘.|⍨ ส่วนที่เหลือของตารางที่มี 1 ... Nทั้งในแนวตั้งและแนวนอน

0= โดยที่เท่ากับศูนย์ (เช่นมันหาร)

+⌿ รวมคอลัมน์ (เช่นให้จำนวนตัวหารสำหรับแต่ละหมายเลข)

'#'⍴¨⍨ ใช้ตัวเลขแต่ละตัวเพื่อปรับแต่งอักขระแฮช (ให้รายการสตริง)

↑ มิกซ์ (รายการของสตริงลงในตารางของแถว)

⍉ transpose

⊖ พลิกคว่ำ

Mathematica, 59 57 ไบต์

Rotate[Grid@Map[X~Table~#&,0~DivisorSigma~Range@#],Pi/2]&

C #, 333 281 ไบต์

using System.Linq;using C=System.Console;class P{static void Main(){var n=int.Parse(C.ReadLine());var v=new int[n];for(var k=2;k<=n;k++)for(var i=1;i<k;i++)if(k%i==0)v[k-1]++;for(var i=0;i<v.Length;i++)for(var u=v.Max()-v[i];u<v.Max();u++){C.SetCursorPosition(i,u);C.Write("#");}}}

ด้วยตัวแบ่งบรรทัด:

using System.Linq;
using C = System.Console;

class P
{
    static void Main()
    {
        var n = int.Parse(C.ReadLine());
        var v = new int[n];
        for (var k = 2; k <= n; k++)
            for (var i = 1; i < k; i++)
                if (k % i == 0)
                    v[k - 1]++;
        for (var i = 0; i < v.Length; i++)
            for (var u = v.Max() - v[i]; u < v.Max(); u++)
            {
                C.SetCursorPosition(i, u);
                C.Write("#");
            }
    }
}

ในขณะที่ฉันแน่ใจว่านี่เป็นไปได้สั้นลงเช่นกันฉันหวังว่าเราจะได้คำตอบที่สั้นกว่าด้วยกัน)

บันทึก 52 Bytes ด้วยความช่วยเหลือของ raznagul

Mathematica, 99 ไบต์

{T=DivisorSigma[0,Range@#];Row[Column/@Table[Join[Table[,Max[T]-T[[i]]],$~Table~T[[i]]],{i,1,#}]]}&

สำหรับ N = 50

ถ่าน , 23 22 20 ไบต์

Ｆ…·¹Ｎ«Ｊι⁰Ｆι¿¬﹪ι⁺κ¹↑#

ลองออนไลน์! การเชื่อมโยงคือการใช้รหัสเวอร์ชันอย่างละเอียด แก้ไข: บันทึกไว้ 1 ไบต์โดยวนลูปkจาก0ไปi-1และการเพิ่ม1ภายในวง บันทึกอีกสองไบต์โดยไม่เก็บข้อมูลไว้ในตัวแปร คำอธิบาย:

Ｆ…·¹Ｎ       for (i : InclusiveRange(1, InputNumber()))
«           {
 Ｊι⁰         JumpTo(i, 0);
 Ｆι          for (k : Range(i))
  ¿¬﹪ι⁺κ¹     if (!(i % (k + 1)))
   ↑#          Print(:Up, "#");
            }

แก้ไข: 18 ไบต์ "หนึ่งซับ" นี้ (ลิงก์คือรหัสรุ่น verbose) จะไม่ทำงานกับรุ่น Charcoal ในเวลาที่ส่งคำถาม: ลองออนไลน์!

↑Ｅ…·¹Ｎ⪫Ｅι⎇﹪ι⁺¹λω#ω

05AB1E , 12 ไบต์

รหัส:

LÑ€g'#×.BøR»

คำอธิบาย:

L             # Create the range 1 .. input
 Ñ            # Get the list of divisors of each
  €g          # Get the length of each element
    '#        # Push a hash tag character
      ×       # String multiply
       .B     # Squarify, make them all of equal length by adding spaces
         ø    # Transpose
          R   # Reverse the array
           »  # Join by newlines

ใช้การเข้ารหัส05AB1E ลองออนไลน์!

Python 2 , 101 ไบต์

N=input();r=range
for i in r(N,0,-1):print''.join('# '[i>sum(x%-~p<1for p in r(x))]for x in r(1,1+N))

ลองออนไลน์!

สิ่งนี้ทำให้เกิดช่องว่างในแนวตั้งเป็นจำนวนมาก มันพิมพ์รวมเป็นNเส้นส่วนใหญ่ซึ่งจะมักจะเว้นว่าง

Japt , 34 33 16 14 ไบต์

บันทึกแล้ว 17 ไบต์ขอบคุณ @ETHproductions

õ@'#pXâ l÷z w

ลองออนไลน์!

J , 28 ไบต์

[:|:&.|.[('#',@$~1+_&q:)@-i.

กำหนดคำกริยา monadic ลองออนไลน์!

คำอธิบาย

[:|:&.|.[('#',@$~1+_&q:)@-i.  Input is y.
                          i.  Range from 0 to y-1
        [                -    subtracted from y (gives range from y to 1).
         (             )@     For each of the numbers:
                   _&q:         Compute exponents in prime decomposition,
                 1+             add 1 to each,
          '#'  $~               make char matrix of #s with those dimensions,
             ,@                 and flatten into a string.
                              The resulting 2D char matrix is padded with spaces.
[:|:&.|.                      Reverse, transpose, reverse again.

PHP, 126 ไบต์

for(;$n++<$argn;)for($c=$d=0;$d++<$n;)$n%$d?:$r[$n]=++$c;for($h=max($r);$h--;print"
")for($n=0;$n++<$argn;)echo$h<$r[$n]?:" ";

ลองออนไลน์!

Brachylogขนาด 34 ไบต์

⟦fᵐlᵐgDh⌉⟦↔gᵐ;D↔z{z{>₁∧0ṫ|∧Ṣ}ᵐcẉ}ᵐ

ลองออนไลน์!

อลิซ 33 ไบต์

I.!.t&w?t!aot&wh.Bdt.?-ex' +o&;k@

ลองออนไลน์!

การป้อนข้อมูลเป็น (ขออภัย) ในรูปแบบของจุดรหัส อย่างน้อยก็อ่านตัวอักษร UTF-8 เพื่อให้คุณสามารถใช้อินพุตที่มีขนาดใหญ่กว่า 255 แต่ก็ยังมีข้อ จำกัด และมันเป็นรูปแบบอินพุตที่ค่อนข้างเจ็บปวด สำหรับสามไบต์เพิ่มเติมเราสามารถอ่านจำนวนเต็มทศนิยม:

/
ki@/.!.t&w?t!aot&wh.Bdt.?-ex' +o&;

ลองออนไลน์!

!ตัวละครที่ไม่ใช่ช่องว่างในการส่งออกคือ

โปรดทราบว่าวิธีแก้ปัญหานี้ยังพิมพ์ช่องว่างนำหน้าจำนวนหนึ่งตัน (เริ่มต้นด้วยบรรทัดว่างเสมอจากนั้นพิมพ์NxNตารางเพื่อให้มีขนาดใหญ่ขึ้นNจะมีช่องว่างหลายบรรทัดก่อนหน้าแรก!)

คำอธิบาย

ฉันเคยใช้และอธิบายการ&w...kก่อสร้างมาก่อน (เช่นที่นี่ ) มันเป็นสำนวนเล็ก ๆ ที่เรียบร้อยที่ปรากฏเป็นจำนวนเต็มnและจากนั้นเรียกใช้ส่วนหนึ่งของรหัสn + 1ครั้ง (ดังนั้นจึงมักจะใช้t&w...kเพื่อเรียกใช้วนซ้ำnครั้งโดยtลดค่าอินพุต) สิ่งนี้ทำได้โดยการทำงานกับReturn address stack (RAS) wผลักที่อยู่ IP ปัจจุบันไปที่ RAS และถ้าเราทำซ้ำด้วย&ที่อยู่นั้นจะถูกผลักnครั้ง kดึงที่อยู่หนึ่งรายการจาก RAS และกระโดดกลับไปที่นั่น ถ้า RAS ว่างเปล่ามันจะไม่ทำอะไรเลยและออกจากลูป

คุณอาจสังเกตเห็นว่ามันเป็นไปไม่ได้ที่จะทำรังลูปเหล่านี้ได้เนื่องจากในตอนท้ายของลูปด้านในสแต็กจะไม่ว่างเปล่าดังนั้นจึงkไม่กลายเป็นแบบไม่มี op แต่ IP จะกลับไปที่จุดเริ่มต้นของลูปด้านนอกแทน วิธีทั่วไปในการแก้ไขปัญหานี้เกี่ยวข้องกับการตัดลูปด้านในในรูทีนย่อยของมันเอง แต่ถ้าเราสามารถจัดเรียงลูปซ้อนเพื่อให้ลูปด้านนอกลงท้ายด้วยลูปภายในเราสามารถใช้ลักษณะการทำงานนี้และประหยัดได้แม้แต่อันเดียวk!

ดังนั้นการก่อสร้างนี้:

&wX&wYk

เป็นลูปซ้อนที่ใช้งานได้ซึ่งรันXYYYXYYYXYYY...(สำหรับบางจำนวนYs ในแต่ละการวนซ้ำ) มันค่อนข้างเรียบร้อยที่เราสามารถจบทั้งสองลูปด้วยซิงเกิ้ลkได้เพราะมันจะใช้ที่อยู่ด้านนอกจาก RAS ทุกครั้งที่ที่อยู่ด้านในหมดลง

สำนวนนี้ใช้ในโปรแกรมเพื่อเรียกใช้วนรอบกริดเอาท์พุท

I         Read a character and push its code point as input N.
.!        Store a copy on the tape.
.         Make another copy.
t&w       Run this outer loop N times. This loops over the lines of the
          output, so the current iteration corresponds to a divisor count
          no more than i (i counting down from N).
  ?t!       Decrement the value on the tape. That means we'll actually have
            i-1 on the tape during the iteration.
  ao        Print a linefeed. Doing this now leads to the weird leading linefeed, 
            but it's necessary for the &w...&w...k pattern.
  t&w       Remember that we still have a copy of N on the stack. We'll also
            ensure that this is the case after each loop iteration. So this
            also runs the inner loop N times. This iterates over the columns
            of the output grid so it's j that goes from 1 to N and corresponds
            to the number whose divisors we want to visualise.
              At this point the stack will always be empty. However, operating
              on an empty stack works with implicit zeros at the bottom of
              the stack. We'll use the top zero to keep track of j.
    h         Increment j.
    .B        Duplicate j and push all of its divisors.
    dt        Push the stack depth minus 1, i.e. the divisor count of j.
    .         Duplicate the divisor count.
    ?-        Retrieve i-1 from the tape and subtract it. So we're computing
              d(j)-i+1. We want to output a non-whitespace character iff this
              value is positive (i.e. if i is no greater than d(j)).
    ex        Extract the most significant bit of this value. This is 1 for
              all positive values and 0 for non-positive ones. It's the shortest
              way (I believe) to determine if a value is positive.
    ' +       Add this to the code point of a space. This gives a 33, or '!',
              if the cell is part of the skyline.
    o         Output the character.
    &;        We still have all the divisors and the divisor count on the stack.
              We pop the divisor count to discard that many values (i.e. to
              get rid of the divisors again).
k         Return to the appropriate loop beginning to run the continue the
          nested loop.
@         Terminate the program.

ที่จริงแล้ว 25 ไบต์

R♂÷♂l;M' *╗⌠'#*╜@+⌡M┬♂ΣRi

ลองออนไลน์!

เวอร์ชัน 22 ไบต์พร้อมด้วย newlines ชั้นนำมากมาย

;╗R⌠÷l'#*╜' *@+⌡M┬♂ΣRi

ลองออนไลน์!

R, 83 82 ไบต์

-1 ไบต์ต้องขอบคุณ MickyT

N=scan();m=matrix('#',N,N);for(i in 1:N)m[i,1:sum(i%%1:N>0)]=' ';write(m,'',N,,'')

อ่านNจาก stdin

N=scan()                        # read N
m=matrix('#',N,N)               # make an NxN matrix of '#' characters
for(i in 1:N)                   # for each integer in the range
    m[i,1:sum(i%%1:N!=0)]=' '   # set the first n-d(n) columns of row i to ' '
write(m,'',N,,'')               # print to console with appropriate formatting

ลองออนไลน์!

Pyth , 16 ไบต์

j_.tm*\#/%LdSQ0S

ลองออนไลน์!

SpecBAS - 149 ไบต์

1 INPUT n: DIM h(n)
2 FOR i=1 TO n
3 FOR j=1 TO i
4 h(i)+=(i MOD j=0)
5 NEXT j
6 NEXT i
7 FOR i=1 TO n
8 FOR j=51-h(i) TO 50
9  ?AT j,i;"#"
10 NEXT j
11 NEXT i

อาร์เรย์จะติดตามจำนวนตัวหารแล้วพิมพ์จำนวนอักขระที่ถูกต้องลงไปที่ตำแหน่งหน้าจอ 50

PHP, 99 ไบต์

for(;$d<$k?:$k++<$argn+$d=$n=0;)$k%++$d?:$r[--$n]=str_pad($r[$n],$k).H;ksort($r);echo join("
",$r);

พิมพ์หนึ่งพื้นที่ชั้นนำ ใช้เป็นท่อที่มีphp -nr '<code>'หรือลองออนไลน์

ชำรุด

for(;$d<$k?:                    # inner: loop $d from 1 to $k
    $k++<$argn+$d=$n=0;)        # outer: loop $k from 1 to $argn, reset $d and $n
    $k%++$d?:                       # if $d divides $k
        $r[--$n]=str_pad($r[$n],$k).H;  # add one store to building $k
ksort($r);echo join("\n",$r);   # reverse and print resulting array

PowerShell ขนาด 101 ไบต์

((($d=1.."$args"|%{($x=$_)-(1..$_|?{$x%$_}).Count})|sort)[-1])..1|%{$l=$_;-join($d|%{' #'[$_-ge$l]})}

สคริปต์ทดสอบ golfed น้อย:

$f = {

$d=1.."$args"|%{
    ($x=$_)-(1..$_|?{$x%$_}).Count
}                                     # $d is the Divisor count array
$maxHeight=($d|sort)[-1]
$maxHeight..1|%{
    $l=$_
    -join($d|%{' #'[$_-ge$l]})
}

}

@(
    ,(10, 
    "     # # #",
    "   # # ###",
    " #########",
    "##########")

    ,(50, 
    "                                               #  ",
    "                                   #           #  ",
    "                       #     #     #   # #     #  ",
    "                       #     #     #   # #     #  ",
    "           #     # #   #   # # #   #   # # ##  # #",
    "           #   # # #   #   # # #   #   # # ##  # #",
    "     # # # # ### # ### # ### # ##### ### # ### # #",
    "   # # ### # ### # ### ##### # ##### ### # ### ###",
    " #################################################",
    "##################################################")

    ,(200,
    "                                                                                                                                                                                   #                    ",
    "                                                                                                                                                                                   #                    ",
    "                                                                                                                       #                                               #           #                    ",
    "                                                                                                                       #                       #                       #           #                    ",
    "                                                                                                                       #                       #                       #           #           #        ",
    "                                                                                                                       #                       #                       #           #           #        ",
    "                                                           #           #           #     #     #           #           #     #     #       #   #     #     #   #       #           #           #     # #",
    "                                                           #           #           #     #     #           #           #     #     #       #   #     #     #   #       #           #           #     # #",
    "                                               #           #           #       #   #     #     #           #   #       #     #     #       #   #     #     #   # #     #       #   #           #     # #",
    "                                   #           #           #           #       #   #     #     #   #       #   #       #     #     #       #   #     #     #   # #     #       #   #           #   # # #",
    "                       #     #     #   # #     #     # #   #     #   # #     # #   #   # #     #   # # ##  # # # #     #     # # # #  ## # #   #     # # # #   # #  #  # #   # #   # # # #  ## #  ## # #",
    "                       #     #     #   # #     #     # #   #   # #   # #     # #   #   # #     #   # # ##  # # # #     #     # # # #  ## # #   #     # # # #   # #  #  # #   # #   # # # #  ## #  ## # #",
    "           #     # #   #   # # #   #   # # ##  # # # # #   #  ## # # # #  ## # #   #   # # #   # ### # ##  # # # # ##  #   # # # # #  ## # #   #  ## # ### #   # # ##  # ### ###   # # # # ### #  ## # #",
    "           #   # # #   #   # # #   #   # # ##  # # # # #   #  ## # # # #  ## # ##  #   # # #   # ### # ##  # # # # ##  #   # # # # #  ## # #   #  ## # ### #   # # ##  # ### ###   # # # # ### #  ## # #",
    "     # # # # ### # ### # ### # ##### ### # ### # ### ##### # ##### ### # ##### ### ##### ####### ### # ### # ### ####### ##### ### ##### # ######### # ##### ##### ### # ### ##### # ######### # ### # #",
    "   # # ### # ### # ### ##### # ##### ### # ### ##### ##### # ##### ### # ##### ### ##### ####### ### # ### # ### ############# ### ##### # ######### # ##### ##### ### ##### ##### # ######### # ### # #",
    " #######################################################################################################################################################################################################",
    "########################################################################################################################################################################################################")


) | % {
    $n,$expected = $_
    $result = &$f $n
    "$result"-eq"$expected"
    #$result    # uncomment this to enjoy the view of the Divisor skyline
}

เอาท์พุท:

True
True
True

SOGL V0.12 , 8 ไบต์

∫Λ⁄╗*}⁰H

ลองที่นี่!

ภาษา Wolfram (Mathematica) , 46 44 ไบต์

Grid[PadLeft[0Divisors@Range@#-" "]+" "]&

ลองออนไลน์! แต่อาจจะลองออนไลน์! กับ ColumnForm แทน Gridเนื่องจากGridไม่สามารถใช้งานใน TIO ใน Mathematica มันดูดีกว่า:

วิธีการแก้ปัญหา Mathematica ที่สาม ... Divisors@Range@#พบหารทั้งหมดที่อยู่ในช่วงที่เราต้องการและจากนั้นเราคูณด้วย0และลบทำให้ทุกหารเท่ากับ" "-" "

PadLeftเพิ่ม zeroes ด้านซ้าย, การสร้างเส้นขอบฟ้าด้านข้างที่มีการวางแนวทางเราจะแก้ไขปัญหาด้วย= \[Transpose]สุดท้ายเพิ่ม" "กับทุกสิ่งที่ทำให้รายการทั้งหมดอย่างใดอย่างหนึ่งหรือ0" "

เป็นทางเลือก 59- ไบต์""<>Riffle[PadLeft["X"-" "+0Divisors@Range@#]+" ","\n"]&ผลิตสตริงออก

เพิ่ม ++ , 58 ไบต์

D,g,@,FL1+
D,k,@~,J
L,R€gd"#"€*$dbM€_32C€*z£+bUBcB]bR€kbUn

ลองออนไลน์!

มันทำงานอย่างไร

gkg$x$$1$$n$$d(x)$k

$A = [d(1), d(2), d(3), ..., d(n)]$#$A$$\max(A)$$A$จากค่าสูงสุดนี้ก่อนที่จะยอมให้มีจำนวนช่องว่างสำหรับแต่ละองค์ประกอบและต่อเชื่อมช่องว่างกับแฮชซ้ำหลายครั้ง ต่อไปเราจะย้ายและย้อนกลับแถวก่อนที่จะเข้าร่วมแต่ละบรรทัดในการขึ้นบรรทัดใหม่ ในที่สุดเราก็ส่งออกเส้นขอบฟ้า