对于任何正整数k，令d(k)表示的除数k。例如，d(6)是4，因为6具有4除数（即1，2，3，6）。

给定一个正整数N，使用固定的字符，使得“建筑物”位于水平位置的高度显示ASCII技术中的“地平线” k是d(k)为k = 1, ..., N。请参阅下面的测试案例。

规则

• 可以一致地使用任何非空白字符，不一定非要#如测试用例所示。
• 该算法在理论上应该适用于任意高N。实际上，如果程序受时间，内存，数据类型大小或屏幕大小的限制，这是可以接受的。
• 允许水平或垂直前导或尾随空格或换行符。
• 输入和输出可以通过任何合理的方式进行。
• 允许使用任何编程语言编写程序或功能。禁止出现标准漏洞。
• 以字节为单位的最短代码获胜。

测试用例

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取Int并返回String。

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

在线尝试！

• m是NOP的（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= 等于零（即除）

+⌿ 对列求和（即给出每个数字的除数计数）

'#'⍴¨⍨ 使用每个数字来重塑哈希字符（给出字符串列表）

↑ 混合（将字符串列表放入行表）

⍉ 转置

⊖ 上下翻转

Mathematica，59 57字节

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

C＃，333281字节

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

虽然我确信这也可能会更短，但我希望我们能一起实现更短的解决方案；

在raznagul的帮助下保存了52个字节

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字节

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

在线尝试！链接是详细版本的代码。编辑：通过k从0到循环i-1并1在循环内添加，保存了1个字节。通过不将输入存储在变量中，又节省了两个字节。说明：

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

编辑：在提交问题时，此18字节的“单线”（链接是详细版本的代码）将无法与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字节

@ETHproductions节省了17个字节

õ@'#pXâ l÷z w

在线尝试！

J，28个字节

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

定义单子动词。 在线尝试！

说明

[:|:&.|.[('#',@$~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的空格，在第一个!s 之前将有很多行空格。）

说明

我之前曾经使用并解释过这种&w...k构造（例如此处）。这是一个简洁的小习惯用法，它弹出一个整数n，然后运行一段代码n + 1次（因此，通常t&w...k将其循环运行n次，并t递减输入值）。这是通过使用返回地址堆栈（RAS）来完成的。w将当前IP地址推送到RAS，如果重复此操作，&则该地址将被推送n次。k从RAS弹出一个地址，然后跳回那里。如果RAS为空，则它什么也不做，并且退出循环。

您可能会注意到，嵌套这些循环并不容易，因为在内部循环的末尾，堆栈不是空的，因此k不会成为空操作。相反，IP会跳回到外循环的开始。解决此问题的一般方法包括将内部循环包装在其自己的子例程中。但是，如果我们可以安排嵌套循环，使外循环以内循环结束，那么我们实际上可以利用这种行为，甚至可以节省一个k！

所以这个构造：

&wX&wYk

是一个工作的嵌套循环，运行XYYYXYYYXYYY...（Y每个迭代中有一定数量的）。我们可以用一个结束两个循环，这很不错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字节版本，带有许多领先的换行符

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

少打高尔夫的测试脚本：

$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在左侧添加零，创建侧向天际线，我们使用= 固定其方向\[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$从这个最大值开始，在为每个元素产生此数量的空格并将这些空格连接到重复的哈希之前。接下来，在对换行进行连接之前，我们对行进行转置和反转。最后，我们输出天际线。