Ein Octothorpe (auch Nummernzeichen, Hash oder Hashtag oder Pfundzeichen genannt) ist das folgende ASCII-Zeichen:

#

Ist das nicht eine lustige Form? Machen wir größere Versionen davon! Also hier ist deine Herausforderung:

Bei einer positiven Ganzzahl N wird ein ASCII-Hashtag der Größe N ausgegeben .

Ein ASCII-Hashtag der Größe 1 sieht beispielsweise folgendermaßen aus:

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

Das nachgestellte Leerzeichen in jeder Zeile ist zulässig, aber nicht erforderlich.

Die Eingabe ist immer eine gültige positive Ganzzahl, sodass Sie keine Nicht-Zahlen, negativen oder 0-Werte verarbeiten müssen. Ihre Ausgabe kann in einem beliebigen vernünftigen Format erfolgen, dh sie wird an STDOUT ausgegeben und gibt eine Liste von Zeichenfolgen oder Zeichenfolgen mit zurück Zeilenumbrüche, eine 2D-Zeichenmatrix, das Schreiben in eine Datei usw. sind in Ordnung.

Testfälle

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

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

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

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

Da dies ein Code-Golf ist, versuchen Sie, die kürzestmögliche Lösung zu schreiben und vor allem Spaß zu haben!

MATL , 20 16 12 11 Bytes

3 Bytes dank DJMcMayhem.

1 Byte dank Luis Mendo.

21BwY"&*~Zc

Probieren Sie es online!

Erläuterung

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

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

Probieren Sie es online!

Nein, die Punktzahl von 420 war nicht beabsichtigt. Das verspreche ich. Lesbare Version:

# 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 Maschinencode (C64), 59 56 Bytes

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

Online-Demo

Verwendung: SYS49152,Nwobei N eine Zahl zwischen 1 und 255 ist.

_{(Werte größer als 4 sind für den C64-Bildschirm bereits zu groß, ab 8 ist die Ausgabe sogar zu breit)}

Erklärung :

         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 Bytes

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

Probieren Sie es online!

Gibt eine Liste von Zeichenfolgen aus.

Python 2 , 55 Bytes

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

Probieren Sie es online!

Dies gibt eine 2D-Liste von Zeichen zurück.

Python 2 , 65 Bytes

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

Probieren Sie es online!

Python 2 , 66 Bytes

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

Probieren Sie es online!

Holzkohle , 21 Bytes

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Ich hatte ursprünglich einen niedlichen Bitmap-Ansatz versucht:

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Erläuterung: Funktioniert unter Berücksichtigung der #als Array von 5 × 5 Quadraten. Die Quadrate in ungeraden Zeilen oder Spalten müssen ausgefüllt werden.

J, 22 Bytes

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

Probieren Sie es online!

Sehr ähnlich zu der anderen J-Antwort, obwohl ich Züge mit vielen Substantiven nicht gut verstehe, hat meine Antwort drei mögliche Bytes zum Abschneiden (zwei Parens und ein Reflexiv- ~).

Erläuterung

Octothorpe generieren

Die Oktothorpe wird von allem in der Klammer hergestellt, die der Einfachheit halber unten wiedergegeben wird.

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

Ein Großteil der Art und Weise, wie ich die Oktothorpe herstelle, ist ein Missbrauch der Art und Weise, wie J ihre Arrays auffüllt, wenn sie nicht lang genug sind.

21,0Erstellt einfach das Array 21 0.

5$umformt , dass die Anordnung in einen 5-Atom - Array: 21 0 21 0 21.

#:wandelt jedes Atom in eine Binärzahl um. Da #:an jedem Atom gearbeitet wird, ist die Ausgabe eine Matrix. Jeder 21wird 1 0 1 0 1wie erwartet durch ersetzt, aber jeder 0wird durch ersetzt 0 0 0 0 0! Dies liegt daran, dass J-Pads-Arrays nicht lang genug sind, um mit der Form des resultierenden 2D-Arrays übereinzustimmen, was 5 5aufgrund der 1 0 1 0 1Zeilen erzwungen wird . Glücklicherweise wird für Zahlen, mit denen es aufgefüllt wird 0, die resultierende Matrix erhalten

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

'# '{~konvertiert jeweils 1zu einem Leerzeichen und 0zu #. {bedeutet "take" und ~bedeutet "switch the dyadic arguments", also betrachtet J jedes Element in der Matrix als Index für die Zeichenfolge, '# 'was bedeutet, dass jedes 0Element zum nullten #und jedes 1zum ersten Element, einem Leerzeichen, wird. Dies ergibt die Größe einer Oktothorpe.

Größe der Oktothorpe ändern

Dies ist einfach eine Frage der Kopierzeiten nentlang jeder Achse, die mit ausgeführt werden

der erste #(der Teil eines Hakens ist) und #~"1]. #Kopien entlang der horizontalen Achse und #"1Kopien entlang der vertikalen Achse.

CJam, 27 26 25 Bytes

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

Probieren Sie es online!

Unterhaltsame Tatsache: Dies begann ursprünglich mit 29 Bytes, und Bytes wurden seitdem nacheinander entfernt, wobei zwischen Block- und Vollprogramm-Modus gewechselt wurde.

Erläuterung:

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

Schale , 12 10 Bytes

´Ṫ▲Ṙ" # # 

Probieren Sie es online! Beachten Sie das nachfolgende Leerzeichen.

Erläuterung

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

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

4 Bytes dank @LeakyNun gespart.

Probieren Sie es online!

Erläuterung

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

2 Bytes dank @JonathanAllen gespart

5ẋ€Ẏ&þ`ị⁾ #

Ein monadischer Link, der eine Liste von Zeilen zurückgibt. Beachten Sie das nachfolgende Leerzeichen.

Probieren Sie es online!

Wie es funktioniert

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

Game Maker Language, 138 108 Bytes

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

Bestimmt als Skript (Game Maker Name für benutzerdefinierte Funktionen), also das n=argument0und return s. 20 Bytes könnten rasiert werden, indem ndirekt von der aktuellen Instanz genommen und sals Ergebnis verwendet wird. (Die Instanz bekommt diese Variablen trotzdem, weil sie nicht mit deklariert wurden var).

Achtung, #das wird von Game Makers Grafik als alternatives Newline-Zeichen verwendet. Du solltest es also mit einem Präfix versehen, \wenn du es auf dem Bildschirm ausgeben möchtest.

Beachten Sie auch, dass ich hier die GML-Version von Game Maker 8.0 verwende. Moderne GML-Versionen verfügen möglicherweise über Funktionen, mit denen zusätzliche Bytes eingespart werden können.

Einige Ideen mit freundlicher Genehmigung von Freunden wareya und Chordbug.

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

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

Probieren Sie es online!

Wie?

Speichern Sie die Eingabe implizit in $ _ über das -pFlag. Beginnen Sie mit der grundlegendsten Top-Line " # # "mit der folgenden Newline. Replizieren Sie jedes dieser Zeichen mit der eingegebenen Nummer. Dann repliziere das mit der eingegebenen Zahl, um den oberen Teil des Oktothors zu bilden, und speichere alles zurück in $ . Fügen Sie dann die Zeile mit allen Zeichen hinzu, die durch '#' und die eingegebene Nummer ersetzt wurden. Dann hängen Sie den oberen Abschnitt an. Machen Sie die letzten beiden Sätze insgesamt zweimal. Die Ausgabe des $ ist im -pFlag enthalten.

05AB1E , 25 22 21 Bytes

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

Probieren Sie es online!

-1 weil Emigna transliterieren hasst und mich zum Glück daran erinnert, dass ich es auch tun sollte: P.

Muss ein besserer Weg sein, als es zu mappen ... Ich arbeite immer noch.

JavaScript (ES6), 79 Byte

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 des Bitmap-Ansatzes, den ich für meinen ursprünglichen Charcoal-Versuch verwendet hatte.

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

Neu (Bildnachweis: HyperNeutrino):

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

Alt:

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

Probieren Sie es online!

Natürlich nicht die kürzeste Lösung, aber ich finde es anständig. Über Feedback würde ich mich freuen!

Brain-Flak , 338 332 Bytes

6 Bytes danke an Riley.

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

Probieren Sie es online!

Mehr "lesbare" Version

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

Probieren Sie es online!

SOGL (SOGLOnline Commit 2940dbe) , 15 Bytes

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

Laden Sie dies herunter und führen Sie den Code in der index.htmlDatei aus , um dies auszuführen .

Verwendet das bei diesem Commit (und davor) * jedes Zeichen und nicht die gesamte Zeichenfolge wiederholt wird.

Erläuterung:

ø─Ζ┘Χ⁴‘          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: 2 Eingänge für separate X- und Y-Länge hinzufügen!

Brainfuck , 224 Bytes

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

Probieren Sie es online!

Making-of

Ich habe versucht, diesen Code von Hand zu erstellen, und einige Stunden damit verbracht, einen Transpiler in Python zu erstellen.

Hier ist der Code, den ich eingegeben habe, um diesen Code zu machen:

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)

Probieren Sie es online!

C (GCC) , 98 93 Bytes

5 Bytes dank 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);}

Probieren Sie es online!

Gaia , 9 Bytes

 # ”ṫ&:Ṁ‡

Ziemlich genau die richtige Antwort von Zgarb

Probieren Sie es online! (Die Fußzeile ist nur zu schön gedruckt, das Programm selbst gibt eine 2D-Liste von Zeichen zurück.)

Erläuterung

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

Befunge , 105 103 Bytes

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

Probieren Sie es online!

Python, 88 84 77 Bytes

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

Probieren Sie es online!

Gibt eine 2D-Liste von Zeichen zurück.

PowerShell , 72 68 63 60 Byte

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

Probieren Sie es online!

Übernimmt die Eingabe $a. Dann führen wir eine Reihe magischer Manipulationen an Strings und Arrays durch.

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

Sie können die Teile der Erklärung von unten abschälen, um zu sehen, wie die Ausgabe aufgebaut ist. Hoffentlich macht meine Erklärung also Sinn.

Haskell, 72 Bytes

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

Gibt eine Liste von Zeichenfolgen zurück. Probieren Sie es online!

Wie es funktioniert:

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 Bytes

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

Erläuterung

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) -##analysiert inTimes[-1, ##]}

Python 2, 113 Bytes

Als eine Reihe von Zeichenfolgen:

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

Als ASCII-Kunst:

Python 3, 115 Bytes

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 Bytes

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

Als Array von Booleschen Werten

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 Bytes

Lambda akzeptiert Integerund druckt die Oktothorpe gemäß Standard aus. Besetzung für 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"));}

Probieren Sie es online

Ungolfed Lambda

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

Die Schlüsselbeobachtung ist hier, dass, auf einem 5 x 5 Raster von n von n - Zellen, octothorpes erscheinen , wo die Zeilen- oder Spaltennummer (0-basierte) ungerade ist . Ich bin mir ziemlich sicher, dass dies der billigste allgemeine Ansatz ist, aber er scheint weiterhin Golf zu spielen.

Danksagung

• -1 Byte dank Kevin Cruijssen

Pyth , 28 22 Bytes

-6 Bytes dank @LeakyNun

JsC*]S5Qjmsm@"# "*kdJJ

Test Suite.

R , 87 85 62 Bytes

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

2 Bytes gespart, indem c (F, T) dank LeakyNun als! 1: 0 dargestellt wird

23 Bytes gespart dank Giuseppe

Probieren Sie es online!

Erklärung (ungolfed):

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