Reto

Dado un tamaño s, imprima una red de cubos de ese tamaño hecha de símbolos hash ( #) y espacios ( ).

Ejemplos:

1:
  #
# # #    
  #
  #

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

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

La red en realidad puede ser cualquier red de cubos válida que se pueda plegar en un cubo, por ejemplo, estas:

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

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

Reglas

• La red resultante debe ser geométricamente válida (plegable en un cubo)
• Lagunas estándar prohibidas
• Lee las reglas cuidadosamente
• Este es el código de golf , la respuesta más corta gana, pero no se seleccionará

Python 2, 47 bytes

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

Pruébalo en línea!

Imprime esta red, elegida por ser justificada a la izquierda:

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

Las líneas tienen no 4*ncopias de '# '. Para cada una de ellas 1,4,1, imprimimos nveces esa cantidad de copias, nveces de nlíneas. Tener un execbucle dentro de un forbucle parece un desperdicio, pero no vi mejor.

Alternativas que probé:

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

( defTodas las funciones pueden ser una más corta como programa).

Octava, 58 44 42 32 bytes

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

en parte inspirado por la respuesta python de @xnor.

z=repmat('# ',n);

crea un patrón de escuadra de '#' para los resultados de la entrada 2;

# #             
# # 

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

cuatro zs se concatenan horizontalmente:

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

[z;y;z]

zy yy zse concatenan verticalmente

¡Pruébelo en línea!

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

Respuesta anterior:

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

¡Pruébelo en línea!

Genera una en forma de T

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

Mathematica, 77 60 52 bytes

¡Gracias a Martin Ender por jugar al golf a 8 bytes de distancia!

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

Función sin nombre que toma un argumento entero positivo #y devuelve una cadena con nuevas líneas (incluida una nueva línea final); cada línea tiene un espacio final también. Primero definimos ±como una función que repite sus #tiempos de entrada ; luego ase define como ±"# "(¡este #es un carácter, no la entrada!), y a partir de eso bse define como el conjunto de #líneas cortas, mientras que ±{a,a,a,a}<>nes el conjunto de #líneas largas. (En ambos casos, hay un salto de línea literal entre comillas coincidentes). El final <>bconcatena la lista resultante de cadenas con una segunda copia del conjunto de líneas cortas. Ejemplo de salida cuando #=2( la respuesta de xnor me enseñó que esta orientación es más golfista):

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

Versión anterior de esta implementación:

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

Presentación original:

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

Construye un cabo serie de 4*(3#+1)piezas, cada una de las cuales es ya sea "# ", " "o "\n"; simplemente calcula qué piezas usar según el índice n. Ejemplo de salida cuando #=2:

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

JavaScript (ES6), 59 bytes

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

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

La salida incluye un espacio final al final de cada línea y una nueva línea final.

Ruby, 36 bytes

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

Rubí, 38 bytes.

Esta forma es más larga en Ruby, pero espero que haya algunos idiomas donde sea más corta.

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

Uso:

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

Ambas respuestas pueden ser más cortas si se permite devolver (preferiblemente) una serie de cadenas o (menos preferiblemente) una sola cadena en lugar de imprimir.

Scala, 56 bytes

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

Prueba

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 bytes

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 bytes

Ài# ddÀpLyGïp3PGïp

Con todos los personajes ocultos mostrados

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

^[es 0x1b(carácter de escape literal) y^V es 0x16( C-v)

Pruébalo en línea!

Tuve que aumentar bytecount porque el Ä comando tenía errores en este nuevo V pull

Salidas en este formato:

# 
# # # # 
# 

con una nueva línea líder

Hexdump:

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

Explicación

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

Ahora que se ha completado una cara de la red, tenemos que crear la red

^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

Solución alternativa si no sacamos los espacios:

21 20 18 16 18 bytes

Àé#ddÀpLyGïp3pGïp

(por la misma razón que la solución principal, este enlace TIO se modifica)

Pruébalo en línea!

V , 14 bytes (no competitivos)

Ài# 5Ù4JjòÀÄk

Pruébalo en línea!

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

Por alguna razón, este desafío descubrió numerosos errores. Ahora que todos están arreglados, esta versión desafortunadamente no es competitiva, pero es bueno ver cómo debería ser una respuesta V a este desafío cuando no tiene que agregar toneladas de bytes para mantenerse al día con mi codificación descuidada.

Explicación:

À                   " 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

Jalea , 20 19 bytes

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

Pruébalo en línea!

-1 gracias a 44874 (steenbergh).

^{¡NO PUEDO SUPERAR LA AYUDA DE MUDDYFISH!}

¿Es esto golfable? 20 19 bytes simplemente parece demasiado , al ver el enlace 1.

Explicación:

”#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.

Carbón de leña , 20 bytes

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

El código termina con un espacio. Pruébalo en línea!

Explicación

El carbón es un lenguaje especializado en arte ASCII. También está incompleto, tiene errores y está poco documentado. Baste decir que esto llevó una buena cantidad de prueba y error antes de hacer lo que se suponía que debía hacer.

• Ｎλingresa un número en λ.
• Ｇes el comando polígono, que usaremos aquí para dibujar un rectángulo. ↑λ←×⁶λ↓λespecifica el borde del polígono: λpasos hacia arriba , hacia la izquierda 6 veces λy hacia abajo λ. (Eso es tres λpor λbloques uno al lado del otro). Se infiere el borde inferior del rectángulo. El polígono se llena con la cadena # .
• Ｄ vuelca el lienzo actual en stdout, lo que resulta en algo como esto:

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

• Después de la Ｇ comando, el cursor está en la esquina inferior izquierda del lienzo. Ｍ×⁴λ←lo mueve hacia la izquierda 4 λpasos (equivalente a dos λpor λbloques).
• genera un espacio allí, extendiendo el lienzo hacia la izquierda en la cantidad correcta.
• Al final del programa, el lienzo se envía (nuevamente) a stdout:

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

Póngalos juntos y tendrá una red de cubos.

Utilidades Bash / Unix, 72 69 68 66 bytes

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

Pruébalo en línea!

Esto funciona utilizando el hecho de que [4 ^ k / 3], cuando se escribe en la base 2, es 10101010 ... 01, con k 1's. (Los corchetes aquí denotan la función de piso).

Pyke, 16 bytes

uAD,sXF**"# 

Pruébalo aquí!

Equivalente a

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

Debido a no imprimibles

Esto usa un par de trucos para reducir el conteo de bytes:

• Utiliza algunos no imprimibles para representar la lista [1, 4, 1]
• XF vuelca automáticamente la salida a la pila
• La cadena "#al final se intercambia con la última *, lo que significa que "no se requiere el cierre . Esto sucede implícitamente cuando el último token es una cadena.

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

Pitón 2 , 68 71 65 bytes

-6 con agradecimiento a @sagiksp

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

Pruébalo en línea!

En ausencia de encontrar una manera de vencer a @xnor, publicaré mi función recursiva simplemente como un enfoque alternativo. Para impresiones f (5)

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

Este patrón fue elegido simplemente porque se puede dividir en dos partes, a diferencia de todas las demás.

PHP, 64 62 bytes

Guardado 2 bytes gracias a Christoph .

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

Imprime una red como esta:

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

(con una nueva línea principal)

Lote, 111 bytes

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

Agresivo , 32 29 28 bytes

Imprime el cubo neto justificado a la izquierda. Esto fue difícil de golf ...

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

Pruébalo en línea!

Retina , 39 37 bytes

Esta es la primera vez que uso Retina, todavía estoy tratando de entender cómo hacer las cosas.

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

(con dos espacios finales después de la 4ta y 5ta línea)

¡Gracias a Martin Ender por jugar al golf 2 bytes!

Pruébalo en línea!

QBIC , 52 67 40 bytes

Reescritura completa:

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

Esto ahora usa este patrón:

###--
--###

Donde -se llenan los espacios.

:        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 bytes

15 bytes de código, +1 para -nbandera.

"# "Xa*_RLaM141

Toma el tamaño como un argumento de línea de comandos. Pruébalo en línea!

Explicación

                 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)

Lo siguiente no es exactamente cómo se modifican los datos, pero da la idea básica (para a=2):

141

[1;4;1]

[2;8;2]

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

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

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

05AB1E , 13 bytes

D141S×S*„# ×»

Pruébalo en línea!

Explicación

Entrada de ejemplo 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 bytes

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 bytes

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

Explicado:

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

Después de la primera IMPRESIÓN (tamaño = 2, @ es la posición del cursor):

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

@ 

Después del DESPLAZAMIENTO:

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

Después de la segunda IMPRESIÓN:

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

Lisp común, 83 81 79 bytes

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

Salida:

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

¿Como funciona?

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

Ideas de mejora son bienvenidas.