除数的天际线


46

对于任何正整数k,令d(k)表示的除数k。例如,d(6)4,因为6具有4除数(即1236)。

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

规则

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

测试用例

N = 10

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

N = 50

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

N = 200

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

Answers:



7

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

看到它在这里工作


7

八度,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


   #
 ####
#####

1
很好的方法!
路易斯·门多

2
Octave隐式执行单例扩展,因此为@(N)" #"(sort(~mod(k=1:N,k')+1))您节省了几个字节:)尽管您得到了一堆领先的换行符,但我不确定这方面的规则是什么。
斯蒂夫·格里芬

1
相同BYTECOUNT(32): @(N)['',35*sort(~mod(k=1:N,k'))]
斯蒂夫·格里芬

@StewieGriffin谢谢!我不知道该功能。是mod(1:N,(1:N).') 在MATLAB接受吗?
rahnema1年

2
认为从R2016b开始是可能的,但是很遗憾,我自己无法测试,因为我没有它。
Stewie Griffin'5

6

Haskell,71个字节

fInt并返回String

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

在线尝试!

  • mNOP的(Haskell变量必须为小写。)
  • l=[1..m]在嵌套列表推导中使用缩写,以迭代遍历所有行,列和可能的除数。这意味着一些额外的初始行充满空白。
  • n是列(也检查数字),i是行。
  • ['#'|0<-mod n<$>l]是一个'#'字符列表,其长度为的除数n

6

八度,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)腾出空间

最后,我们将其翻转,并将其转换为字符串,将其隐式更改032

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

5

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

在线尝试!


这会产生一些领先的垂直空白


5

APL(Dyalog),19字节

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

在线尝试!

 获得评估输入(N

 1 ... N

∘.|⍨垂直和水平轴均 具有1 ... N的除法余数表

0= 等于零(即除)

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

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

 混合(将字符串列表放入行表)

 转置

 上下翻转


5

Mathematica,59 57字节

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

在此处输入图片说明


欢迎回答关于PPCG的问题,同乐高minifig :-)
Luis

1
现在没有回头路了
Luis Mendo

欢迎!很高兴见到另一位Mathematica高尔夫球手。不过,此答案并非完全有效,因为您已将输入硬编码到代码段中。答案必须是完整程序或可调用函数(尽管可能未命名)。因此,这可以通过更换固定在没有成本50#和追加&。您也可以使用中缀符号保存一些字节:X~Table~#&0~DivisorSigma~Range@#
Martin Ender

@MartinEnder谢谢。从测试转到答案时,我忘了这一点。并感谢有关插入的提示。它不是我通常使用的东西(因为我并不真正打高尔夫球)。
伊恩·米勒

我也这么想 它更多是在面颊上发表评论。对困惑感到抱歉。
伊恩·米勒

5

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


1
如果使用int数组而不是列表,则可以从using-statement中节省很多字节。
raznagul

@raznagul更新了它。
MetaColon

222个字节:using System.Linq;using C=System.Console;n=>{var v=new int[n];for(var k=1,i;++k<=n;)for(i=1;i<k;)if(k%i++==0)v[k-1]++;for(var i=0,u;i<v.Length;i++)for(u=v.Max()-v[i];u<v.Max();){C.SetCursorPosition(i, u++);C.Write("#");}};编译为Action,移动增量,然后进行一些其他小的调整。我还没有测试过,但是应该可以。
TheLethalCoder

@TheLethalCoder我将对其进行测试/明天更新我的答案。
MetaColon

5

Mathematica,99个字节

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

对于N = 50

在此处输入图片说明


代码运行是否需要所有这些空格(和换行符)?我从来没有自己编程过Mathematica,但是在大多数语言中,您几乎可以删除所有这些空格。
凯文·克鲁伊森

这是我的第一次高尔夫。感谢您的提示
J42161217

2
没问题,欢迎使用PPCG!如果您还没有阅读过,可能会发现<all language> 打高尔夫球的技巧Mathematica中打高尔夫球的技巧。:) 入住愉快。
凯文·克鲁伊森

外部花括号可以更改为圆括号,以防止它们显示在输出中,并且您可以使用一些infix / prefix语法来保存2个字节:(T=0~DivisorSigma~Range@#;Row[Column/@Table[Join[Table[,Max@T-T[[i]]],$~Table~T[[i]]],{i,1,#}]])&
numbermaniac

5

木炭23 22 20字节

F…·¹N«Jι⁰Fι¿¬﹪ι⁺κ¹↑#

在线尝试!链接是详细版本的代码。编辑:通过k0到循环i-11在循环内添加,保存了1个字节。通过不将输入存储在变量中,又节省了两个字节。说明:

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

编辑:在提交问题时,此18字节的“单线”(链接是详细版本的代码)将无法与Charcoal版本一起使用:在线尝试!

↑E…·¹N⪫Eι⎇﹪ι⁺¹λω#ω


3

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编码。在线尝试!


您不能使用ζ代替.Bø吗?此外,角色也不必是#
Oliver Ni

ζ当时不存在。
魔术章鱼缸

3

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行,其中大部分通常为空白。



2

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.



2

爱丽丝,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.

1
有没有第一个单行的Alice程序?:-)
路易斯·门多

1
@LuisMendo不,我认为Leo编写了一些仅适用于Cardinal的程序(也许我也有...例如quine和Hello,World)。可能是最详尽的单行程序。:)
马丁·恩德

嗯,我的解决方案可以用“大量的领先空白”技巧节省一些字节
quintopia'5


2

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

在线尝试!


1
!=0可能是>0
MickyT


1

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。

在此处输入图片说明


1

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

1

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


1

Wolfram语言(Mathematica)46 44字节

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

在线尝试! 但也许可以在线尝试!使用ColumnForm而不是Grid,因为Grid在TIO中不起作用。在Mathematica中,看起来更好:

Mathematica输出

第三个Mathematica解决方案... Divisors@Range@#查找所需范围内的所有除数,然后乘以0并减去" ",从而使每个除数等于-" "

PadLeft在左侧添加零,创建侧向天际线,我们使用= 固定其方向\[Transpose]。最后,添加" "到所有内容后,所有条目都变为0" "

或者,59字节""<>Riffle[PadLeft["X"-" "+0Divisors@Range@#]+" ","\n"]&产生字符串输出。


1

加++,58字节

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

在线尝试!

这个怎么运作

gkgx1nd(x)k

A=[d(1),d(2),d(3),...,d(n)]#Amax(A)A从这个最大值开始,在为每个元素产生此数量的空格并将这些空格连接到重复的哈希之前。接下来,在对换行进行连接之前,我们对行进行转置和反转。最后,我们输出天际线。

By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.