正の整数の場合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. 1つの列と1つの行を拡張して、2の約数の余地を作ります
3. 1列を拡張して、3のスペースを作ります（2つの除数のみ）
4. 1つの列と1つの行を展開して、3つの除数（1,2,4）のためのスペースを作ります
5. 5列分のスペースを空けるために、1列を拡張します
6. 1つの列と1つの行を展開して、4つの除数（1,2,3,6）のスペースを確保します

最後にそれを反転し、文字列に変換し、暗黙的に0toを変更し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＃、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("#");
            }
    }
}

これも同様に短くできると確信していますが、一緒に短い解決策を達成することを望みます;）

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。入力を変数に保存しないことで、さらに2バイトを保存しました。説明：

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

編集：この18バイトの「ワンライナー」（リンクは冗長バージョンのコードへ）は、質問が提出された時点ではチャコールのバージョンでは動作しませんでした：オンラインで試してみてください！

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

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を超える入力を使用できますが、それらはまだ制限されており、非常に苦痛な入力形式です。さらに3バイトの場合、10進整数を読み取ることができます。

/
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回プッシュされます。kRASから1つのアドレスをポップし、そこにジャンプします。RASが空の場合、何も実行されず、ループは終了します。

これらのループをネストすることは簡単ではないことに気付くかもしれません。内側のループの最後ではスタックが空でkはないため、何も実行されません。代わりに、IPは外側のループの先頭に戻ります。これを修正する一般的な方法には、内部ループを独自のサブルーチンでラップすることが含まれます。しかし、外側のループが内側のループで終了するようにネストされたループを配置できる場合、実際にこの動作を利用して、1つを節約することさえできますk！

したがって、この構造：

&wX&wYk

XYYYXYYYXYYY...（Y各反復でいくつかのs に対して）を実行するネストされたループです。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バイト

MickyTのおかげで-1バイト

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

Nstdinから読み取ります。

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

先行スペースを1つ印刷します。でパイプとして実行する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@#-" "]+" "]&

オンラインでお試しください！ しかし、おそらくオンラインで試してみてください！GridTIOでは機能しないため、GridではなくColumnFormを使用します。Mathematicaでは、より良く見えます：

3番目のMathematicaソリューション... Divisors@Range@#必要な範囲内のすべての約数を見つけてから、乗算0と減算" "を行い、すべての約数をに等しくし-" "ます。

PadLeft左側にゼロを追加し、横向きのスカイラインを作成します。その向きは=で修正し\[Transpose]ます。最後に、" "すべてに追加すると、すべてのエントリが0またはになり" "ます。

代替として、59バイト""<>Riffle[PadLeft["X"-" "+0Divisors@Range@#]+" ","\n"]&は文字列出力を生成します。

Add ++、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$この最大数から、各要素にこの数のスペースを生成し、スペースを繰り返しハッシュに連結する前に。次に、各行を改行で結合する前に、行を転置および反転します。最後に、スカイラインを出力します。