Sfida

Data una dimensione s, stampa una rete cubica di quella dimensione fatta di simboli hash ( #) e spazi ( ).

Esempi:

1:
  #
# # #    
  #
  #

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

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

La rete può effettivamente essere qualsiasi rete di cubi valida che può essere piegata in un cubo, ad esempio questi:

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

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

Regole

• La rete risultante deve essere geometricamente valida (pieghevole in un cubo)
• Scappatoie standard vietate
• Leggi attentamente le regole
• Si tratta di code-golf , vince la risposta più breve, ma non verrà selezionata

Python 2, 47 byte

n=input()
for c in 1,4,1:exec"print'# '*c*n;"*n

Provalo online!

Stampa questa rete, scelta per essere giustificata a sinistra:

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

Le righe hanno no 4*ncopie di '# '. Per ognuno di 1,4,1noi, stampiamo ntempi che molte copie, ntempi fatti per nlinee. Avere un execloop all'interno di un forloop sembra uno spreco, ma non ho visto di meglio.

Alternative che ho testato:

lambda n:('# '*n*3+'\n')*n+('  '*n+'# '*n+'\n')*3*n

lambda n:('# '*n*3+'\n')*n+(' '*4*n+'# '*n*3+'\n')*n

def f(n):
 for c in[3]*n+[1]*3*n:print('# '*c*n).center(6*n)

def f(n):
 for c in[4]*n+[0]*n:print' '*c*n+'# '*n*3

def f(n):
 for c in[1]*n+[4]*n+[1]*n:print'# '*c*n

def f(n):
 c=1;exec("print'# '*c*n;"*n+"c^=5;"*n)*3

def f(n):
 for i in range(3*n):print'# '*[1,4,1][i/n]*n

def f(n):
 for c in 1,4,1:print('# '*c*n+'\n')*n,

def f(n):
 for c in 1,4,1:exec"print'# '*c*n;"*n

(Le deffunzioni possono essere tutte più brevi di un programma.)

Ottava, 58 44 42 32 byte

@(n)[z=repmat('# ',n);z,z,z,z;z]

parzialmente ispirato alla risposta di Python di @xnor.

z=repmat('# ',n);

crea un modello squre di '#' per i risultati dell'input 2 il modello seguente:

# #             
# # 

y=[z,z,z,z];

quattro zs sono concatenati orizzontalmente:

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

[z;y;z]

ze ye zsono concatenati verticalmente

Provalo online!

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

Risposta precedente:

@(n){h(1:n,1:2:n*6)=1;h(1:n*4,n*2+1:2:4*n)=1;' #'(h+1)}{3}

Provalo online!

Genera uno a forma di T.

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

Mathematica, 77 60 52 byte

Grazie a Martin Ender per il golf a 8 byte di distanza!

{±s_:=s~Table~#;b=±{a=±"# ","
"},±{a,a,a,a,"
"}}<>b&

Funzione senza nome che accetta un argomento intero positivo #e restituisce una stringa con newline (inclusa una newline finale); ogni riga ha anche uno spazio finale. Per prima cosa definiamo ±una funzione che ripete i suoi #tempi di input ; allora aè definito come ±"# "(questo #è un carattere, non l'input!), e da quello bè definito l'insieme delle #linee corte, mentre ±{a,a,a,a}<>nè l'insieme delle #linee lunghe. (In entrambi i casi, c'è un avanzamento di riga letterale tra virgolette corrispondenti.) Il finale <>bconcatena l'elenco risultante di stringhe con la seconda copia dell'insieme di righe brevi. Esempio di output quando #=2( la risposta di xnor mi ha insegnato che questo orientamento è più golfistico):

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

Versione precedente di questa implementazione:

""<>(±s_:=s&~Array~#;{b=±{a=±"# ",n="\n"},±{a,a,a,a}<>n,b})&

Presentazione originale:

""<>If[(m=n~Mod~t)==0,"\n",If[n<t#||#<m<=2#,"# ","  "]]~Table~{n,4(t=3#+1)#}&

Costruisce un fuori serie di 4*(3#+1)pezzi, ciascuno dei quali è o "# ", " "o "\n"; calcola semplicemente quali pezzi utilizzare in base all'indice n. Esempio di output quando #=2:

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

JavaScript (ES6), 59 byte

f=
n=>`141`.replace(/./g,m=>`${`# `.repeat(n*m)}\n`.repeat(n))

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

L'output include uno spazio finale alla fine di ogni riga e una nuova riga finale.

Rubino, 36 byte

f=->n{puts (t=[s="# "*n]*n)+[s*4]*n+t}

Uso:

f=->n{puts (t=[s="# "*n]*n)+[s*4]*n+t}
f[3]
# # #
# # #
# # #
# # # # # # # # # # # #
# # # # # # # # # # # #
# # # # # # # # # # # #
# # #
# # #
# # #

Rubino, 38 byte

Questa forma è più lunga in Ruby ma mi aspetto che ci siano alcune lingue in cui è più breve.

->n{puts [s="# "*n*3]*n+[" "*n*4+s]*n}

Uso:

g=->n{puts [s="# "*n*3]*n+[" "*n*4+s]*n}
g[3]
# # # # # # # # #
# # # # # # # # #
# # # # # # # # #
            # # # # # # # # #
            # # # # # # # # #
            # # # # # # # # #

Entrambe le risposte possono essere più brevi se è consentito restituire (preferibilmente) una matrice di stringhe o (meno preferibilmente) una singola stringa invece di stampare.

Scala, 56 byte

(n:Int)=>Seq(1,4,1)map("# "*_*n+"\n")map(_*n)mkString ""

JavaScript (ES6), 71

n=>((z='# '[R='repeat'](n))[R](3)+`
`)[R](n)+('  '[R](n)+z+`
`)[R](n*3)

Test

f=
n=>((z='# '[R='repeat'](n))[R](3)+`
`)[R](n)+('  '[R](n)+z+`
`)[R](n*3)

function update() {
  O.textContent=f(I.value)
}

update()

<input id=I type=number value=3 oninput='update()'><pre id=O></pre>

Java 8, 99 byte

l->{for(int i=-1,j;++i<3*l;)for(j=-1,k=(i/l==2)?4*l:l;++j<k;)System.out.print("# "+j>k-2?"\n":"");}

V , 24 23 20 18 20 byte

Ài# ddÀpLyGïp3PGïp

Con tutti i personaggi nascosti mostrati

Ài# ^[ddÀp^VLyGïp3PGoïp

^[è 0x1b(carattere di escape letterale) ed ^Vè 0x16( C-v)

Provalo online!

Ho dovuto aumentare il conteggio perché il Äcomando era stato corretto in questo nuovo pull V

Output in questo formato:

# 
# # # # 
# 

con una newline leader

hexdump:

00000000: c069 2320 1b64 64c0 7016 4c79 47ef 7033  .i# .dd.p.LyG.p3
00000010: 5047 ef70                                PG.p

Spiegazione

Ài# ^[              " Argument times insert "# "
ddÀp                " Argument times duplicate line

Ora che una faccia della rete è stata completata, dobbiamo creare la rete

^VLy                " Copy the face
Gïp                 " Paste it at the end of buffer
3P                  " Paste 3 times (these form the line)
Gïp                 " Paste at end of buffer again

Soluzione alternativa se non produciamo gli spazi:

21 20 18 16 18 byte

Àé#ddÀpLyGïp3pGïp

(per lo stesso motivo della soluzione principale, questo collegamento TIO viene modificato)

Provalo online!

V , 14 byte (non concorrenti)

Ài# 5Ù4JjòÀÄk

Provalo online!

00000000: c069 2320 1b35 d934 4a6a f2c0 c46b       .i# .5.4Jj...k

Per qualsiasi motivo, questa sfida ha scoperto numerosi bug. Ora che sono tutti corretti, questa versione è purtroppo non competitiva, ma è bello vedere come dovrebbe apparire una V risposta a questa sfida quando non è necessario aggiungere tonnellate di byte per tenere il passo con la mia programmazione sciatta.

Spiegazione:

À                   " Arg 1 times:
 i# <esc>           "   Insert the string "# "
         5Ù         " Make 5 copies of this line, and put the cursor on the second copy
           4J       " Join four of these lines together
             j      " Move down to the last line
              ò     " Recursively:
               ÀÄ   "   Make Arg 1 copies of this line
                 k  "   And move up a line

Gelatina , 20 19 byte

”#xẋ³Wẋ³K€Y
141DÇ€Y

Provalo online!

-1 grazie a 44874 (steenbergh).

^{NON POSSO GUADAGNARE AIUTO MUDDYFISH!}

Questo è golfabile ??? 20 19 byte sembra troppo , vedendo Link 1.

Spiegazione:

”#xẋ³Wẋ³K€Y Helper link. Arguments: z
”#          Character #.
            y (implicit)
  x         Repeat each element of y x times.
    ³       1st command-line argument.
   ẋ        Repeat x y times.
     W      Wrap z.
       ³    1st command-line argument.
      ẋ     Repeat x y times.
        K   Join z on spaces.
         €  Map this link on x.
          Y Join z on newlines.

141DÇ€Y Main link. Arguments: 0
141     Integer 141.
   D    Convert z to base 10.
    Ç   The above link as a monad.
     €  Map this link on x.
      Y Join z on newlines.

Carbone , 20 byte

ＮλＧ↑λ←×⁶λ↓λ# ＤＭ×⁴λ← 

Il codice termina con uno spazio. Provalo online!

Spiegazione

Il carbone è una lingua specializzata nell'arte ASCII. È anche incompleto, difettoso e sotto documentato. Basti dire che questo ha richiesto una buona dose di tentativi ed errori prima di fare quello che doveva.

• Ｎλinserisce un numero in λ.
• Ｇè il comando poligono, che useremo qui per disegnare un rettangolo. ↑λ←×⁶λ↓λspecifica il bordo del poligono: λpassi verso l'alto , passi verso sinistra 6 volte λe λpassi verso il basso . (Sono tre λper λblocco affiancati.) Il margine inferiore del rettangolo viene dedotto. Il poligono viene quindi riempito con la stringa # .
• Ｄ scarica la tela corrente su stdout, risultando in qualcosa del genere:

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

• Dopo il Ｇ comando, il cursore si trova nell'angolo in basso a sinistra dell'area di disegno. Ｍ×⁴λ←lo sposta a sinistra di 4 volte λ(equivalente a due λper λblocchi).
• genera uno spazio lì, estendendo la tela verso sinistra della quantità corretta.
• Alla fine del programma, il canvas viene (di nuovo) inviato a stdout:

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

Mettili insieme e hai una rete cubica.

Utilità Bash / Unix, 72 69 68 66 byte

b()(yes `dc<<<2o4d$n^$1^3/p`|tr 01 ' #'|head -$n);n=$1;b 1;b 4;b 1

Provalo online!

Questo funziona usando il fatto che [4 ^ k / 3], quando scritto nella base 2, è 10101010 ... 01, con k 1. (Le parentesi quadre qui indicano la funzione pavimento.)

Pyke, 16 byte

uAD,sXF**"# 

Provalo qui!

Equivalente a

1 4 1]3AD,sXF**"# 

A causa di non stampabili

Questo utilizza un paio di trucchi per ridurre il conteggio dei byte:

• Utilizza alcuni non stampabili per rappresentare l'elenco [1, 4, 1]
• XF scarica automaticamente l'output nello stack
• La stringa "#alla fine viene scambiata con l'ultima *, il che significa che la chiusura "non è richiesta. Ciò accade implicitamente quando l'ultimo token è una stringa.

u                -      [1, 4, 1]
     AD          -     apply(*, ^, input)
       ,         -    zip(^)
        s        -   sum(^)
          F**"#  -  for i in ^:
           *     -    ^ * input
            *    -   ^ * v
             "#  -    "# "
         X       - splat(^)

Python 2 , 68 71 65 byte

-6 grazie a @sagiksp

def f(i,c=1):
 print(' '*i*4,'')[c>i]+'# '*i*3
 if i*2>c:f(i,c+1)

Provalo online!

In assenza di un modo per battere @xnor, posterò la mia funzione ricorsiva semplicemente come approccio alternativo. Per stampe f (5)

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

Questo modello è stato scelto semplicemente perché può essere diviso in due parti a differenza di tutte le altre.

PHP, 64 62 byte

Salvato 2 byte grazie a Christoph .

while($a="282"[$i++/$s=$argv[1]]*$s)echo str_pad("
",$a,"# ");

Stampa una rete come questa:

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

(con una nuova linea principale)

Lotto, 111 byte

@set s=
@set i=@for /l %%i in (1,1,%1)do @
%i%call set s=%%s%% #
%i%echo%s%
%i%echo%s%%s%%s%%s%
%i%echo%s%

Pushy , 32 29 28 byte

Stampa la rete cubica giustificata a sinistra. È stato difficile giocare a golf ...

&V:`# `;{:";N^:4:";T'.;TD^:"

Provalo online!

Retina , 39 37 byte

Questa è la prima volta che utilizzo Retina, sto ancora cercando di capire come fare le cose.

.+
$*#
#
# 
\`# 
$_¶
G`.
)*%`^
$_$_$_

(con due spazi finali dopo la 4a e 5a riga)

Grazie a Martin Ender per aver giocato a golf 2 byte!

Provalo online!

QBIC , 52 67 40 byte

Riscrittura completa:

:[a*3|G=G+@#`][a*2|G=G+@ `][a|?G][a|?_fG

Questo ora utilizza questo modello:

###--
--###

Dove -sono pieni di spazi.

:        Read 'a' from the command line        > Assume 3
[a*3|    Create 3 segments times 'a' filling   > 3*3 = 9
G=G+@#`] Define A$ to be '#' and add this to G > G = "#########" 
[a*2|    Create 2 segments times 'a' spacer
G=G+@ `] Define B$ to be ' ' and add this to G > G = "#########       " 
[a|      FOR d == 1; d <= a; d++
?G]      Display G$:
            "#########       " 
            "#########       " 
            "#########       " 
[a|      FOR e == 1; e <= a; e++
?_fG     Display G$ in reverse (_f...|):
            "      #########" 
            "      #########" 
            "      #########" 
         (For loop and function call to Flip impicitly closed by QBIC)

Pip , 28 17 16 byte

15 byte di codice, +1 per la -nbandiera.

"# "Xa*_RLaM141

Accetta le dimensioni come argomento della riga di comando. Provalo online!

Spiegazione

                 a is 1st cmdline arg
       _         Build a lambda function
     a*          (a) times argument
"# "X            Repeat string "# " that many times
        RLa      Wrap in a list and repeat list (a) times
           M141  Map that function to the characters of 141
                 Autoprint (-n flag separating list items with newlines)

Quanto segue non è esattamente come vengono modificati i dati, ma dà l'idea di base (per a=2):

141

[1;4;1]

[2;8;2]

["# # ";"# # # # # # # # ";"# # "]

[["# # ";"# # "];["# # # # # # # # ";"# # # # # # # # "];["# # ";"# # "]]

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

05AB1E , 13 byte

D141S×S*„# ×»

Provalo online!

Spiegazione

Esempio di input n=2

D              # duplicate input
               # STACK: 2, 2
 141S          # push the list [1,4,1]
               # STACK: 2, 2, [1,4,1]
     ×         # repeat each item in the list input_no times
               # STACK: 2, [11, 44, 11]
      S        # split into list of digits
               # STACK: 2, [1, 1, 4, 4, 1, 1]
       *       # multiply each digit with input
               # STACK: [2, 2, 8, 8, 2, 2]
        „# ×   # repeat the string "# " for each item in the list
               # STACK: ['# # ','# # ','# # # # # # # # ','# # # # # # # # ','# # ','# # ']
            »  # join by newlines
               # OUTPUT: # # 
                         # # 
                         # # # # # # # # 
                         # # # # # # # # 
                         # # 
                         # # 

C #, 152 byte

n=>{var m="";foreach(int c in new[]{1,4,1})for(int i=0,j;i++<n;){for(j=0;j++<c;)m+=new System.Text.StringBuilder().Insert(0,"# ",n);m+="\n";}return m;};

SmileBASIC, 57 50 byte

INPUT S
E$=("#"*S*3+CHR$(10))*S?E$SCROLL-S*2,-1?E$

Ha spiegato:

INPUT SIZE
PART$=("#"*SIZE*3+CHR$(10))*S 'generate half of the pattern
PRINT PART$ 'print half the pattern
SCROLL SIZE*-2,-1 'scroll the text 2 squares right (and 1 character down)
PRINT PART$ 'print half the pattern again

Dopo la prima STAMPA (dimensione = 2, @ è la posizione del cursore):

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

@ 

Dopo lo SCROLL:

    ######
    ######
@

Dopo la seconda STAMPA:

    ######
    ######
######
######
@

Lisp comune, 83 81 79 byte

(lambda(x)(format t"~v@{~v@{# ~}~:*~%~}~v@{~vt~0@*~v{# ~}~%~}"x(* x 3)(* x 2)))

Uso:

(funcall #'(lambda(x)(format t"~v@{~v@{# ~}~:*~%~}~v@{~vt~0@*~v{# ~}~%~}"x(* x 3)(* x 2)))2)

Produzione:

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

Come funziona?

in format there is control string (inside "") and arguments after it
certain commands in string can use arguments (for example ~a displays argument)
~v{~} - takes argument and does commends inside {~} number of times 
                                      (number is given by argument)
       we can write text in loop body - it'll get displayed. Even if
       in loop body there are none commends to use arguments loop itself                 
       will consume one argument (it doesn't matter what it'll be -
       it doesn't seem to affect output)
~% - newline
~n* - jump n arguments forward (relative)
~n:* - jump n arguments backwards (relative)
~n@* - jump to argument n (global, counting from 0)

~v@{~v{# ~}~%~1@*~} <--- we make x rowns, 3x columns of string "# ". 
                         ~1@* is used during looping, it also means we end on argument 1. 
                         (second argument: (* x 3))
~v@{~vt~0@*~v{# ~}~%~} <--- we now make 3x rows, x columns of "(spaces)# "
                         ~vt - is used to move to accurate column. 
                         Here it takes argument (* x 2) - this is 
                         minimal number of columns to display. It uses
                         space as default character for missing characters
                         (when string inside <~> is shorter than min 
                         number of columns). I use it to make (* x 2) spaces, 
                         by giving it no text.
      ~0@* <--- after making spaces we have no new arguments, we go back to
                argument number zero - it is used to determine number of columns in our block

Le idee per il miglioramento sono le benvenute.