一个井号（也称为数字符号，哈希或主题标签，或井号）是以下ASCII字符：

#

那不是很有趣的形状吗？让我们做更大的版本！所以这是您的挑战：

给定正整数N，输出大小为N的ASCII井号。

例如，大小为1的ASCII哈希标签如下所示：

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

允许在每行尾随空白，但不是必需的。

输入将始终是有效的正整数，因此您不必处理非数字，负数或0。您的输出可以是任何合理的格式，因此输出到STDOUT，返回字符串列表或带有换行符，二维字符矩阵，写入文件等都可以。

测试用例

2:
  ##  ##
  ##  ##
##########
##########
  ##  ##
  ##  ##
##########
##########
  ##  ##
  ##  ##

3:
   ###   ###   
   ###   ###   
   ###   ###   
###############
###############
###############
   ###   ###   
   ###   ###   
   ###   ###   
###############
###############
###############
   ###   ###   
   ###   ###   
   ###   ###   

4:
    ####    ####    
    ####    ####    
    ####    ####    
    ####    ####    
####################
####################
####################
####################
    ####    ####    
    ####    ####    
    ####    ####    
    ####    ####    
####################
####################
####################
####################
    ####    ####    
    ####    ####    
    ####    ####    
    ####    ####    

5:
     #####     #####     
     #####     #####     
     #####     #####     
     #####     #####     
     #####     #####     
#########################
#########################
#########################
#########################
#########################
     #####     #####     
     #####     #####     
     #####     #####     
     #####     #####     
     #####     #####     
#########################
#########################
#########################
#########################
#########################
     #####     #####     
     #####     #####     
     #####     #####     
     #####     #####     
     #####     #####     

由于这是一个代码问题，请尝试编写尽可能短的解决方案，最重要的是，请尽情享受！

MATL，20 16 12 11字节

3个字节，感谢DJMcMayhem。

1字节感谢Luis Mendo。

21BwY"&*~Zc

在线尝试！

说明

    % stack starts with input e.g. 2
21  % push 21 to stack             2 21
B   % convert to binary            2 [1 0 1 0 1]
w   % swap                         [1 0 1 0 1] 2
Y"  % repeat                       [1 1 0 0 1 1 0 0 1 1]
&*  % one-input multiplication    [[1 1 0 0 1 1 0 0 1 1]
                                   [1 1 0 0 1 1 0 0 1 1]
                                   [0 0 0 0 0 0 0 0 0 0]
                                   [0 0 0 0 0 0 0 0 0 0]
                                   [1 1 0 0 1 1 0 0 1 1]
                                   [1 1 0 0 1 1 0 0 1 1]
                                   [0 0 0 0 0 0 0 0 0 0]
                                   [0 0 0 0 0 0 0 0 0 0]
                                   [1 1 0 0 1 1 0 0 1 1]
                                   [1 1 0 0 1 1 0 0 1 1]]
~   % complement                  [[0 0 1 1 0 0 1 1 0 0]
                                   [0 0 1 1 0 0 1 1 0 0]
                                   [1 1 1 1 1 1 1 1 1 1]
                                   [1 1 1 1 1 1 1 1 1 1]
                                   [0 0 1 1 0 0 1 1 0 0]
                                   [0 0 1 1 0 0 1 1 0 0]
                                   [1 1 1 1 1 1 1 1 1 1]
                                   [1 1 1 1 1 1 1 1 1 1]
                                   [0 0 1 1 0 0 1 1 0 0]
                                   [0 0 1 1 0 0 1 1 0 0]]
Zc  % convert 0 to spaces            ##  ##  
      1 to octothorpes               ##  ##  
      and join by newline          ##########
                                   ##########
                                     ##  ##  
                                     ##  ##  
                                   ##########
                                   ##########
                                     ##  ##  
                                     ##  ##  

Brain-Flak，420字节

(()()()){({}<(({})){({}<<>(<>({})<>){({}<((((()()()()){}){}()){}())>[(
)])}{}(<>({})<>){({}<((((()()()()){}){}){})>[()])}{}(<>({})<>){({}<(((
(()()()()){}){}()){}())>[()])}{}(<>({})<>){({}<((((()()()()){}){}){})>
[()])}{}((()()()()()){})<>>[()])}{}((({}))<(({})(({}){}){})>){({}<<>(<
>({})<>){({}<((((()()()()){}){}()){}())>[()])}{}((()()()()()){})<>>[()
])}{}{}>[()])}{}({}<>)(({})((({({})({}[()])}{})){}){}{}){({}<{}>[()])}

在线尝试！

不，420分不是故意的。我承诺。可读版本：

# 3 Times...
(()()())
{
({}<

    #Duplicate the input
    (({}))

    #Input times...
    {
        ({}<

        #Switch to the main stack
        <>

        #Grab the duplicate of the input
        (<>({})<>)

        #That many times...
        {({}<

            # Push a hash
            ((((()()()()){}){}()){}())

        >[()])}{}

        #Grab the duplicate of the input
        (<>({})<>)

        #That many times...
        {({}<

            #Push a space
            ((((()()()()){}){}){})

        >[()])}{}

        #Grab the duplicate of the input
        (<>({})<>)

        #That many times...
        {({}<

            # Push a hash
            ((((()()()()){}){}()){}())

        >[()])}{}

        #Grab the duplicate of the input
        (<>({})<>)

        #That many times...
        {({}<

            #Push a space
            ((((()()()()){}){}){})

        >[()])}{}

        #Push a newline
        ((()()()()()){})

        #Toggle back to the alternate stack
        <>

        #Decrement the (second) loop counter
        >[()])

    #Endwhile
    }

    #Pop the now zeroed loop counter
    {}

    #Turn [a] into [a, a*5, a]
    ((({}))<(({})(({}){}){})>)

    #A times....
    {
        ({}<

        #Toggle back over
        <>

        #Grab a*5
        (<>({})<>)

        #That many times...
        {({}<

            #Push a space
            ((((()()()()){}){}()){}())

        >[()])}{}

        #Push a newline
        ((()()()()()){})

        #Toggle back
        <>

        #Decrement the (second) loop counter
        >[()])

    }

    #Pop the loop counter and the a*5
    {}{}

#Decrement the outer loop counter
>[()])
}

#Pop the zeroed loop counter
{}

#Pop a over
({}<>)

#Pushes (a**2) * 5 + a
(({})((({({})({}[()])}{})){}){}{})

#That many times...
{({}<

    #Pop a character off the output stack
    {}

>[()])}

6502机器代码（C64），59 56字节

00 C0 20 9B B7 A9 06 85 FC 86 FE A6 FE 86 FD A9 03 4D 1F C0 8D 1F C0 C6 FC D0
01 60 A9 23 A0 05 49 00 20 D2 FF CA D0 FA A6 FE 88 D0 F3 A9 0D 20 D2 FF C6 FD
D0 E6 F0 D3

在线演示

用法：SYS49152,N其中N是1到255之间的数字。

_{（对于C64屏幕，大于4的值将已经太大，从8开始，输出甚至太宽）}

说明：

         00 C0       .WORD $C000    ; load address

.C:c000  20 9B B7    JSR $B79B      ; read N into X
.C:c003  A9 06       LDA #$06       ; number of "logical" lines plus 1 for hash
.C:c005  85 FC       STA $FC        ; store in counter variable for lines
.C:c007  86 FE       STX $FE        ; store N in counter variable for char repetitions
.C:c009  A6 FE       LDX $FE        ; load repetition counter
.C:c00b  86 FD       STX $FD        ; store in counter variable for line repetitions
.C:c00d  A9 03       LDA #$03       ; value to toggle the character toggle
.C:c00f  4D 1F C0    EOR $C01F      ; xor character bit toggle
.C:c012  8D 1F C0    STA $C01F      ; store character bit toggle
.C:c015  C6 FC       DEC $FC        ; decrement "logical" lines
.C:c017  D0 01       BNE $C01A      ; not 0 -> continue
.C:c019  60          RTS            ; program done
.C:c01a  A9 23       LDA #$23       ; load hash character
.C:c01c  A0 05       LDY #$05       ; load "logical" columns for hash
.C:c01e  49 00       EOR #$00       ; in each odd "logical" line, toggle character
.C:c020  20 D2 FF    JSR $FFD2      ; output one character
.C:c023  CA          DEX            ; decrement character repetition
.C:c024  D0 FA       BNE $C020      ; not 0 -> back to output
.C:c026  A6 FE       LDX $FE        ; reload character repetition
.C:c028  88          DEY            ; decrement "logical" columns
.C:c029  D0 F3       BNE $C01E      ; not 0 -> back to character toggle
.C:c02b  A9 0D       LDA #$0D       ; line done, load newline character
.C:c02d  20 D2 FF    JSR $FFD2      ; and output
.C:c030  C6 FD       DEC $FD        ; decrement line repetitions
.C:c032  D0 E6       BNE $C01A      ; not 0 -> back to character init
.C:c034  F0 D3       BEQ $C009      ; else back to main loop (toggle char toggling)

Haskell，43个字节

l%n=l!!1:l++l<*[1..n]
f n=["##"%n,"# "%n]%n

在线尝试！

输出字符串列表。

Python 2，55个字节

def f(n):p=[(" "*n+"#"*n)*2]*n;print(p+["#"*n*5]*n)*2+p

在线尝试！

这将返回二维字符列表。

Python 2，65个字节

def f(n):p=((" "*n+"#"*n)*2+"\n")*n;print(p+("#"*n*5+"\n")*n)*2+p

在线尝试！

Python 2，66字节

def f(n):p=[(" "*n+"#"*n)*2]*n;print'\n'.join((p+["#"*n*5]*n)*2+p)

在线尝试！

木炭，21字节

ＮθＵＯײθ#ＵＯθ Ｆ²⟲ＯＯ²⁴⁶θ

在线尝试！链接是详细版本的代码。我最初尝试了一种可爱的位图方法：

Ｆ⁵Ｆ⁵Ｆ＆｜ικ¹«Ｊ×ιＩθ×κＩθＵＯθ#

在线尝试！链接是详细版本的代码。说明：通过将#视为5×5正方形阵列来工作。需要填写奇数行或奇数列中的正方形。

J，22个字节

#('# '{~#:5$21,0)#~"1]

在线尝试！

与其他J答案有很多相似之处，尽管我不太理解带有很多名词的火车，所以我的答案有3个可能的字节要删减（两个paren和一个reflexive- ~）。

说明

生成八丁烷

八角形是由括号中的所有内容组成的，为方便起见，以下复制。

'# '{~#:5$21,0

我制作八面体的很多方法都是滥用J在数组不够长时填充其数组的方式。

21,0简单地创建数组21 0。

5$将该数组重塑为5原子数组：21 0 21 0 21。

#:将每个原子转换为二进制数。由于#:对每个原子进行操作，因此输出为矩阵。每个21元素均按1 0 1 0 1预期替换，但每个元素0均替换为0 0 0 0 0！这是因为J填充数组的时间不足以匹配最终的2D数组的形状，而二维数组5 5由于1 0 1 0 1行而被迫。幸运的是，对于用填充的数字0，我们得到了结果矩阵

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

'# '{~将每个都转换1为一个空格，并转换0为#。{表示“取”，~表示“切换二元自变量，因此J将矩阵中的每个元素都看做字符串的索引，这'# '意味着每个0元素都成为第零个元素，#并且每个元素都1成为第一个元素，即一个空格。这产生​​一个八度的大小。

调整八面体的大小

这只是n沿每个轴复制时间的问题，使用

第一个#（是钩子的一部分）和#~"1]。#沿水平轴#"1复制，沿垂直轴复制。

CJam，27 26 25字节

{_[{S3*'#*'#5*}3*;]fe*e*}

在线尝试！

有趣的事实：该字节最初以29个字节开始，从那以后，在块和全程序模式之间交替地逐个删除了字节。

说明：

{                          e# Stack:               | 2
 _                         e# Duplicate:           | 2 2
  [                        e# Begin array:         | 2 2 [
   {                       e# Do the following 3 times:
    S                      e#   Push a space       | 2 2 [" "
     3*                    e#   Repeat it 3 times: | 2 2 ["   "
       '#*                 e#   Join with '#':     | 2 2 [" # # "
          '#               e#   Push '#':          | 2 2 [" # # " '#
            5*             e#   Repeat it 5 times: | 2 2 [" # # " "#####"
              }3*          e# End:                 | 2 2 [" # # " "#####" " # # " "#####" " # # " "#####"
                 ;         e# Delete top of stack: | 2 2 [" # # " "#####" " # # " "#####" " # # "
                  ]        e# End array:           | 2 2 [" # # " "#####" " # # " "#####" " # # "]
                   fe*     e# Repeat characters:   | 2 ["  ##  ##  " "##########" "  ##  ##  " "##########" "  ##  ##  "]
                      e*   e# Repeat strings:      | ["  ##  ##  " "  ##  ##  " "##########" "##########" "  ##  ##  " "  ##  ##  " "##########" "##########" "  ##  ##  " "  ##  ##  "]
                        }  e# End
e# Result:
e# ["  ##  ##  "
e#  "  ##  ##  "
e#  "##########"
e#  "##########"
e#  "  ##  ##  "
e#  "  ##  ##  "
e#  "##########"
e#  "##########"
e#  "  ##  ##  "
e#  "  ##  ##  "]

外壳，12个 10字节

´Ṫ▲Ṙ" # # 

在线尝试！ 注意尾随空格。

说明

´Ṫ▲Ṙ" # #   Implicit input, e.g. n=2.
   Ṙ" # #   Repeat each character of the string n times: "  ##  ##  "
´Ṫ          Outer product with itself by
  ▲         maximum: ["  ##  ##  ","  ##  ##  ","##########","##########","  ##  ##  ","  ##  ##  ","##########","##########","  ##  ##  ","  ##  ##  "]
            Print implicitly, separated by newlines.

J，23 19字节

' #'{~1=]+./~@#i:@2

感谢@LeakyNun，节省了4个字节。

在线尝试！

说明

' #'{~1=]+./~@#i:@2  Input: integer n
                  2  The constant 2
               i:@   Range [-2, -1, 0, 1, 2]
        ]            Get n
              #      Copy each n times
         +./~@       GCD table
      1=             Equals 1, forms the hashtag for input 1
' #'{~               Index and select the char

果冻，14 13 11字节

@JonathanAllen节省了2个字节

5ẋ€Ẏ&þ`ị⁾ #

返回行列表的单子链接。注意尾随空格。

在线尝试！

怎么运行的

5ẋ€Ẏ&þ`ị⁾ #    Main link. Arguments: n (integer)            1
5              Yield 5.
 ẋ€            Create a range and repeat each item n times. [[1], [2], [3], [4], [5]]
   Ẏ           Tighten; dump all sublists into the main list.
                                                            [1, 2, 3, 4, 5]
     þ         Create a table of                            [[1, 0, 1, 0, 1],
    &          bitwise ANDs,                                 [0, 2, 2, 0, 0],
      `        reusing this list.                            [1, 2, 3, 0, 1],
                                                             [0, 0, 0, 4, 4],
                                                             [1, 0, 1, 4, 5]]
       ị⁾ #    Index into the string " #".                   [" # # ",
               0 -> "#", 1 -> " ", 2 -> "#", etc.             "#####",
                                                              " # # ",
                                                              "#####",
                                                              " # # "]

游戏制作者语言，138108字节

n=argument0 s=''for(j=0;j<5*n;j+=1){for(l=0;l<5*n;l+=1)if(j div n|l div n)&1s+='#'else s+=' 's+='
'}return s

旨在作为脚本（用户定义功能的Game Maker名称），也就是n=argument0和return s。通过n直接从当前实例获取并使用20字节，可以将其剃光s。（无论如何，实例都获得了这些变量，因为未使用声明它们var）。

当然要注意，#Game Maker的图形素材会使用它作为替代的换行符，因此\如果要输出到屏幕，则可能要给它加上前缀;）

还要注意，我在这里使用Game Maker 8.0的GML版本。现代GML版本可能具有可以节省更多字节的功能。

一些想法由朋友wareya和chordbug提供。

Perl 5、49 +1（-p）= 50字节

$_=' # # 
'=~s/./$&x$_/gre x$_;$_.=(y/ /#/r.$_)x2

在线尝试！

怎么样？

通过-p标志将输入隐式存储在$ _中。从最基本的最上面一行开始，" # # "再加上结尾的换行符。通过输入数字复制每个字符。然后通过输入数字将其复制以形成八叉戟的顶部，并将所有这些存储在$中。然后，在该行后面附加所有字符，并用“＃”乘以输入数字。然后附加顶部。最后两个句子总共要重复两次。$的输出隐含在-p标志中。

05AB1E，25 22 21字节

•LQ•bûε×}5ôεS„# èJ¹F=

在线尝试！

-1是因为Emigna讨厌音译，而且，谢天谢地，提醒我我也应该：P。

比起位图，它是更好的方法...仍在工作。

JavaScript（ES6），79个字节

f=
n=>[...Array(n*5)].map((_,i,a)=>a.map((_,j)=>` #`[(i/n|j/n)&1]).join``).join`
`

<input type=number oninput=o.textContent=f(this.value)><pre id=o>

我最初尝试使用木炭时使用的位图方法的端口。

Python 2中，124，116，113，112，98，96 66个字节

新增功能（来源：HyperNeutrino）：

def f(a):i='print(" "*a+"#"*a)*2;'*a;exec(i+'print"#"*a*5;'*a)*2+i

旧：

a=input();b,c="# "
for i in"012":
	exec'print c*a+b*a+c*a+b*a;'*a
	if i<"2":exec'print b*a*5;'*a

在线尝试！

显然，这不是最短的解决方案，但我认为它是不错的。对于任何反馈，我们都表示感谢！

Brain-Flak，338332字节

6字节感谢赖利。

(({}<>)<(())>)(()()()()()){({}<(<>)<>{({}<<>({}<(((((()()()()())){})){}{}{})<>([({})]()){(<{}({}<((((({}))){}){}{}){({}<<>(({}))<>>[()])}{}>)>)}{}(({})<{{}(<(()()()()()){({}<<>(<([{}](((((()()){}){}){}){}()){}())>)<>{({}<<>({}<(({}))>())<>>[()])}<>({}<>{})>[()])}{}>)}>{})<>((()()()()()){})>())<>>[()])}<>({}<>{}<([{}]())>)>[()])}<>

在线尝试！

更多“可读”版本

(({}<>)<(())>)(()()()()())
{({}<(<>)<>{({}<<>({}<(((((()()()()())){})){}{}{})<>
  ([({})]()){(<{}({}<
    ((((({}))){}){}{}){({}<<>(({}))<>>[()])}{}
  >)>)}{}(({})<{{}(<
    (()()()()()){({}<<>(<([{}](((((()()){}){}){}){}()){}())>)<>{({}<<>({}<(({}))>())<>>[()])}<>({}<>{})>[()])}{}
  >)}>{})
<>((()()()()()){})>())<>>[()])}<>({}<>{}<([{}]())>)>[()])}<>

在线尝试！

SOGL（SOGLOnline commit 2940dbe），15 个字节

ø─Ζ┘Χ⁴‘5n{.∙.*T

要运行此程序，请下载此程序并运行index.html文件中的代码。

使用该提交时（及其之前）*重复每个字符，而不是整个字符串。

说明：

ø─Ζ┘Χ⁴‘          push " # # ##### # # ##### # # "
       5n        split into lines of length 5
         {       for each line do
          .∙       multiply vertically input times
            .*     multiply horizontally input times
              T    output in a new line

奖励：为单独的X和Y长度添加2个输入！

brainfuck，224个字节

,[->+>>>>+<<<<<]>>>+>+++++[-<<<[->+>>>>>+>+++++[-<<<[->+<<<[->>>>>>+<<[->>>+>---<<<<]<<<<]>>>>>>[-<<<<<<+>>>>>>]>[-<<<+>>>]+++++[->+++++++<]>.[-]<<<<<<]>[-<+>]>[-<->]<+[->+<]>>]<<++++++++++.[-]<<<<<]>[-<+>]>[-<->]<+[->+<]>>]

在线尝试！

由...制成

我试图手工构建此代码，并花费了几个小时，所以我决定使用Python编写转译器。

这是我输入的用于生成此代码的代码：

read(0)
copy(0,(1,1),(5,1))
add(3,1)
add(4,5)
loop(4)
loop(1)
add(2,1)

add(7,1)
add(8,5)
loop(8)
loop(5)
add(6,1)

loop(3)
add(9,1)
loop(7)
add(10,1)
add(11,-3)
end(7)
end(3)
copy(9,(3,1))
copy(10,(7,1))
add(10,5)
copy(10,(11,7))
write(11)
clear(11)

end(5)
copy(6,(5,1))
copy(7,(6,-1))
add(6,1)
copy(6,(7,1))
end(8)
add(6,10)
write(6)
clear(6)

end(1)
copy(2,(1,1))
copy(3,(2,-1))
add(2,1)
copy(2,(3,1))
end(4)

在线尝试！

C（gcc），98 93字节

5字节感谢Felix Palmen。

i,j;main(a){for(scanf("%d",&a);j<a*5||(j=!puts(""),++i<a*5);)putchar(i/a+1&j++/a+1&1?32:35);}

在线尝试！

盖亚 9字节

 # ”ṫ&:Ṁ‡

相当多的端口Zgarb是伟大的答案

在线尝试！（页脚仅用于漂亮打印，程序本身返回二维字符列表）

说明

 # ”       Push the string " # "
    ṫ      Bounce, giving " # # "
     &     Repeat each character by input
      :    Copy
       Ṁ‡  Tabled maximum with itself

Befunge，105个 103字节

p9p&5*08p>08g-   v
>,g1+:00p^v0:/5g8_p9g1+:09p08g-#v_@
gvg90\/\g0< # # ##### 0:/5g8,+55<
^>\/2%5*+92++2

在线尝试！

Python，88 84 77字节

lambda x:[[(' #'[i//x%2]+'#')[j//x%2]for j in range(5*x)]for i in range(5*x)]

在线尝试！

返回二维字符列表。

PowerShell，72 68 63 60字节

param($a)(,($x=,((' '*$a+"#"*$a)*2)*$a)+,("#"*5*$a)*$a)*2;$x

在线尝试！

接受输入$a。然后，我们进行了许多魔术字符串和数组操作。

(,($x=,((' '*$a+"#"*$a)*2)*$a)+,("#"*5*$a)*$a)*2;$x
         ' '*$a+"#"*$a                              # Construct a string of spaces and #
        (             )*2                           # Repeat it twice
      ,(                 )*$a                       # Repeat that $a times to get the top as an array
  ($x=                       )                      # Store that into $x and immediately output it
 ,                            +                     # Array concatenate that with ...
                               ,("#"*5*$a)          # another string, the middle bar ...
                                          *$a       # repeated $a times.
(                                            )*2;   # Do that twice
                                                 $x # Output $x again

您可以从底部开始剥离解释的各个部分，以了解输出的构造方式，因此希望我的解释有意义。

Haskell，72个字节

a#b=a++b++a++b++a
c%l=((c<$l)#('#'<$l))<$l
f n=(' '%[1..n])#('#'%[1..n])

返回字符串列表。在线尝试！

怎么运行的：

a#b=a++b++a++b++a          -- concatenate the strings a and b in the given pattern
c%l=                       -- take a char c and a list l (we only use the length
                           -- of l, the actual content doesn't matter)
    c<$l                   -- make length l copies of c
         '#'<$l            -- make length l copies of '#'
        #                  -- combine them via function #
               <$l         -- and make length l copies of that string
f n=                       -- main function
              #            -- make the "a b a b a" pattern with the strings
                           -- returned by the calls to function %                                
    ' '%[1..n]             --   one time with a space 
               '#'%[1..n]  --   one time with a '#'

Mathematica，63个字节

ArrayFlatten@Array[x=#;Table[If[OddQ@-##," ","#"],x,x]&,{5,5}]&

说明

ArrayFlatten@Array[x=#;Table[If[OddQ@-##," ","#"],x,x]&,{5,5}]&  (* input N *)

                   x=#                                           (* Set x to N *)
                                                      &          (* A function that takes two inputs: *)
                             If[OddQ@-##," ","#"]                (* if both inputs are odd (1), " ". "#" otherwise *)
                       Table[                    ,x,x]           (* Make N x N array of that string *)
             Array[                                     ,{5,5}]  (* Make a 5 x 5 array, applying that function to each index *)
ArrayFlatten@                                                    (* Flatten into 2D array *)

_{（1）-##解析成Times[-1, ##]}

Python 2，113字节

作为字符串数组：

r=[1-1*(i%(2*n)<n)for i in range(5*n)]
print[''.join(' #'[r[k]+r[j]>0]for k in range(len(r)))for j in range(n*5)]

作为ASCII艺术：

Python 3，115个字节

r=[1-1*(i%(2*n)<n)for i in range(5*n)]
for j in range(n*5):print(*(' #'[r[k]+r[j]>0]for k in range(len(r))),sep='')

Python 3，117个字节

p=range(5*n)
for i,e in enumerate([j%(2*n)>=n for j in p]for k in p):print(*[' #'[i%(2*n)>=n or k]for k in e],sep='')

作为布尔数组

p=range(5*n)
f=lambda o:o%(2*n)>=n
print[[f(j)or f(i)for j in p]for i in p]

Java 8，103字节

Lambda接受Integer并打印八面体以使其标准化。投放到Consumer<Integer>。

n->{for(int s=5*n,x=0,y;x<s;x++)for(y=0;y<s;)System.out.print((x/n%2+y++/n%2>0?'#':32)+(y<s?"":"\n"));}

在线试用

非高尔夫λ

n -> {
    for (
        int
            s = 5 * n,
            x = 0,
            y
        ;
        x < s;
        x++
    )
        for (y = 0; y < s; )
            System.out.print(
                (x / n % 2 + y++ / n % 2 > 0 ? '#' : 32)
                + (y < s ? "" : "\n")
            );
}

此处的主要观察结果是，在n × n单元的5×5网格上，八面锥出现在行号或列号（从0开始）是奇数的任何地方。我敢肯定，这是最便宜的一般方法，但似乎更适合高尔夫。

致谢

• -1字节感谢Kevin Cruijssen

Pyth，28 22字节

-6个字节，感谢@LeakyNun

JsC*]S5Qjmsm@"# "*kdJJ

测试套件。

R，87 85 62字节

m=matrix(" ",x<-scan()*5,x);m[s,]=m[,s<-rep(!1:0,e=x/5)]="#";m

感谢LeakyNun，通过将c（F，T）表示为！1：0节省了2个字节

Giuseppe节省了23个字节

在线尝试！

说明（无胶体）：

x=scan()*5              # Multiply input by 5 to get the required width/height of the matrix
m=matrix(" ",x,x)       # Create a matrix of the required dimensions
s=rep(!1:0,each=x/5)    # The sequence s consists of F repeated n times, followed by T repeated n times
m[s,]="#"               # Use s as logical indices to set those rows as "#" characters.
                        # R recycles the sequence to the height of the matrix.
m[,s]="#"               # Same, with columns
write(m,"",x,,"")       # Print out across the required number of columns