Un octothorpe (également appelé signe numérique, dièse ou hashtag, ou dièse) est le caractère ASCII suivant:

#

N'est-ce pas une forme amusante? Permet de faire de plus grandes versions de celui-ci! Alors, voici votre défi:

Etant donné un entier positif N , la sortie d' un hashtag ASCII de taille N .

Par exemple, un hashtag ASCII de taille 1 ressemble à ceci:

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

Les espaces de fin sur chaque ligne sont autorisés, mais pas obligatoires.

L’entrée sera toujours un entier positif valide, vous n’aurez donc pas à traiter des nombres non négatifs, négatifs ou 0. Votre sortie peut être dans n’importe quel format raisonnable. les nouvelles lignes, une matrice de caractères 2D, l'écriture dans un fichier, etc.

Cas de test

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

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

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

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

Puisqu'il s'agit d'un code-golf, essayez d'écrire la solution la plus courte possible, et surtout amusez-vous!

MATL , 20 16 12 11 octets

3 octets grâce à DJMcMayhem.

1 octet grâce à Luis Mendo.

21BwY"&*~Zc

Essayez-le en ligne!

Explication

    % 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 octets

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

Essayez-le en ligne!

Non, le score de 420 n'était pas intentionnel. Je promets. Version lisible:

# 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 code machine (C64), 59 56 octets

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

Démo en ligne

Utilisation: SYS49152,Noù N est un nombre compris entre 1 et 255.

_{(les valeurs supérieures à 4 seront déjà trop grandes pour l'écran C64, à partir de 8, la sortie est même trop large)}

Explication :

         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 octets

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

Essayez-le en ligne!

Affiche une liste de chaînes.

Python 2 , 55 octets

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

Essayez-le en ligne!

Ceci retourne une liste 2D de caractères.

Python 2 , 65 octets

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

Essayez-le en ligne!

Python 2 , 66 octets

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

Essayez-le en ligne!

Charbon de bois , 21 octets

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

Essayez-le en ligne! Le lien est vers la version verbeuse du code. J'avais initialement essayé une approche bitmap mignonne:

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

Essayez-le en ligne! Le lien est vers la version verbeuse du code. Explication: Fonctionne en considérant le #comme un tableau de 5 × 5 carrés. Les carrés qui se trouvent dans des lignes ou des colonnes impaires doivent être remplis.

J, 22 octets

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

Essayez-le en ligne!

Beaucoup de similitudes avec l'autre réponse de J, bien que je ne comprenne pas bien les trains avec beaucoup de noms, ma réponse a donc trois octets potentiels à couper (deux parens et un réflexif ~).

Explication

Générer l'octothorpe

L'octothorpe est composé de tout ce qui est entre parenthèses, reproduit ci-dessous pour plus de commodité.

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

Une bonne partie de ma fabrication de l'octothorpe est un abus de la façon dont J remplit ses tableaux quand ils ne sont pas assez longs.

21,0crée simplement le tableau 21 0.

5$remodèle ce tableau dans un tableau 5-atome: 21 0 21 0 21.

#:convertit chaque atome en un nombre binaire. Puisqu'il #:fonctionne sur chaque atome, la sortie est une matrice. Chacun 21est remplacé par 1 0 1 0 1comme prévu, mais chacun 0est remplacé par 0 0 0 0 0! Cela est dû au fait que les tableaux de J Pads ne sont pas assez longs pour correspondre à la forme du tableau 2D résultant, ce qui est forcé à 5 5cause des 1 0 1 0 1lignes. Heureusement, pour les nombres avec lesquels nous plaçons 0, nous obtenons la matrice résultante

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

'# '{~convertit chacun 1en espace et 0en #. {signifie "prendre" et " ~signifie" permuter les arguments dyadiques, donc J regarde chaque élément de la matrice comme des indices pour la chaîne, '# 'ce qui signifie que chacun 0devient l'élément zéro, #et que chacun 1devient le premier élément, un espace. Cela donne la taille un octothorpe.

Redimensionner l'octothorpe

Il s’agit simplement de copier les ntemps le long de chaque axe, en utilisant

le premier #(qui fait partie d'un crochet) et #~"1]. #copies le long de l'axe horizontal et #"1copies le long de l'axe vertical.

CJam, 27 26 25 octets

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

Essayez-le en ligne!

Fait amusant: cela a commencé à l'origine avec 29 octets, et les octets ont été supprimés un par un depuis, alternant entre le mode bloc et le mode programme complet.

Explication:

{                          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#  "  ##  ##  "]

Husk , 12 à 10 octets

´Ṫ▲Ṙ" # # 

Essayez-le en ligne! Notez l'espace de fuite.

Explication

´Ṫ▲Ṙ" # #   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 octets

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

Sauvegardé 4 octets grâce à @LeakyNun.

Essayez-le en ligne!

Explication

' #'{~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

Jelly , 14 13 11 octets

2 octets sauvés grâce à @JonathanAllen

5ẋ€Ẏ&þ`ị⁾ #

Un lien monadique renvoyant une liste de lignes. Notez l'espace de fuite.

Essayez-le en ligne!

Comment ça marche

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.             "#####",
                                                              " # # ",
                                                              "#####",
                                                              " # # "]

Jeu Game Maker Language, 138 108 octets

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

Destiné à un script (nom du fabricant pour des fonctions définies par l'utilisateur), ainsi le n=argument0et return s. 20 octets pourraient être rasés en prenant ndirectement à partir de l'instance actuelle et en utilisant scomme résultat. (L’instance obtient ces variables de toute façon car elles n’ont pas été déclarées avecvar ).

Méfiez-vous bien sûr #des éléments graphiques de Game Maker utilisés comme caractères de substitution à la nouvelle ligne. Vous voudrez peut-être les préfixer par\ si vous souhaitez afficher à l'écran;)

Notez également que j'utilise la version de GML de Game Maker 8.0; les versions GML modernes pourraient avoir des fonctionnalités qui pourraient économiser des octets supplémentaires.

Quelques idées fournies par des amis wareya et chordbug.

Perl 5 , 49 + 1 (-p) = 50 octets

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

Essayez-le en ligne!

Comment?

Stocke implicitement l'entrée dans $ _ via l' -pindicateur. Commencez par la ligne de base la plus élémentaire possible " # # "avec sa nouvelle ligne. Répliquez chacun de ces caractères par le numéro saisi. Puis répliquez cela par le numéro d'entrée pour former la partie supérieure de l'octothorpe, en stockant tout cela dans $ . Puis ajoutez la ligne avec tous les caractères remplacés par «#» fois le nombre saisi. Puis ajoutez la section supérieure. Ne ces deux dernières phrases un total de deux fois. La sortie du $ est implicite dans le -pdrapeau.

05AB1E , 25 22 21 octets

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

Essayez-le en ligne!

-1 parce qu'Emigna déteste translittérer et, heureusement, me rappelle que je devrais aussi: P.

Je dois être un meilleur moyen que de le bitmoder ... Encore en train de travailler.

JavaScript (ES6), 79 octets

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>

Port de l'approche bitmap que j'avais utilisé pour ma tentative originale de charbon de bois.

Python 2 , 124 , 116 , 113 , 112 , 98 , 96 66 octets

Nouveau (Crédit: HyperNeutrino):

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

Vieux:

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

Essayez-le en ligne!

De toute évidence pas la solution la plus courte, mais je pense que c'est décent. Tout commentaire serait apprécié!

Brain-Flak , 338 332 octets

6 octets grâce à Riley.

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

Essayez-le en ligne!

Version plus "lisible"

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

Essayez-le en ligne!

SOGL (SOGLOnline commit 2940dbe) , 15 octets

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

Pour l'exécuter, téléchargez -le et exécutez le code dans le dossierindex.html fichier.

Utilise ça à ce commit (et avant) * répète chaque caractère, pas la chaîne entière.

Explication:

ø─Ζ┘Χ⁴‘          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

Bonus: ajoutez 2 entrées pour des longueurs X et Y séparées!

brainfuck , 224 octets

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

Essayez-le en ligne!

Making-of

J'ai essayé de construire ce code à la main et j'ai passé pas mal de temps. J'ai donc décidé de faire un transpiler en Python.

Voici le code que j'ai entré pour faire ce code:

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)

Essayez-le en ligne!

C (gcc) , 98 93 octets

5 octets grâce à 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);}

Essayez-le en ligne!

Gaia , 9 octets

 # ”ṫ&:Ṁ‡

A peu près un port de Zgarb est excellente réponse

Essayez-le en ligne!(le pied de page est juste assez imprimé, le programme lui-même renvoie une liste 2D de caractères)

Explication

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

Befunge , 105 à 103 octets

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

Essayez-le en ligne!

Python, 88 84 77 octets

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

Essayez-le en ligne!

Retourne la liste 2D des caractères.

PowerShell , 72 68 63 60 octets

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

Essayez-le en ligne!

Prend les entrées $a. Ensuite, nous faisons un tas de manipulations magiques de chaînes et de tableaux.

(,($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

Vous pouvez détacher les parties de l'explication en commençant par le bas pour voir comment la sortie est construite. J'espère donc que mon explication a un sens.

Haskell, 72 octets

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

Retourne une liste de chaînes. Essayez-le en ligne!

Comment ça marche:

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 octets

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

Explication

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) -##analyse dansTimes[-1, ##]}

Python 2, 113 octets

Comme un tableau de chaînes:

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

Comme art ASCII:

Python 3, 115 octets

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 octets

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='')

Comme un tableau de booléens

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 octets

Lambda accepte Integeret imprime l'octothorpe au format standard. Cast à 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"));}

Essayez-le en ligne

Lambda Ungolfed

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

L’observation clé ici est que, sur une grille de 5 sur 5 de n sur n cellules, octothorpes apparaissent chaque fois que le numéro de ligne ou de colonne (sur la base 0-) est impair. Je suis à peu près sûr que c’est l’approche générale la moins chère, mais elle semble plus facile à jouer.

Remerciements

• -1 octet grâce à Kevin Cruijssen

Pyth , 28 22 octets

-6 octets grâce à @LeakyNun

JsC*]S5Qjmsm@"# "*kdJJ

Suite de tests.

R , 87 85 62 octets

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

2 octets enregistrés en représentant c (F, T) comme! 1: 0, grâce à LeakyNun

23 octets sauvés grâce à Giuseppe

Essayez-le en ligne!

Explication (non golfée):

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