Die Herausforderung:

Zeichnen Sie ein Rechteck aus ASCII-Feldern: []

Die Regeln:

Nimmt eine Eingabe für Breite und Höhe vor

Sie können davon ausgehen, dass beide Zahlen sind

Es muss eine Zeichenfolge mit Zeilenumbrüchen erstellt werden, \ n

Beispiele:

2, 2:

[][]
[][]

2, 3:

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

Wenigste Bytes gewinnt.

SOGL , 5 Bytes

Ƨ[]*∙

Einfach:

Ƨ[]    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"

Probieren Sie es online!

Erläuterung

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 mit einem cleveren Trick dank insert_name_here

VE*`Y

Probieren Sie es hier aus

Erläuterung:

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

oder

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

Habe ich bei meinem ersten Codegolfversuch etwas Offensichtliches übersehen?

05AB1E , 6 Bytes

F„[]×,

Probieren Sie es online!

Erläuterung

Eingabe dauert wie height, width

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

; # + 197 Bytes

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

Probieren Sie es online! Benötigt nach jeder Eingabenummer ein Null-Byte.

Ich weiß irgendwie nicht, wie das funktioniert. Was ich Ihnen sagen kann ist, dass dieser Teil des Codes:

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

analysiert die eingegebenen Zahlen.

Brainfuck, 145 Bytes

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

Probieren Sie es online!

Mein allererster Code Golf! Yay!

Die Eingabe erfolgt in ASCII + 48. Um also 50, 50 zu tun, müssen Sie b, b eingeben (die ASCII-Buchstaben für 98).

Erläuterung

+++++++++[>++++++++++<-]>+ 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

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

Probieren Sie es online!

Erläuterung

'[]'$~],+:@[   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

Dies gibt uns eine xdurch 2yReihe von sich wiederholenden []Zeichen.

Python 2.7, 32 Bytes

Volles Programm:

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

Probieren Sie es online!

Gelee , 7 Bytes

ẋ⁾[]ẋ$Y

Ein dyadischer Link, der eine Liste von Zeichen zurückgibt (oder ein vollständiges Programm, das das Ergebnis druckt).

Probieren Sie es online!

Wie?

ẋ⁾[]ẋ$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
[]

Probieren Sie es online! Übernimmt die Eingabe von Höhe und Breite in separaten Zeilen.

Python 3 , 26 Bytes

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

Probieren Sie es online!

V , 7 Bytes

Ài[]<esc>ÀÄ

wo <esc>ist 0x1b.

Probieren Sie es online!

Erläuterung

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

Ohm , 9 Bytes

M"[]"َJ,    

Probieren Sie es online!

Erläuterung

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 Danke an Mathias!

Japt , 13 12 + 1 = 14 13 Bytes

+1 für die -RFlagge.

"[]"pN× òU*2

Probieren Sie es online aus

• Dank obarakon 1 Byte gespart.

APL (Dyalog) , 11 Bytes

'[]'⍴⍨⊢,2×⊣

Probieren Sie es online!

'[]' die Saite

⍴⍨ zyklisch wiederholt, um die Form zu füllen

⊢ richtiges Argument (Zeilen)

, und

2× zweimal

⊣ das linke Argument (Spalten)

Kohle , 8 7 Bytes

ＥＮ×[]Ｉη

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Nimmt Eingaben in der Reihenfolge Höhe, Breite vor. Die Zeichenprimitive von Charcoal sind dafür nicht geeignet, daher ist dies nur ein einfacher Ausweg, und die []Zeichenfolge wird entsprechend wiederholt . Erläuterung:

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

Probieren Sie es online!

Gibt eine anonyme Funktion zurück, die die Zeichenfolge erstellt und zurückgibt.

45 Bytes, nicht konform

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

Eine anonyme Funktion, die den String im gewünschten Format ausgibt.

Versuchen Sie dies online

Japt , 7 Bytes

6 Byte Code, +1 für das -RFlag.

VÆç"[]

Funktioniert aufgrund eines Fehlers in der neuesten Version çnicht, funktioniert aber in Commitf619c52 . Online testen!

Erläuterung

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

Probieren Sie es online!

QBIC , 14 Bytes

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

Erläuterung:

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

Dies nimmt seine Argumente in der Reihenfolge von #rows, #cols. Die Ausgabe beginnt mit einem Zeilenumbruch.

Pyke, 8 Bytes

}A;**"[]

Probieren Sie es hier aus!

Auch 8 Bytes:

 F2K*"[]

Probieren Sie es hier aus!

Bash , 55 Bytes

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

Probieren Sie es online! Verwendet die TIO-Variante von bash, da ich Windows verwende.

78 Bytes

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

Führen Sie in C # Pad

Dies ist kürzer als bei for-Schleifen, und mir ist keine Funktion in C # bekannt, die sich mit weniger Code wiederholen kann.

CJam, 10 Bytes

l~"[]"*N+*

JavaScript (ES6), 43 36 Bytes

Aus den Kommentaren ist nun ein abschließender Zeilenumbruch zulässig.

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

Versuch es

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

Probieren Sie es online!

Canvas , 4 Bytes

[]×＊

Probieren Sie es hier aus!