22

Le défi:

Dessinez un rectangle de cases ASCII: []

Les règles:

Prend une entrée de largeur et de hauteur

Vous pouvez supposer que ce sont des nombres

Doit produire une chaîne avec des caractères de nouvelle ligne, \ n

Exemples:

2, 2:

[][]
[][]

2, 3:

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

Le moins d'octets gagne.

code-golf string ascii-art

— Robinlemon
source

2

Bon premier post! Bienvenue chez PPCG!

— MD XF

1

Puis-je supposer que les chiffres sont positifs? Peut-il y avoir des nouvelles lignes de fuite?

— dzaima

@dzaima Entiers positifs, aucun élément de fin ou de

— début

pouvons-nous imprimer sur la console ou devons-nous renvoyer la chaîne?

— Giuseppe

5

que faire si nous ne pouvons littéralement pas ne pas imprimer de nouvelles lignes de fin? cela a tendance à être une bonne pratique d'autoriser une nouvelle ligne à la fin

— Destructible Lemon

6

SOGL , 5 octets

Ƨ[]*∙

Simple:

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

— dzaima
source

4

Mathematica, 26 octets

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

— J42161217
source

Un Gridobjet Mathematica compte-t-il comme "une chaîne avec des caractères de nouvelle ligne"?

— David Zhang

4

MATL , 7 octets

v&DiiX"

Essayez-le en ligne!

Explication

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

— Luis Mendo
source

4

Pyth - 7 5 octets

-2 octets par une astuce astucieuse grâce à insert_name_here

VE*`Y

Essayez-le ici

Explication:

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

— Maria
source

3

Vous pouvez enregistrer 2 octets à l'aide de `Y(représentation sous forme de chaîne de la liste vide) au lieu de "[]".

— insert_name_here

@insert_name_here Ingenious !! J'ai mis à jour la réponse. Merci d'avoir fait remarquer cela!

— Maria

1

Entré avec ce code exact indépendamment. Bien fait.

— isaacg

4

C, 47 46 octets

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

ou

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

Ma première tentative de golf par code, ai-je raté quelque chose d'évident?

— dbandstra
source

Il y en a pour 45, mais il y a une nouvelle ligne au début:f(w,h){h*=w;while(h--)printf("\n[]"+!(h%w));}

— Conor O'Brien

Cela ne fonctionne que lorsque la largeur est de 2.

— dbandstra

C'est le cas, mon erreur

— Conor O'Brien

Super premier golf! Bienvenue sur le site!

— MD XF

1

L'utilisation d'une forboucle ne raccourcirait -elle pas encore plus le code?

— Spikatrix

3

05AB1E , 6 octets

F„[]×,

Essayez-le en ligne!

Explication

L'entrée prend comme height, width

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

— Emigna
source

3

; # + , 197 octets

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

Essayez-le en ligne! Nécessite un octet zéro après chaque numéro d'entrée.

Je ne sais pas comment ça marche. Ce que je peux vous dire, c'est que cette partie du code:

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

analyse les numéros d'entrée.

— Conor O'Brien
source

3

brainfuck, 145 octets

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

Essayez-le en ligne!

Mon tout premier golf à code! Yay!

L'entrée est en ascii + 48, donc pour faire 50, 50 vous devez entrer b, b (les lettres ascii pour 98)

Explication

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

— vityavv
source

Impressionnant. Bienvenue sur le site! :)

— DJMcMayhem

Pourquoi l'entrée ASCII + 48? Vous pouvez économiser beaucoup d'octets en utilisant simplement l'entrée ASCII + 0 (éventuellement en vous connectant à la version ASCII + 48 pour plus de convivialité)

— CalculatorFeline

Je voulais juste répondre aux critères de saisie, @calculatorFeline

— vityavv

... Ah oui. : |

— CalculatorFeline

2

J , 12 octets

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

Essayez-le en ligne!

Explication

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

Cela nous donne une xpar 2ychaîne de répétition des []caractères.

— Conor O'Brien
source

11 octets

— Leaky Nun

2

Python 2.7, 32 octets

Programme complet:

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

Essayez-le en ligne!

— Koishore Roy
source

2

Gelée , 7 octets

ẋ⁾[]ẋ$Y

Un lien dyadique renvoyant une liste de caractères (ou un programme complet imprimant le résultat).

Essayez-le en ligne!

Comment?

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

— Jonathan Allan
source

2

Rétine , 32 octets

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

Essayez-le en ligne! Prend la hauteur et la largeur saisies sur des lignes séparées.

— Neil
source

2

Python 3 , 26 octets

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

Essayez-le en ligne!

— ovs
source

2

V , 7 octets

Ài[]<esc>ÀÄ

où <esc>est 0x1b.

Essayez-le en ligne!

Explication

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

— Kritixi Lithos
source

2

Ohm , 9 octets

M"[]"┘ÄJ,

Essayez-le en ligne!

Explication

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

— Datboi
source

2

PowerShell, 25 octets

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

-3 merci à Mathias!

— colsw
source

Vous pouvez le raccourcir à 25 comme ceci:param($w,$h),("[]"*$w)*$h

— Mathias R. Jessen

2

Japt , 13 12 + 1 = 14 13 octets

+1 pour le -Rdrapeau.

"[]"pN× òU*2

Essayez-le en ligne

1 octet économisé grâce à obarakon.

— Hirsute
source

Être un peu ivre peut parfois améliorer vos compétences en programmation : P

— ETHproductions

@ETHproductions: le dessin animé que je cherchais mais j'étais trop ivre pour le trouver!

— Shaggy

Haha, j'espère que vous passez une bonne soirée. fyi, U*Vpeut être raccourci àN×

— Oliver

1

@obarakon: C'est 2 opportunités de travailler avec Nhier soir. Jamais boire et jouer au golf, les enfants!

— Shaggy

2

APL (Dyalog) , 11 octets

'[]'⍴⍨⊢,2×⊣

Essayez-le en ligne!

'[]' la chaîne

⍴⍨ répété cycliquement pour remplir la forme

⊢ argument de droite (lignes)

, et

2× deux fois

⊣ l'argument de gauche (colonnes)

— Adam
source

2

Fusain , 8 7 octets

ＥＮ×[]Ｉη

Essayez-le en ligne! Le lien est vers la version détaillée du code. Prend la saisie dans l'ordre hauteur, largeur. Les primitives de dessin de Charcoal ne sont pas adaptées à cela, donc cela prend simplement le chemin facile et répète la []chaîne de manière appropriée. Explication:

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

— Neil
source

Eh bien, il a des primitives de dessin pour cela, mais toujours 8 octets : P

— ASCII uniquement

@ ASCII uniquement Désolé, je ne savais pas que Oblong fonctionnait sur des chaînes arbitraires. Soigné!

— Neil

@ ASCII uniquement Oh, et quel est le nom détaillé de la variable de chaîne vide prédéfinie?

— Neil

C'est w, nom , grec à verbeux

— ASCII uniquement

@ ASCII uniquement Alors qu'est-ce que je fais de mal ici: Essayez-le en ligne!

— Neil

1

R , 70 octets

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

Essayez-le en ligne!

Renvoie une fonction anonyme qui construit et renvoie la chaîne.

45 octets, non conforme

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

Une fonction anonyme qui imprime la chaîne au format souhaité.

Essayez ceci en ligne

— Giuseppe
source

1

Japt , 7 octets

6 octets de code, +1 pour le -Rdrapeau.

VÆç"[]

Ne fonctionne pas dans la dernière version en raison d'un bogue avec ç, mais il fonctionne en commitf619c52 . Testez-le en ligne!

Explication

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

— ETHproductions
source

1

Aller , 74 octets

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

Essayez-le en ligne!

— totalement humain
source

1

QBIC , 14 octets

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

Explication:

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

Cela prend ses arguments dans l'ordre des #rows, #cols. La sortie commence par une nouvelle ligne.

— steenbergh
source

1

Pyke, 8 octets

}A;**"[]

Essayez-le ici!

Aussi 8 octets:

 F2K*"[]

Essayez-le ici!

— Bleu
source

1

Bash , 55 octets

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

Essayez-le en ligne! Utilise la saveur TIO de bash, car je lance Windows.

— Conor O'Brien
source

1

Je ne pense pas que cela fonctionne pour les nombres à plusieurs chiffres

— Kritixi Lithos

@KritixiLithos Cela devrait fonctionner maintenant

— Conor O'Brien

1

C #, 78 octets

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

Exécuter en C # Pad

C'est plus court qu'avec les boucles for et je ne connais aucune fonction en C # qui puisse se répéter avec moins de code.

— Arthur Rump
source

1

CJam, 10 octets

l~"[]"*N+*

— Esolanging Fruit
source

1

JavaScript (ES6), 43 36 octets

D'après les commentaires, une nouvelle ligne de fin est désormais autorisée.

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

Essayez-le

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>

Développer l'extrait

— Hirsute
source

1

J , 11 octets

,./@$'[]'"0

Essayez-le en ligne!

— FrownyFrog
source

1

Canvas, 4 bytes

[]×＊

Try it here!

— dzaima
source

Créer dynamiquement des boîtes

SOGL , 5 octets

Mathematica, 26 octets

MATL , 7 octets

Explication

Pyth - 7 5 octets

C, 47 46 octets

05AB1E , 6 octets

; # + , 197 octets

brainfuck, 145 octets

Explication

J , 12 octets

Explication

Python 2.7, 32 octets

Gelée , 7 octets

Comment?

Rétine , 32 octets

Python 3 , 26 octets

V , 7 octets

Explication

Ohm , 9 octets

Explication

PowerShell, 25 octets

Japt , 13 12 + 1 = 14 13 octets

APL (Dyalog) , 11 octets

Fusain , 8 7 octets

R , 70 octets

45 octets, non conforme

Japt , 7 octets

Explication

Aller , 74 octets

QBIC , 14 octets

Pyke, 8 octets

Bash , 55 octets

C #, 78 octets

CJam, 10 octets

JavaScript (ES6), 43 36 octets

Essayez-le

J , 11 octets

Canvas, 4 bytes