Đối với bất kỳ số nguyên dương nào k, hãy d(k)biểu thị số lượng ước của k. Ví dụ, d(6)là 4, vì 6có 4ước (cụ thể là 1, 2, 3, 6).

Cho một số nguyên dương N, hiển thị "đường chân trời" trong nghệ thuật ASCII bằng cách sử dụng một ký tự cố định, sao cho chiều cao của "tòa nhà" nằm ở vị trí nằm ngang klà d(k)dành cho k = 1, ..., N. Xem các trường hợp thử nghiệm dưới đây.

Quy tắc

• Bất kỳ ký tự không phải khoảng trắng nào cũng có thể được sử dụng nhất quán, không nhất thiết phải #được hiển thị trong các trường hợp thử nghiệm.
• Các thuật toán nên hoạt động trên lý thuyết cho cao tùy ý N. Trong thực tế, có thể chấp nhận nếu chương trình bị giới hạn bởi thời gian, bộ nhớ, kích thước loại dữ liệu hoặc kích thước màn hình.
• Không gian theo chiều dọc hoặc theo chiều dọc hoặc dấu hoặc dòng mới được cho phép.
• Đầu vào và đầu ra có thể được thực hiện bằng bất kỳ phương tiện hợp lý .
• Các chương trình hoặc chức năng được cho phép, trong bất kỳ ngôn ngữ lập trình . Sơ hở tiêu chuẩn bị cấm.
• Mã ngắn nhất trong byte thắng.

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

N = 10:

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

N = 50:

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

N = 200:

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

Thạch , 9 byte

Sử dụng 0thay vì #.

RÆD0ṁz⁶ṚY

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

C, 99 95 92 91 90 byte

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

Xem nó hoạt động ở đây .

Octave, 41 40 32 byte

Nhờ @StewieGriffin đã lưu 8 byte.

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

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

Câu trả lời trước:

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

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

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

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

Giải trình:

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 byte

fmất một Intvà trả về a String.

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

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

• mlà NOP (biến Haskell phải là chữ thường.)
• Chữ viết tắt l=[1..m]được sử dụng trong phần hiểu danh sách lồng nhau để lặp qua tất cả các hàng, cột và ước số tiềm năng. Điều này có nghĩa là một số hàng ban đầu bổ sung đầy khoảng trắng.
• nlà cột (cũng được kiểm tra số), ilà hàng.
• ['#'|0<-mod n<$>l]là danh sách các '#'ký tự có độ dài số ước của n.

Octave, 61 byte

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

Giải trình:

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

Một vài điều tôi muốn làm nổi bật

• Đưa đầu vào trực tiếp vào vòng lặp
  • Không gán giá trị đầu vào cho bất kỳ biến nào
• Không khởi tạo bất kỳ mảng nào
  • Nó tạo ra nó một cách nhanh chóng, thêm các cột và hàng khi cần thiết
• Tự động chuyển giá trị ASCII-0 sang khoảng trắng (ASCII-32)

Điều gì xảy ra bên trong vòng lặp (giả sử đầu vào 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. Bắt đầu như một 35
2. Mở rộng một cột và một hàng, để nhường chỗ cho hai ước của 2
3. Mở rộng một cột, để nhường chỗ cho 3 (chỉ có hai ước)
4. Mở rộng một cột và một hàng, để nhường chỗ cho 3 ước ( 1,2,4)
5. Mở rộng một cột, để nhường chỗ cho 5
6. Mở rộng một cột và một hàng, để nhường chỗ cho 4 ước ( 1,2,3,6)

Cuối cùng chúng ta lật nó và chuyển đổi nó thành một chuỗi, thay đổi hoàn toàn 0thành 32:

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

Python 3 , 111 byte

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

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

Điều này tạo ra một số khoảng trắng dọc hàng đầu

APL (Dyalog) , 19 byte

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

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

⎕ được đánh giá đầu vào ( N )

⍳ 1 ... N

∘.|⍨ bảng còn lại chia với 1 ... N cả trục dọc và trục ngang

0= trong đó bằng 0 (tức là chia)

+⌿ tính tổng các cột (nghĩa là tính số ước cho mỗi số)

'#'⍴¨⍨ sử dụng mỗi số để định hình lại ký tự băm (đưa ra danh sách các chuỗi)

↑ trộn (danh sách các chuỗi vào bảng hàng)

⍉ hoán vị

⊖ lộn ngược

Toán học, 59 57 byte

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

C #, 333 281 byte

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("#");}}}

Với ngắt dòng:

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("#");
            }
    }
}

Mặc dù tôi chắc chắn rằng điều này cũng có thể ngắn hơn, tôi hy vọng chúng ta sẽ cùng nhau đạt được một giải pháp ngắn hơn;)

Đã lưu 52 Byte với sự trợ giúp của raznagul

Toán học, 99 byte

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

cho N = 50

Than , 23 22 20 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 1 byte bằng cách lặp ktừ 0đến i-1và thêm vào 1bên trong vòng lặp. Đã lưu thêm hai byte bằng cách không lưu trữ đầu vào trong một biến. Giải trình:

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

Chỉnh sửa: "Một-liner" 18 byte này (liên kết là phiên bản mã dài dòng) sẽ không hoạt động với phiên bản Char than tại thời điểm câu hỏi được gửi: Hãy thử trực tuyến!

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

05AB1E , 12 byte

Mã số:

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

Giải trình:

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

Sử dụng mã hóa 05AB1E . Hãy thử trực tuyến!

Python 2 , 101 byte

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

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

Điều này tạo ra (rất nhiều) khoảng trắng hàng đầu theo chiều dọc. Nó in tổng cộng các Ndòng, phần lớn trong số đó thường sẽ trống.

Japt , 34 33 16 14 byte

Đã lưu 17 byte nhờ @ETHproductions

õ@'#pXâ l÷z w

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

J , 28 byte

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

Xác định một động từ đơn âm. Hãy thử trực tuyến!

Giải trình

[:|:&.|.[('#',@$~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 byte

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]?:" ";

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

Brachylog , 34 byte

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

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

Alice , 33 byte

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

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

Đầu vào là (không may) dưới dạng một điểm mã . Ít nhất là nó đọc ký tự UTF-8, vì vậy bạn có thể sử dụng các đầu vào lớn hơn 255, nhưng chúng vẫn bị giới hạn và đó là một định dạng đầu vào khá đau đớn. Đối với ba byte bổ sung, chúng ta có thể đọc một số nguyên thập phân:

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

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

Ký tự không phải khoảng trắng trong đầu ra là !.

Lưu ý rằng giải pháp cũng in một tấn khoảng trắng hàng đầu (nó luôn bắt đầu bằng một dòng trống và sau đó in một NxNlưới để lớn hơn N, sẽ có nhiều dòng khoảng trắng trước !s đầu tiên .)

Giải trình

Tôi đã sử dụng và giải thích việc &w...kxây dựng trước đây (ví dụ ở đây ). Đó là một thành ngữ nhỏ gọn bật ra một số nguyên n và sau đó chạy một đoạn mã n + 1 lần (do đó, nó thường được sử dụng t&w...kđể chạy một vòng lặp n lần, với tgiá trị đầu vào giảm dần). Điều này được thực hiện bằng cách làm việc với ngăn xếp địa chỉ trả về (RAS). wđẩy địa chỉ IP hiện tại lên RAS và nếu chúng ta lặp lại &địa chỉ đó thì địa chỉ sẽ bị đẩy n lần. kbật một địa chỉ từ RAS và nhảy trở lại đó. Nếu RAS trống, nó không làm gì cả và vòng lặp được thoát.

Bạn có thể nhận thấy rằng không thể tầm thường để lồng các vòng lặp này, bởi vì ở cuối vòng lặp bên trong, ngăn xếp không trống, do đó, kkhông trở thành không có. Thay vào đó, IP sẽ quay trở lại điểm bắt đầu của vòng lặp bên ngoài. Cách chung để khắc phục điều này liên quan đến việc gói vòng lặp bên trong trong chương trình con của chính nó. Nhưng nếu chúng ta có thể sắp xếp vòng lặp lồng nhau sao cho vòng lặp bên ngoài kết thúc với vòng lặp bên trong, chúng ta thực sự có thể sử dụng hành vi này và thậm chí lưu vào một vòng lặp k!

Vì vậy, việc xây dựng này:

&wX&wYk

Là một vòng lặp lồng nhau làm việc chạy XYYYXYYYXYYY...(cho một số số Ys trong mỗi lần lặp). Thật gọn gàng khi chúng ta có thể kết thúc cả hai vòng bằng một lần duy nhất k, bởi vì nó sẽ tiêu thụ một địa chỉ bên ngoài từ RAS mỗi khi các địa chỉ bên trong bị cạn kiệt.

Thành ngữ này được sử dụng trong chương trình để chạy vòng lặp trên lưới đầu ra.

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.

Trên thực tế , 25 byte

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

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

Phiên bản 22 byte với rất nhiều dòng mới hàng đầu

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

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

R, 83 82 byte

-1 byte nhờ MickyT

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

Đọc Ntừ 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

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

Bình thường , 16 byte

j_.tm*\#/%LdSQ0S

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

SpecBAS - 149 byte

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

Một mảng theo dõi số lượng ước, sau đó in đúng số ký tự xuống vị trí màn hình 50.

PHP, 99 byte

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

in một không gian hàng đầu; chạy như đường ống với php -nr '<code>'hoặc thử trực tuyến .

phá vỡ

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 byte

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

Kịch bản kiểm tra ít chơi gôn hơn:

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

Đầu ra:

True
True
True

SOGL V0.12 , 8 byte

∫Λ⁄╗*}⁰H

Hãy thử nó ở đây!

Ngôn ngữ Wolfram (Mathicala) , 46 44 byte

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

Hãy thử trực tuyến! Nhưng có thể thử trực tuyến! với ColumnForm thay vì Grid , vì Gridkhông hoạt động trong TIO. Trong Mathematica, nó có vẻ tốt hơn:

Một giải pháp Mathicala thứ ba ... Divisors@Range@#tìm thấy tất cả các ước số trong phạm vi chúng ta muốn, sau đó chúng ta nhân 0và trừ " ", làm cho mọi ước số bằng-" " .

PadLeftthêm các số 0 ở bên trái, tạo đường chân trời nằm ngang, hướng mà chúng ta sửa với = \[Transpose]. Cuối cùng, thêm " "vào tất cả mọi thứ làm cho tất cả các mục0 hoặc " ".

Thay thế, 59 byte ""<>Riffle[PadLeft["X"-" "+0Divisors@Range@#]+" ","\n"]&tạo ra đầu ra chuỗi.

Thêm ++ , 58 byte

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

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

Làm thế nào nó hoạt động

Chương trình của chúng tôi bao gồm hai chức năng trợ giúp gvà kchức năng lambda chính.g$x$$1$$n$$d(x)$k lấy danh sách các ký tự và ghép chúng thành một chuỗi.

$A = [d(1), d(2), d(3), ..., d(n)]$#$A$$\max(A)$$A$từ mức tối đa này, trước khi thu được số khoảng trắng này cho mỗi phần tử và nối các khoảng trắng với các giá trị băm lặp lại. Tiếp theo, chúng tôi hoán chuyển và đảo ngược các hàng, trước khi nối từng dòng trên dòng mới. Cuối cùng, chúng tôi xuất ra đường chân trời.