#OctothorpeAsciiArt


35

Un Octothorpe, (chiamato anche segno numerico, hash o hashtag o cancelletto) è il seguente carattere ASCII:

#

Non è una forma divertente? Facciamo versioni più grandi di esso! Quindi ecco la tua sfida:

Dato un intero positivo N , uscita un hashtag ASCII di dimensioni N .

Ad esempio, un hashtag ASCII di dimensioni 1 è simile al seguente:

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

Gli spazi bianchi finali su ogni riga sono consentiti, ma non richiesti.

L'input sarà sempre un numero intero positivo valido, quindi non è necessario gestire numeri non negativi, negativi o 0. L'output può essere in qualsiasi formato ragionevole, quindi inoltrare a STDOUT, restituendo un elenco di stringhe o stringhe con newline, una matrice 2D di caratteri, scrivere su un file, ecc. vanno bene.

Casi test

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

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

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

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

Dato che si tratta di un codice-golf, prova a scrivere la soluzione più breve possibile e, soprattutto, divertiti!


Risposte:


21

MATL , 20 16 12 11 byte

3 byte grazie a DJMcMayhem.

1 byte grazie a Luis Mendo.

21BwY"&*~Zc

Provalo online!

Spiegazione

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

1
Puoi usare Zcinvece di 35*ce ~(NOT logico) invece di0=
DJMcMayhem

1
@DJMcMayhem @ _ @ why is that a built
Leaky Nun

1
In realtà, il motivo che è incorporato è davvero interessante. Potrei sbagliarmi, ma penso che Conor l'abbia suggerito, e Suever ha scritto uno script che esamina tutte le risposte MATL per vedere quali funzioni sono più comuni per i miglioramenti futuri. Zc è stato appena aggiunto
DJMcMayhem

Inoltre, poiché ogni cella deve essere diversa da zero, è possibile fare Qinvece di2<
DJMcMayhem

1
@LeakyNun Puoi cambiare !t*in &*. Quest'ultimo significa "moltiplicazione a un input", che moltiplica (in termini di elementi) l'input per la sua trasposizione
Luis Mendo,

14

Brain-Flak , 420 byte

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

Provalo online!

No, il punteggio di 420 non era intenzionale. Lo prometto. Versione leggibile:

# 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
    {}

>[()])}

13

6502 codice macchina (C64), 59 56 byte

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

Demo online

Utilizzo: SYS49152,Ndove N è un numero compreso tra 1 e 255.

(valori superiori a 4 saranno già troppo grandi per lo schermo C64, a partire da 8, l'output è persino troppo ampio)

Spiegazione :

         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)

Screenshot


5
+1 per la nostalgia (6502 assemblaggio su un c64 è stata la mia prima esperienza di programmazione ...)
Olivier Dulac,


8

Python 2 , 55 byte

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

Provalo online!

Ciò restituisce un elenco 2D di caratteri.

Python 2 , 65 byte

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

Provalo online!

Python 2 , 66 byte

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

Provalo online!


Wat witchkraft è il tuo footer
Leaky Nun,

@LeakyNun A for loop :)
Mr. Xcoder,

No, sto parlando della f(i);memorizzazione del risultato in una temperatura e printdell'accesso ad esso.
Leaky Nun,

1
@LeakyNun Ya frainteso: f(i)stampe e printin Python 2 aggiunge una nuova riga: P
Mr. Xcoder

Oh, che stupido da parte mia.
Leaky Nun,

6

Carbone , 21 byte

NθUOײθ#UOθ F²⟲OO²⁴⁶θ

Provalo online!Il collegamento è alla versione dettagliata del codice. Inizialmente avevo provato un simpatico approccio bitmap:

F⁵F⁵F&|ικ¹«J×ιIθ×κIθUOθ#

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione: Funziona considerando #un array di 5 × 5 quadrati. I quadrati che si trovano in righe o colonne dispari devono essere compilati.


il carbone non ha davvero una forma di hashtag integrata?
dzaima,

Ho legato il carbone O_O?
Magic Octopus Urn,

yay (hmm sembra che dovrei sistemarlo un po ')
ASCII il

@ Solo ASCII Cosa deve essere riparato?
Neil,

Oblungo non dovrebbe stampare i passaggi per il poligono che utilizza internamente lol
solo ASCII il

6

J, 22 byte

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

Provalo online!

Un sacco di somiglianza con l'altra risposta J, anche se non capisco bene i treni con molti nomi, quindi la mia risposta ha tre potenziali byte da tagliare (due parentesi e una riflessiva- ~).

Spiegazione

Generazione dell'ottotorpe

L'ottotorpe è composto da tutto in parentesi, riprodotto di seguito per comodità.

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

Molto del modo in cui realizzo l'ottotorpe è l'abuso del modo in cui J riempie le sue matrici quando non sono abbastanza lunghe.

21,0crea semplicemente l'array 21 0.

5$ridisegna tale matrice in una matrice 5-atomo: 21 0 21 0 21.

#:converte ciascun atomo in un numero binario. Poiché #:opera su ciascun atomo, l'output è una matrice. Ciascuno 21è sostituito da 1 0 1 0 1come previsto, ma ciascuno 0è sostituito da 0 0 0 0 0! Questo perché gli array di J pad non sono abbastanza lunghi da corrispondere alla forma dell'array 2D risultante che è costretto ad essere a 5 5causa delle 1 0 1 0 1righe. Fortunatamente, per i numeri che riempie 0, quindi otteniamo la matrice risultante

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

'# '{~converte ciascuno 1in uno spazio e 0in #. {significa "prendi" e ~significa "cambia gli argomenti diadici, quindi J guarda a ciascun elemento della matrice come indici per la stringa, il che '# 'significa che ognuno 0diventa l'elemento zeroth, #e ciascuno1 diventa il primo elemento, uno spazio. Ciò produce la dimensione di un ottotorpe.

Ridimensionamento dell'ottotorpe

Si tratta semplicemente di copiare i ntempi lungo ciascun asse, usando

il primo #(che fa parte di un gancio) e #~"1]. #copie lungo l'asse orizzontale e #"1copie lungo l'asse verticale.


1
##"1&('# '{~#:5$21,0)salva un byte.
Zgarb,

6

CJam, 27 26 25 byte

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

Provalo online!

Curiosità: inizialmente era iniziato a 29 byte e da allora i byte sono stati rimossi uno a uno, alternando la modalità blocco a programma completo.

Spiegazione:

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

Qualcuno era preparato per questa sfida: P
ETHproductions

@ETHproductions Era una CMC e si trasferì al principale ...
Esolanging Fruit

@ETHproductions Non posso davvero biasimarlo per quello ...
Leaky Nun,

6

Buccia , 12 10 byte

´Ṫ▲Ṙ" # # 

Provalo online! Nota lo spazio finale.

Spiegazione

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

6

J , 23 19 byte

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

Salvato 4 byte grazie a @LeakyNun.

Provalo online!

Spiegazione

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

Ratti! Stavo per pubblicare una mia soluzione (4 byte più lunga). Sono davvero impressionato da come riesci a comporre queste funzioni senza maiuscole e con poche congiunzioni.
Cole

@cole Grazie. A volte i cappellini possono essere evitati usando un sostantivo e una diade. Ad esempio, [:|:fpotrebbe essere0|:f
miglia il

' # '{~]#"1]#+./~@i:@2salva un byte
Conor O'Brien il

ripetere prima della moltiplicazione ti dà 19 byte:f=:' #'{~1=]+./~@#i:@2
Leaky Nun

1
@hoosierEE È una nuova funzionalità in arrivo in J 8.06. Puoi provare la beta jsoftware.com/download/j806/install
miglia il

5

Gelatina , 14 13 11 byte

Salvato 2 byte grazie a @JonathanAllen

5ẋ€Ẏ&þ`ị⁾ #

Un collegamento monadico che restituisce un elenco di righe. Nota lo spazio finale.

Provalo online!

Come funziona

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

Bella osservazione per quanto riguarda bit a bit o - salva due byte passando da o a e - rimuovendo la necessità di abbassare, consentendo un intervallo implicito e rimuovendo la necessità di µ(o invece avresti potuto avere lì) ...5ẋ€Ẏ&þ`ị⁾ #
Jonathan Allan

@JonathanAllan Interessante - perché 5Ḷẋ€richiede il µ, ma no 5ẋ€?
ETHproductions

Pensavo che la necessità fosse solo quella di smettere di agire ne poi ẋ€passarla a destra , poiché non è necessario che una catena guida nilad-diade venga chiamata monadicamente. Non sono del tutto sicuro, tuttavia, come `sembra posizionare 5 (o forse l'elenco di quella lunghezza) a destra della tabella &.
Jonathan Allan il

4

Lingua di Game Maker, 138 108 byte

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

Inteso come uno script (nome del Game Maker per le funzioni definite dall'utente), quindi il n=argument0e return s. 20 byte possono essere rasati prendendo ndirettamente dall'istanza corrente e usando scome risultato. (L'istanza ottiene comunque queste variabili perché non sono state dichiarate convar ).

Fai attenzione, ovviamente, che #viene utilizzato dagli elementi grafici di Game Maker come personaggio newline alternativo, quindi potresti voler aggiungere un prefisso \se vuoi eseguire l'output sullo schermo;)

Nota anche che sto usando la versione di GML di Game Maker 8.0 qui; le versioni GML moderne potrebbero avere funzionalità che potrebbero salvare byte aggiuntivi.

Alcune idee per gentile concessione degli amici wareya e chordbug.


I think this is the first GML answer i've ever seen
Timothy Groote

@TimothyGroote It's a shame it isn't used more, its optional brackets and semicolons are great for golfing :)
Andrea

4

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

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

Try it online!

How?

Implicitly store the input in $_ via the -p flag. Start with the most basic possible top line " # # " with its trailing newline. Replicate each of those characters by the input number. Then replicate that by the input number to form the top part of the octothorpe, storing all of that back in $. Then append the line with all characters replaced by '#' times the input number. Then append the top section. Do those last two sentences a total of two times. Output of the $ is implicit in the -p flag.


I like how your answer is just as readable as mine.
AdmBorkBork

They've always said that Perl is a write-only language.
Xcali

3

05AB1E, 25 22 21 bytes

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

Try it online!


-1 because Emigna hates transliterate and, thankfully, reminds me I should too :P.


Gotta be a better way than bitmapping it... Still working.


Reflection... is not the answer in 05AB1E, though it seems like it could be...
Magic Octopus Urn

5ôεS„# èJ¹F= saves a byte.
Emigna

@Emigna would canvas be good for this?
Magic Octopus Urn

Possibly. I haven't tried the canvas yet so I'm not really sure of its capabilities. Seems like something it's made for.
Emigna

3

JavaScript (ES6), 79 bytes

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 of the bitmap approach that I'd used for my original Charcoal attempt.


3

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

New (Credit: HyperNeutrino):

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

Old:

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

Try it online!

Obviously not the shortest solution, but I think it's decent. Any feedback would be appreciated!


1
a,b,c=input()," #" should save some bytes.
DJMcMayhem

@DJMcMayhem That gave me an error. Did you mean a,b,c=input(),"#"," "? Which isn't any shorter...I appreciate the help!
Braeden Smith

Oh, sorry. I assumed that worked because a,b="# " works.
DJMcMayhem

a=input();b,c="# " will work and save bytes
Wheat Wizard

You can also get get rid of the parens in (i==2) and add a space to the beginning.
Wheat Wizard

3

Brain-Flak, 338 332 bytes

6 bytes thanks to Riley.

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

Try it online!

More "readable" version

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

Try it online!


(({})<>)(())<>({}<>) at the beginning can be replaced with (({}<>)<(())>)
Riley

2

SOGL (SOGLOnline commit 2940dbe), 15 bytes

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

To run this, download this and run the code in the index.html file.

Uses that at that commit (and before it) * repeated each character, not the whole string.

Explanation:

ø─Ζ┘Χ⁴‘          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: add 2 inputs for separate X and Y length!


"commit 2940dbe" - I like that idea. Can you explain why ø─Ζ┘Χ⁴‘ pushes that though?
Magic Octopus Urn

1
@MagicOctopusUrn That's SOGLs compression, which here stores a dictionary of " " and # and the base-2 data required for that string.
dzaima

Neat, is it stable enough for me to start using :)?
Magic Octopus Urn

1
@MagicOctopusUrn Well it's pretty stable as there have been no answer-breaking changes since SOGLOnline, but whether you can use it (as in understand it) is another question. You can try though and ask question in TNB
dzaima

Haha... Ill wait for documentation then. I do need coddled a little.
Magic Octopus Urn

2

brainfuck, 224 bytes

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

Try it online!

Making-of

I tried to build this code by hand and spent quite a few hours, so I decided to make a transpiler in Python.

Here is the code I entered to make this 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)

Try it online!


2

C (gcc), 98 93 bytes

5 bytes thanks to 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);}

Try it online!


2

Gaia, 9 bytes

 # ”ṫ&:Ṁ‡

Pretty much a port of Zgarb's great answer

Try it online! (the footer is just to pretty print, the program itself returns a 2D list of characters)

Explanation

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


1

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

Try it online!

Returns 2D list of characters.


1

PowerShell, 72 68 63 60 bytes

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

Try it online!

Takes input $a. Then, we do a bunch of magic string and array manipulation.

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

You can peel off the parts of the explanation starting from the bottom to see how the output is constructed, so hopefully my explanation makes sense.


1

Haskell, 72 bytes

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

Returns a list of strings. Try it online!

How it works:

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

1

Mathematica, 63 bytes

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

Explanation

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)-## parses into Times[-1, ##]


ArrayFlatten is very nice.
Mark S.

1

Python 2, 113 bytes

As an array of strings:

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

As ASCII art:

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

As an array of booleans

Python 2, 75 bytes

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]


1
Long time, no see :-)
ETHproductions

Yes, it has! @ETHproductions
Zach Gates

1

Java 8, 103 bytes

Lambda accepts Integer and prints the octothorpe to standard out. Cast to 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"));}

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

The key observation here is that, on a 5 by 5 grid of n by n cells, octothorpes appear wherever the row or column number (0-based) is odd. I'm pretty sure this is the cheapest general approach, but it seems further golfable.

Acknowledgments

  • -1 byte thanks to Kevin Cruijssen

1
You can place the int s=5*n,x=0,y instead the for-loop to save a byte on the semicolon.
Kevin Cruijssen


1

R, 87 85 62 bytes

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

2 bytes saved by representing c(F,T) as !1:0, thanks to LeakyNun

23 bytes saved thanks to Giuseppe

Try it online!

Explanation (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             

It doesn't work on TIO because it scans the next line, which is a code.
Leaky Nun




Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.