El reto:

Dibuja un rectángulo de cuadros ASCII: []

Las normas:

Toma un ancho y una entrada de altura

Puedes asumir que ambos son números

Debe producir una cadena con caracteres de nueva línea, \ n

Ejemplos:

2, 2:

[][]
[][]

2, 3:

[][]
[][]
[][]

Fewest Bytes gana.

SOGL , 5 bytes

Ƨ[]*∙

Simple:

Ƨ[]    push "[]"
   *   multiply horizontally (repeating width times)
    ∙  get an array with input (height) items of that
       implicitly output the array joined with newlines

Mathematica, 26 bytes

Grid@Table["[]",{#2},{#}]&

MATL , 7 bytes

v&DiiX"

Pruébalo en línea!

Explicación

v    % Concatenate the (non-existing) stack contents: gives []
&D   % String representation: gives '[]'
ii   % Take two inputs
X"   % Repeat those numbers of times vertically and horizontally. Implicit display

Pyth - 7 5 bytes

-2 bytes por un truco inteligente gracias a insert_name_here

VE*`Y

Pruébalo aquí

Explicación:

VE*`Y
V      # Loop
 E     # <input> number of times
   `Y  # String representation of empty list (used to be "[]", but insert_name_here pointed out this shorter alternative)
  *    # repeat string implicit input number of times
       # implicit print

C, 47 46 bytes

f(w,h){for(h*=w;h--;)printf(h%w?"[]":"[]\n");}

o

f(w,h){for(h*=w;h--;)printf("[]%c",h%w?0:10);}

Mi primer intento de código de golf, ¿me perdí algo obvio?

05AB1E , 6 bytes

F„[]×,

Pruébalo en línea!

Explicación

La entrada toma como height, width

F         # height times do
 „[]      # push "[]"
    ×     # repeat width times
     ,    # print with newline

; # + , 197 bytes

>;;;;;;~++++++++:>~;;;;:>~*(-:~<~+-::>-:::<~<-+++++++++~:::<~+-:::>-::*)-::<-::::>-::(;)::>-::*(-:~<~+-::>-:::<~<-+++++++++~:::<~+-:::>-::*)-:<~<;;;;;-+>-:<-:-(-:::~<-:::(~<#<-;;-#~;)-:<#-::<;>-:-)

Pruébalo en línea! Requiere un byte cero después de cada número de entrada.

No sé cómo funciona esto. Lo que puedo decirte es que esta parte del código:

 *(-:~<~+-::>-:::<~<-+++++++++~:::<~+-:::>-::*)-::<-::::>-::(;)::>-::*(-:~<~+-::>-:::<~<-+++++++++~:::<~+-:::>-::*)

está analizando los números de entrada.

brainfuck, 145 bytes

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

Pruébalo en línea!

¡Mi primer código de golf! ¡Hurra!

La entrada está en ascii + 48, por lo que para hacer 50, 50 debe ingresar b, b (las letras ascii para 98)

Explicación

+++++++++[>++++++++++<-]>+ Get the opening square bracket into first position
[>+>+<<-] Get it into the second and third position
>>++ Get the third position to be the closing bracket
>
,>+++++++++[<----->-]<--- Get first number into fourth cell
>>>
,>+++++++++[<----->-]<--- Get second number into seventh cell
>++++++++++ get newline into 8th position
<

[ Start our height loop
<<<[>+>+<<-] Get the width into the fifth and sixth positions
>[ Start our width loop at the fifth position
<<<.>. Print the second and third positions
>>-] Decrement the fifth position
>
[<<+>>-] copy the sixth position into the fourth position
>>. print newline
<-]

J , 12 bytes

'[]'$~],+:@[

Pruébalo en línea!

Explicación

'[]'$~],+:@[   input: y, x
        +:@[   double y
      ],       pair with x
               this gives (x, 2y)
    $~         shape the left argument into the right argument's shape
'[]'           2-length character string

Esto nos da una xpor 2ycadena de repetir []caracteres.

Python 2.7, 32 bytes

Programa completo:

n,m=input()
exec"print'[]'*n;"*m

Pruébalo en línea!

Jalea , 7 bytes

ẋ⁾[]ẋ$Y

Un enlace diádico que devuelve una lista de caracteres (o un programa completo que imprime el resultado).

Pruébalo en línea!

¿Cómo?

ẋ⁾[]ẋ$Y - Main link: number w, number h          e.g. 2, 3
ẋ       - repeat w h times                            [2,2,2]
     $  - last two links as a monad:
 ⁾[]    -   literal ['[',']'],                        "[]"
    ẋ   -   repeat list (vectorises)                  ["[][]","[][]","[][]"]
      Y - join with newlines                          "[][]\n[][]\n[][]"
        - if a full program, implicit print

Retina , 32 bytes

.+
$*
1(?=1*(¶1+))|.
$1
G`1
1
[]

Pruébalo en línea! Toma la entrada de alto y ancho en líneas separadas.

Python 3 , 26 bytes

lambda n,m:('[]'*n+'\n')*m

Pruébalo en línea!

V , 7 bytes

Ài[]<esc>ÀÄ

donde <esc>está 0x1b.

Pruébalo en línea!

Explicación

Ài[]<esc>                    " arg1 times insert []
         ÀÄ                  " arg2 times duplicate this line

Ohm , 9 bytes

M"[]"َJ,    

Pruébalo en línea!

Explicación

M"[]"َJ,
M         //Executes code input1 times
 "[]"     //Pushes []
     َ   //Duplicates [] input2 times
       J  //Joins the stack
        , //Prints with a trailing newline

PowerShell, 25 bytes

param($w,$h),("[]"*$w)*$h

-3 gracias a Mathias!

Japt , 13 12 + 1 = 14 13 bytes

+1 para la -Rbandera.

"[]"pN× òU*2

Pruébalo en línea

• 1 byte guardado gracias a obarakon.

APL (Dyalog) , 11 bytes

'[]'⍴⍨⊢,2×⊣

Pruébalo en línea!

'[]' la cuerda

⍴⍨ repetido cíclicamente para llenar la forma

⊢ argumento correcto (filas)

, y

2× dos veces

⊣ el argumento izquierdo (columnas)

Carbón , 8 7 bytes

ＥＮ×[]Ｉη

Pruébalo en línea! El enlace es a la versión detallada del código. Toma entrada en el orden alto, ancho. Las primitivas de dibujo de carbón no son adecuadas para esto, por lo que esto simplemente toma la salida fácil y repite la []secuencia de manera apropiada. Explicación:

 Ｎ      First input as a number
Ｅ       Map over implcit range
      η Second input
     Ｉ  Cast to number
   []   Literal string
  ×     Repeat
        Implicitly print on separate lines

R , 70 bytes

p=paste
function(w,h)p(rep(p(rep('[]',w),collapse=''),h),collapse='
')

Pruébalo en línea!

Devuelve una función anónima que construye y devuelve la cadena.

45 bytes, no conforme

function(w,h)write(matrix('[]',w,h),'',w,,'')

Una función anónima que imprime la cadena en el formato deseado.

Prueba esto en línea

Japt , 7 bytes

6 bytes de código, +1 para la -Rbandera.

VÆç"[]

No funciona en la última versión debido a un error con ç, pero funciona en commitf619c52 . ¡Pruébelo en línea!

Explicación

VÆ   ç"[]
VoX{Uç"[]"}  // Ungolfed
             // Implicit: U, V = input integers
VoX{      }  // Create the range [0...V) and replace each item X with
    Uç"[]"   //   U copies of the string "[]".
-R           // Join the result with newlines.
             // Implicit: output result of last expression

Go , 74 bytes

import."strings"
func(x,y int)string{return Repeat(Repeat("[]",x)+"\n",y)}

Pruébalo en línea!

QBIC , 14 bytes

[:|?[:|?@[]`';

Explicación:

[:|     FOR a = 1 to (read input from cmd line)
?       PRINT a newlne
[:|     FOR c = 1 to (read input from cmd line)
?@[]`   PRINT A$ (containing the box)
';         and inject a semicolon in the compiled QBasic code to suppress newlines

Esto toma sus argumentos en el orden de #rows, #cols. La salida comienza con una nueva línea.

Pyke, 8 bytes

}A;**"[]

Pruébalo aquí!

También 8 bytes:

 F2K*"[]

Pruébalo aquí!

Bash , 55 bytes

seq $(($1*$2))|sed s/.*/[]/|tr -d "
"|fold -w $(($1*2))

Pruébalo en línea! Utiliza el sabor TIO de bash, ya que ejecuto windows.

C #, 78 bytes

(w,h)=>"".PadLeft(h).Replace(" ","".PadLeft(w).Replace(" ","[]")+'\n').Trim();

Ejecutar en C # Pad

Esto es más corto que con for-loops y no conozco ninguna función en C # que pueda repetirse con menos código.

CJam, 10 bytes

l~"[]"*N+*

JavaScript (ES6), 43 36 bytes

De los comentarios, ahora se permite una nueva línea final.

w=>h=>("[]".repeat(w)+`
`).repeat(h)

Intentalo

f=
w=>h=>("[]".repeat(w)+`
`).repeat(h)
oninput=_=>o.innerText=f(+i.value)(+j.value);o.innerText=f(i.value=2)(j.value=2)

*{font-family:sans-serif;}
input{margin:0 5px 0 0;width:50px;}

<label for=i>w: </label><input id=i type=number><label for=j>h: </label><input id=j type=number><pre id=o>

J , 11 bytes

,./@$'[]'"0

Pruébalo en línea!

Lienzo , 4 bytes.

[]×＊

Pruébalo aquí!