アンシャープ、（とも呼ばれる番号記号、ハッシュまたはハッシュタグ、またはシャープ記号）は、以下のASCII文字は次のとおりです。

#

それは楽しい形ではありませんか？それのより大きなバージョンを作ろう！だからここにあなたの挑戦があります：

正の整数Nを指定すると、サイズNの ASCIIハッシュタグが出力されます。

たとえば、サイズ1の ASCIIハッシュタグは次のようになります。

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

各行の末尾の空白は許可されますが、必須ではありません。

入力は常に有効な正の整数であるため、非数値、負、または0を処理する必要はありません。出力は任意の適切な形式であるため、STDOUTに出力し、文字列のリストまたは文字列を返します。改行、文字の2Dマトリックス、ファイルへの書き込みなどはすべて問題ありません。

テストケース

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

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

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

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

これはコードゴルフなので、できる限り短いソリューションを作成し、何よりも楽しんでください。

MATL、20 16 12 11バイト

DJMcMayhemのおかげで3バイト。

Luis Mendoのおかげで1バイト。

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,NNは1〜255の数値です。

_{（4より大きい値は、8から始まるC64画面には既に大きすぎるため、出力が広すぎます）}

説明：

         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

オンラインでお試しください！

これは、文字の2Dリストを返します。

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バイト（2つの括弧と反射~）があります。

説明

オクトソープの生成

オクトソープは、括弧内のすべてのもので作られています。

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

オクトソープを作成する方法の多くは、Jが十分に長くないときに配列をパディングする方法の乱用です。

21,0単に配列を作成し21 0ます。

5$その配列を5原子配列に整形します21 0 21 0 21。

#:各原子を2進数に変換します。#:各アトムで動作するため、出力は行列です。それぞれ21が1 0 1 0 1期待どおりに0置き換えられ0 0 0 0 0ますが、それぞれは！これは、J 5 5が、1 0 1 0 1行のために強制される結果の2D配列の形状に一致するのに十分な長さの配列をパディングしないためです。幸いなことに、数字の場合はで埋め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が0番目の要素に#なり、それぞれ1が最初の要素、つまりスペースになることを意味します。

オクトソープのサイズ変更

これは、n各軸に沿って時間をコピーするだけの問題で、

最初#（フックの一部）および#~"1]。#水平軸に#"1沿ってコピーし、垂直軸に沿ってコピーします。

CJam、27 26 25バイト

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

オンラインでお試しください！

おもしろい事実：これはもともと29バイトから始まり、それ以降、ブロックモードとフルプログラムモードを交互にバイトが1つずつ削除されています。

説明：

{                          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

スクリプト（ユーザー定義関数のゲームメーカーの名前）であるため、n=argument0およびreturn sです。n現在のインスタンスから直接取得sし、その結果として使用することにより、20バイトを削ることができます。（インスタンスは、これらの変数をで宣言されていないため、とにかく取得します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フラグを介して入力を暗黙的に$ _に保存します。" # # "末尾の改行で可能な限り最も基本的なトップラインから始めます。これらの各文字を入力番号で複製します。次に、それを入力番号で複製してオクトソープの上部を形成し、そのすべてを$に保存します。次に、入力番号の '＃'倍にすべての文字を置き換えて行を追加します。次に、上部のセクションを追加します。最後の2つの文を合計2回実行します。$の出力は、-pフラグで暗黙的です。

05AB1E、25 22 21バイト

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

オンラインでお試しください！

-1エミグナは音訳を嫌い、ありがたいことに、私もそうすべきだと思い出させるからです：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>

オリジナルのチャコールの試みに使用したビットマップアプローチのポート。

パイソン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、338 332バイト

Rileyのおかげで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バイト

Felix Palmenのおかげで5バイト。

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の素晴らしい答えの移植版

オンラインでお試しください！（フッターはきれいに印刷するためのものであり、プログラム自体は文字の2Dリストを返します）

説明

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

オンラインでお試しください！

文字の2Dリストを返します。

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

ここで重要な観測は、の5×5グリッド上で、それであるNによって、 N行または列番号（0系）が奇数である限り、細胞、octothorpesが現れます。これは最も安価な一般的なアプローチであると確信していますが、さらにゴルフに適しているようです。

謝辞

• -1バイト、Kevin Cruijssenに感謝

Pyth、28 22バイト

@LeakyNunのおかげで-6バイト

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