Votre tâche consiste à générer des boîtes en utilisant n'importe quel caractère ASCII par rapport aux entrées fournies.

Cas de test

1 1   --> =====
          =   =
          =====

1 2   --> =========
          =   =   =
          =========

2 1   --> =====
          =   =
          =====
          =   =
          =====

2 2   --> =========
          =   =   =
          =========
          =   =   =
          =========

2 5   --> =====================
          =   =   =   =   =   =
          =====================
          =   =   =   =   =   =
          =====================

Contribution

• L'entrée peut être prise à partir de l'un des éléments suivants

  • stdin
  • Arguments de ligne de commande
  • Arguments de fonction (2 arguments, un pour chaque nombre)

• L'entrée, si elle est extraite de stdinou des arguments de ligne de commande, contiendra deux entiers positifs, séparés par un espace.

• Les deux nombres indiquent le nombre de cases dans chaque colonne et ligne

Production

• Les boîtes doivent être sorties stdout(ou l'équivalent le plus proche)
• Chaque boîte doit contenir trois espaces horizontaux

Règles

• Les deux nombres seront supérieurs à 0, mais ne dépasseront pas 1000
• Tout caractère visible peut être utilisé pour sortir les boîtes. (tant qu'ils ne sont pas trop durs pour les yeux!)
• Vous êtes autorisé à écrire un programme complet ou une fonction.
• Il ne doit pas y avoir de caractères inutiles à l'exception d'un caractère de retour à la ligne facultatif.

Notation

Il s'agit de code-golf , donc la soumission la plus courte (en octets) l'emporte.

Pyth, 23 octets

Mjbmsm@"= "&%k4dh*4HhyG

Définit la fonction gqui fonctionne comme souhaité.

Manifestation.

Rétine , 57 octets

1(?=.* (1*))
$1#$1#


1(?=(1*#1*#)*$)
=   
1
====
#
=#

Prend entrée en unaire avec une nouvelle ligne de fin.

Chaque ligne doit aller dans son propre fichier et #doit être remplacée par un retour à la ligne dans les fichiers. Cela n'est pas pratique, mais vous pouvez exécuter le code tel quel comme un fichier avec l' -sindicateur, en conservant les #marqueurs (et en changeant le retour à la ligne #en entrée également). #Si vous le souhaitez, vous pouvez remplacer le retour par des sauts de ligne dans la sortie pour plus de lisibilité. Par exemple:

> echo -n 11 111#|retina -s boxes|tr # '\n'
=============
=   =   =   =
=============
=   =   =   =
=============

Méthode: 5 étapes de substitution simples. Les deux premières (4 premières lignes) créent une grille 2*N+1par Munités et les 3 étapes suivantes (6 lignes) le formatent dans la sortie souhaitée.

Les chaînes intermédiaires (délimitées par -des):

11 111
------------------
111
111
111
111
 111
------------------
111
111
111
111
111
------------------
111
=   =   =   
111
=   =   =   
111
------------------
============
=   =   =   
============
=   =   =   
============
------------------
=============
=   =   =   =
=============
=   =   =   =
=============

JavaScript ( ES6 ), 83

Une fonction avec des lignes et des colonnes de paramètres. À l'aide de chaînes de modèle, il y a 2 sauts de ligne intégrés qui sont significatifs et comptés.

Sortie via alert(popup). En alertutilisant une police proportionnelle, nous obtenons un meilleur résultat en utilisant une lettre avec une largeur similaire à l'espace au lieu de =.

Testez dans Firefox en utilisant la console pour avoir la alertsortie réelle , ou exécutez l'extrait ci-dessous.

f=(r,c)=>{for(x=y="|";c--;)x+="||||",y+="   |";for(o=x;r--;)o+=`
${y}
`+x;alert(o)}

// TEST

// redefine alert to avoid that annoying popup during test
alert=x=>O.innerHTML=x

test=_=>([a,b]=I.value.match(/\d+/g),f(a,b))

test()

<input id=I value='2 3'><button onclick="test()">-></button>
<pre id=O></pre>

JavaScript (ES6), 75 73

En utilisant des repeatappels copieux , nous répétons |, puis répétons |avec des espaces de fin, et répétons ces deux répétitions pour faire des lignes:

f=(y,x)=>alert(((s="|"[r="repeat"](x*4)+`|
`)+"|   "[r](x)+`|
`)[r](y)+s)

(Les nouvelles lignes sont importantes, selon la suggestion d'edc65 d'utiliser des chaînes de modèle.)

Fragment:

<input id="x" type="range" max="10" min="1" step="1" value="3"><input id="y" type="range" max="10" min="1" step="1" value="2"><pre id="o"></pre><script>function f(y,x){return ((s="|"[r="repeat"](x*4)+"|\n")+"|   "[r](x)+"|\n")[r](y)+s};function redraw(){document.getElementById("o").innerHTML=f(document.getElementById("y").value,document.getElementById("x").value)};document.getElementById("x").onchange=redraw;document.getElementById("y").onchange=redraw;document.getElementById("x").oninput=redraw;document.getElementById("y").oninput=redraw;redraw();</script>

Sans chaînes de modèle, sans réutilisation de nom de méthode et avec des espaces supplémentaires:

f=(y,x)=>alert(
    (
      (s="|".repeat(x*4)+"|\n") + 
      "|   ".repeat(x)+"|\n"
    ).repeat(y)+s
)

(En utilisant la recommandation d' edc65 à utiliser |pour un meilleur espacement visuel.)

Pip, 29 24 = 23 + 1 octets

Nécessite le -ndrapeau. Prend la hauteur et la largeur comme arguments de ligne de commande et construit des boîtes de 1s.

([1X4m]XbRLa+1)@<v.1R0s

Explication:

                         a,b are cmdline args; m is 1000; v is -1; s is " " (implicit)
 [1X4m]                  List containing 1111 and 1000
       Xb                String repetition of each element b times
         RLa+1           Repeat the list a+1 times
(             )@<v       Now we have one row too many at the end, so take everything
                         but the last item (equiv to Python x[:-1])
                  .1     Concatenate a 1 to the end of each row
                    R0s  Replace 0 with space
                         Print, joining list on newlines (implicit, -n flag)

Ce programme profite largement du fait que les chaînes sont des nombres et que les nombres sont des chaînes dans Pip. (Et les trois espaces dans ces cases se sont avérés être parfaits pour profiter de la mvariable intégrée !)

Voici comment la liste est construite avec l'entrée 2 3:

[1111;1000]
[111111111111;100010001000]
[111111111111;100010001000;111111111111;100010001000;111111111111;100010001000]
[111111111111;100010001000;111111111111;100010001000;111111111111]
[1111111111111;1000100010001;1111111111111;1000100010001;1111111111111]
[1111111111111;"1   1   1   1";1111111111111;"1   1   1   1";1111111111111]

Et la sortie finale:

C:\> pip.py 2 3 -ne "([1X4m]XbRLa+1)@<v.1R0s"
1111111111111
1   1   1   1
1111111111111
1   1   1   1
1111111111111

Plus sur Pip

Perl, 72 63 52 50 octets

Ma version la plus courte utilise encore $/pour obtenir un caractère de nouvelle ligne de manière plus compacte:

$ perl -e 'print((($,="="."   ="x pop.$/)=~s/./=/gr)x(1+pop))' 2 5
=====================
=   =   =   =   =   =
=====================
=   =   =   =   =   =
=====================

La mise à jour précédente place les lignes principalement vides dans le séparateur d'enregistrements de sortie $,et imprime une liste de lignes continues.

$ perl -e 'print((($,="="."   ="x pop."\n")=~s/./=/gr)x(1+pop))' 2 5

La version précédente pourrait être un peu plus claire pour le lecteur occasionnel:

$ perl -E 'say($y=($x="="."   ="x pop)=~s/./=/gr);for(1..pop){say$x;say$y}' 2 5

La première version utilisée @ARGVau lieu de pop:

$ perl -E 'say($y=($x="="."   ="x$ARGV[1])=~s/./=/gr);for(1..$ARGV[0]){say$x;say$y}' 2 5

Python 2, 58 57 octets

Mise en œuvre assez simple.

def f(x,y):a="="*(4*y+1);print(a+"\n="+"   ="*y+"\n")*x+a

Vérifiez le ici.

Merci à Sp3000 pour avoir sauvé un octet.

GNU sed -r, 160

Soupir, je pensais que ce serait plus petit, mais le voici quand même. Malheureusement, les expressions rationnelles sed n'ont aucune capacité de recherche.

:
s/(.*)1$/   =\1/;t
s/([= ]+)/\1\n\1/
:b
s/   (.*\n)/===\1/;tb
s/(1*)1 $/\n\1/
:c
s/([^\n]*\n[^\n]*\n)(1*)1$/\1\1\2/;tc
s/(=+)(.*)/\1\2\1/
s/(^|\n)(.)/\1=\2/g

Prendre la saisie comme unaire de STDIN:

$ sed -rf boxes.sed <<< "11 111"
=============
=   =   =   =
=============
=   =   =   =
=============
$

CJam, 25 octets

q~)S3*'=5*+4/f*3f>\)*1>N*

Essayez-le en ligne dans l' interpréteur CJam .

Comment ça fonctionne

q~                        e# Read H and W from STDIN.
   S3*'=5*+               e# Push "   =====".
           4/             e# Chop into ["   =" "===="].
  )          f*           e# Repeat each string W+1 times.
               3f>        e# Cut off the first three characters.
                  \)*     e# Repeat the resulting array H+1 times.
                     1>   e# Remove the first string.
                       N* e# Join the lines.

Marbelous, 168 octets

Cette réponse ne fonctionne que jusqu'à 255x255, pas 1000x1000, en raison des limitations du langage Marbelous. Je travaille sur une bibliothèque 32 bits, mais elle ne sera pas prête de sitôt.

L'entrée est fournie sous forme de deux paramètres de ligne de commande ou paramètres de fonction à la carte principale.

@2@3}1@0
SLEL//>0\/
@3@1}0--
}1&0@0/\&0
@1/\@2}1\/
:SL
..}0@0
&0/\>0&0
EN..--\/
{0@0/\ES
:EL
..@0
..>0EN
}0--\/
@0/\EX
:EX
}0
\/3D3D3D3D
:ES
}0
\/3D202020
:EN
}0
{03D0A

Pseudocode:

MB(H,W):
    EL(W)
    for 1..H:
        SL(W)
        EL(W)
EL(W):
    for 1..W:
        EX()
    EN()
SL(W):
    for 1..W:
        ES()
    EN()
EX():
    print "===="
ES():
    print "=   "
EN():
    print "=\n"

CJam 52 51 46 41 octets

l~:B;:A;'=:U{{U4*}B*N}:V~{U{SZ*U}B*NUV}A*

Merci à Sp3000 pour -5 caractères

Merci à Martin Büttner ♦ pour encore 5 caractères

Essayez-le

fonction c, 81

x,y;f(h,w){for(;y<=h*2;y++)for(x=0;x<w*4+2;x++)putchar(x>w*4?10:x&3&&y&1?32:61);}

Programme de test:

x,y;f(h,w){for(;y<=h*2;y++)for(x=0;x<w*4+2;x++)putchar(x>w*4?10:x&3&&y&1?32:61);}

int main (int argc, char **argv)
{
  f(2, 3);
}

PHP4.1, 76 71 69 octets

C'est aussi golfique que possible.

$R=str_repeat;echo$R(($T=$R('-',4*$H+1))."
|{$R('   |',$H)}
",$V),$T;

Cela attend que la clé Hait le nombre de lignes et Vle nombre de cases par ligne.

J'utilise -et |juste pour que les boîtes ressemblent à des boîtes. Si nécessaire, je peux le remplacer par =. Peu importe le caractère utilisé.
Partir -et |aide également à comprendre le gâchis qui se passe.

Ancienne méthode, 76 octets:

for($R=str_repeat;$H--;)echo$T=$R('-',($V*4)+1),"
|{$R('   |',$V)}
";echo$T;

Exemple de sortie:

http://localhost/file.php?H=2&V=3

-------------
|   |   |   |
-------------
|   |   |   |
-------------

Julia, 59 octets

(n,m)->(l="="^(4m+1)*"\n";print(l*("="*"   ="^m*"\n"*l)^n))

Cela crée une fonction sans nom qui accepte deux entiers en entrée et imprime le résultat dans STDOUT. Pour l'appeler, donnez-lui un nom, par exemple f=(n,m)->....

Non golfé + explication:

function f(n, m)
    # Store the solid row
    l = "="^(4m + 1) * "\n"

    # Print all rows by repeating a pattern n times
    print(l * ("=" * "   ="^m * "\n" * l)^n)
end

Exemples:

julia> f(2, 3)
=============
=   =   =   =
=============
=   =   =   =
=============

julia> f(1, 5)
=====================
=   =   =   =   =   =
=====================

Toutes suggestions sont les bienvenues.

bash + coreutils, 57

dc -e"2do$2 4*1+^1-pd8*F/1+$1si[fli1-dsi0<c]dscx"|tr 0 \ 

Cela permet dcd'imprimer des nombres binaires qui ont 1s pour les bords de la boîte et 0s pour les espaces.

• le nombre tout- X est calculé par 2 ^ (width * 4 + 1) - 1, puis poussé et imprimé
• le 10001...0001nombre est calculé par , puis pousséX* 8 / 15 + 1
• la pile est ensuite vidée heightfois

Le trconvertit ensuite le 0s en espace.

Production

$ ./boxes.sh 2 4
11111111111111111
1   1   1   1   1
11111111111111111
1   1   1   1   1
11111111111111111
$ 

R, 83 81

En tant que fonction sans nom prenant h et w comme paramètres. Construit la 1ère et la deuxième lignes en un vecteur pour chaque ligne et le reproduit hfois. Ajoute un vecteur pour la ligne du bas et catsupprime le vecteur en utilisant fillpour restreindre la longueur des lignes. Profite désormais de la règle des caractères visibles.

function(h,w)cat(rep(c(A<-rep(1,w*4+2),rep('   1',w)),h),A[-1],fill=w*4+1,sep='')

Essai

> f=function(h,w)cat(rep(c(A<-rep(1,w*4+2),rep('   1',w)),h),A[-1],fill=w*4+1,sep='')
> f(4,2)
111111111
1   1   1
111111111
1   1   1
111111111
1   1   1
111111111
1   1   1
111111111
> 

Python 3 2, 160 87 85 79 octets

Je sais que cela peut être beaucoup plus joué au golf, je voudrais quelques suggestions car c'est mon premier essai de golf.

def d(x,y):
    for i in[1]*x:print'='*(4*y+1)+'\n'+'=   '*(y+1)
    print'='*(4*y+1)

Grâce aux astuces de @Cool Guy et @ Sp3000, j'ai réduit la taille juste au- dessous de la moitié.

Par exemple: d (3,3)

=============
=   =   =   =   
=============
=   =   =   =   
=============
=   =   =   =   
=============

Essayez-le ici .

Excusez les espaces blancs qui suivent.

KDB (Q), 37 octets

{(3+2*x-1)#(5+4*y-1)#'(4#"=";"=   ")}

Explication

                      (4#"=";"=   ")     / box shape
           (5+4*y-1)#'                   / extend y axis
 (3+2*x-1)#                              / extend x axis
{                                   }    / lambda

Tester

q){(3+2*x-1)#(5+4*y-1)#'(4#"=";"=   ")}[2;5]
"====================="
"=   =   =   =   =   ="
"====================="
"=   =   =   =   =   ="
"====================="

JavaScript, 92 85 octets

J'avais espéré que ce serait plus court que l'autre réponse JS (beau travail comme toujours, edc65), mais bon. J'ai le sentiment que les mathématiques ici peuvent être approfondies.

f=(r,c)=>(x=>{for(i=s='';(y=i++/x)<r-~r;)s+=i%x?' *'[-~y%2|!(-~i%4)]:'\n'})(4*c+2)||s

Octave, 69 65 64

y=ones([2,4].*input()+1);y(1:2:end,:)=y(:,1:4:end)=4;char(y+31)

Merci à DLosc d'avoir signalé les problèmes qui ont mené à -1

Prend les entrées [1 1]et les sorties:

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

Vous pouvez également simplement saisir «1» et obtenir 1x1. Si l'entrée doit vraiment l'être 1 1, la taille monte jusqu'à88 8584 :

y=ones([2,4].*eval(['[',input(0,'s'),']'])+1);y(1:2:end,:)=y(:,1:4:end)=4;char(y+31)

Remarque: Matlab ne permet pas le chaînage ou l'entrée d'Octave (entier), mais voici la version de Matlab ( 67 ):

y=ones([2,4].*input('')+1);y(1:2:end,:)=4;y(:,1:4:end)=4;char(y+31)

C, 76 octets

w,n;f(r,c){for(w=c*4+2,n=w*r*2+w;n--;)putchar(n%w?n/w%2&&n%w%4-1?32:61:10);}

Appelé en tant que fonction avec un nombre de lignes et de colonnes comme arguments. Par exemple:

f(5, 2)

CJam, 30 29 octets

Nouvelle version avec redondance +à la fin supprimée (merci, Dennis):

l~_4*)'=*N+:F\'=S3*+*'=+N++*F

Je sais que Dennis a déjà publié une solution CJam qui bat cela de plusieurs kilomètres. Mais c'est ma toute première tentative de CJam, c'est donc un miracle que cela fonctionne du tout. :)

Force assez brute. Construit la première ligne à partir de 4 * H + 1 =signes, puis la deuxième ligne à partir de fois =répétées H, avec une autre =ajoutée. Concatène ensuite les deux lignes, répète toutes les Vfois, puis ajoute une autre copie de la première ligne.

J'ai l'impression d'avoir trop de manipulations de pile, et j'ai même fini par stocker la première ligne dans une variable parce que je devais encore plus mélanger les choses sur la pile.

Pas très élégant dans l'ensemble, mais il faut commencer quelque part ... et je voulais d'abord essayer un problème simple.

CJam, 23

q~[F8]f{2b*1+' f+N}*_0=

Essayez-le en ligne

Explication:

q~        read and evaluate the input (height width)
[F8]      make an array [15 8] - 1111 and 1000 in base 2
f{…}      for width and each of [15 8]
  2b      convert the number to base 2
  *       repeat the digits "width" times
  1+      append a 1 to the array of digits (right edge)
  ' f+    add the space character to each digit (0->' ', 1->'!')
  N       push a newline
*         repeat the resulting array "height" times
_0=       copy the first line (bottom edge)

Dart, 57

b(y,x,{z:'='}){z+=z*4*x;print('$z\n=${'   ='*x}\n'*y+z);}

Essayez-le sur: https://dartpad.dartlang.org/36ed632613395303ef51

Java, 181

J'espère que selon

Vous êtes autorisé à écrire un programme complet ou une fonction.

il est conforme aux règles de compter les octets de la fonction , qui est 181 dans ce cas

import static java.lang.System.*;
public class Boxes
{
    public static void main(String[] args)
    {
        Boxes b=new Boxes();
        System.out.println("1,1:");
        b.b(1,1);
        System.out.println("1,2:");
        b.b(1,2);
        System.out.println("2,1:");
        b.b(2,1);
        System.out.println("2,2:");
        b.b(2,2);
        System.out.println("2,5:");
        b.b(2,5);
    }

    void b(int R, int C){String s="",e=s,x,y,z=s,a="====",n="=\n";int r,c;for(r=R;r-->0;){x=y=e;for(c=C;c-->0;){x+=a;y+="=   ";}s+=x+n+y+n;}for(c=C;c-->0;){z+=a;}s+=z+n;out.println(s);}
}

C #, 153 151 150

Cela ne peut pas vraiment rivaliser mais ici, c'est juste pour le plaisir:

(h,w)=>{string s="=",e="\n",a="====",b="   =",m=a,o;int i=0,j;for(;i++<=h*2;){o=s;for(j=0;j++<w+1;o=m)System.Console.Write(o);m=m==a?b:a;s=e+s;e="";}}

Comment exécuter:

public class Program
{
    public static void Main()
    {
        new System.Action<int, int>((h,w)=>{string s="=",e="\n",a="====",b="   =",m=a,o;int i=0,j;for(;i++<=h*2;){o=s;for(j=0;j++<w+1;o=m)System.Console.Write(o);m=m==a?b:a;s=e+s;e="";}})(3, 4);
    }
}

Ouvert aux améliorations.

Python 2.7, 66 octets.

Je sais qu'il existe déjà de meilleures solutions en python, mais c'est la meilleure que j'ai trouvée.

def f(x,y):a,b,c="="*4,"   =","\n=";print "="+a*y+(c+b*y+c+a*y)*x

Exemple:

f(3,4)

=================
=   =   =   =   =
=================
=   =   =   =   =
=================
=   =   =   =   =
=================

Rubis, 57 48 45

f=->h,w{l=?=*w*4+?=;(l+$/+'=   '*w+"=
")*h+l}

Usage:

print f[2,5]

Merci à manatwork pour avoir économisé 3 octets.

Java, 123 119 octets

void p(int h,int w){String b="=",d="\n=";for(;w-->0;d+="   =")b+="====";for(d+="\n"+b;h-->0;b+=d);System.out.print(b);}

L'utilisation abusive des paramètres d'entrée en tant que compteurs a grandement aidé à réduire la taille du code.

Merci à Cool Guy d'avoir suggéré l'abus de pour la syntaxe.

SAS, 117 119

macro a array a[0:1]$4('#   ' '####');do x=1 to 2+2*&x-1;t=repeat(a[mod(x,2)],&y-1);put t $char%%eval(&y*3). '#';end;%

Exemple:

%let x=4;
%let y=4;
data;a;run;

Résultat:

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