Il tuo compito è generare caselle utilizzando qualsiasi carattere ASCII rispetto agli input dati.

Casi test

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

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

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

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

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

Ingresso

• L'input può essere preso da uno dei seguenti

  • stdin
  • Argomenti della riga di comando
  • Argomenti della funzione (2 argomenti, uno per ogni numero)

• L'input, se preso da stdino argomenti della riga di comando, conterrà due numeri interi positivi, separati da uno spazio.

• I due numeri indicano il numero di caselle in ciascuna colonna e riga

Produzione

• Le caselle devono essere emesse stdout(o equivalente più vicino)
• Ogni riquadro dovrebbe contenere tre spazi orizzontali

Regole

• Entrambi i numeri saranno maggiori di 0, ma non andranno oltre 1000
• Qualsiasi carattere visibile può essere utilizzato per l'output delle caselle. (purché non siano troppo duri alla vista!)
• È consentito scrivere un programma completo o una funzione.
• Non ci dovrebbero essere caratteri non necessari tranne un carattere di nuova riga finale facoltativo.

punteggio

Questo è code-golf , quindi vince l'invio più breve (in byte).

Pyth, 23 byte

Mjbmsm@"= "&%k4dh*4HhyG

Definisce la funzione gche funziona come desiderato.

Dimostrazione.

Retina , 57 byte

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


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

Riceve input in unario con una nuova riga finale.

Ogni riga dovrebbe andare nel proprio file e #dovrebbe essere cambiata in newline nei file. Ciò non è pratico, ma è possibile eseguire il codice come in un unico file con il -sflag, mantenendo i #marker (e modificando anche la newline finale #nell'input). #Se lo si desidera, è possibile modificare la schiena in newline nell'output per la leggibilità. Per esempio:

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

Metodo: 5 passaggi di sostituzione singoli. I primi due (prime 4 righe) crea un 2*N+1dalla Mgriglia di quelli e prossimi 3 fasi (6 linee) formattarlo in uscita desiderata.

Le stringhe intermedie (delimitate da -'s):

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

JavaScript ( ES6 ), 83

Una funzione con righe e colonne di parametri. Usando le stringhe di modello, ci sono 2 newline incorporate che sono significative e contate.

Uscita tramite alert(popup). Come alertuso un carattere proporzionale, otteniamo un risultato migliore utilizzando una lettera con una larghezza simile allo spazio anziché =.

Prova in Firefox utilizzando la console per ottenere l' alertoutput reale o esegui lo snippet di seguito.

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

Usando molte repeatchiamate, ripetiamo |, quindi ripetiamo |con spazi finali e ripetiamo entrambe le ripetizioni per creare righe:

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

(Le nuove righe sono significative, secondo il suggerimento di edc65 di utilizzare stringhe di modelli.)

Frammento:

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

Senza stringhe di modello, senza riutilizzo del metodo e con spazi bianchi aggiunti:

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

(Usando la raccomandazione di edc65 da usare |per una migliore spaziatura visiva.)

Pip, 29 24 = 23 + 1 byte

Richiede la -nbandiera. Prende l'altezza e la larghezza come argomenti della riga di comando e crea scatole di 1s.

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

Spiegazione:

                         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)

Questo programma sfrutta fortemente il fatto che le stringhe sono numeri e che i numeri sono stringhe in Pip. (E i tre spazi in quelle caselle erano proprio giusti per sfruttare la mvariabile integrata !)

Ecco come viene creato l'elenco con l'input 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]

E l'output finale:

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

Altro su Pip

Perl, 72 63 52 50 byte

La mia versione più corta utilizza ancora $/per ottenere un carattere newline in modo più compatto:

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

L'aggiornamento precedente inserisce le righe per lo più vuote nel separatore del record di output $,e stampa un elenco di righe continue.

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

La versione precedente potrebbe essere un po 'più chiara per il lettore occasionale:

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

La prima versione utilizzata al @ARGVposto di 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 byte

Implementazione abbastanza semplice.

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

Controllalo qui.

Grazie a Sp3000 per aver salvato un byte.

GNU sed -r, 160

Sospiro, pensavo che sarebbe stato più piccolo, ma eccolo qui. Sfortunatamente le regex sed non hanno alcuna capacità di ricerca.

:
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

Prendendo input come unario da STDIN:

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

CJam, 25 byte

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

Provalo online nell'interprete CJam .

Come funziona

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 byte

Questa risposta funziona solo fino a 255x255, non 1000x1000, a causa delle limitazioni del linguaggio Marbelous. Sto lavorando su una libreria a 32 bit, ma presto non sarà pronta.

L'input viene fornito come due parametri della riga di comando o parametri di funzione alla scheda 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

pseudocodice:

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 byte

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

Grazie a Sp3000 per -5 caratteri

Grazie a Martin Büttner ♦ per altri 5 caratteri

Provalo

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

Programma di 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 byte

Questo è il massimo del golf.

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

Questo si aspetta che la chiave Habbia il numero di righe e Vil numero di caselle per riga.

Sto usando -e |solo così le scatole sembrano scatole. Se necessario, posso cambiarlo in =. Non importa il carattere che viene utilizzato.
Lasciare -e |aiuta anche a capire il casino che sta succedendo.

Vecchio metodo, 76 byte:

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

Esempio di output:

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

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

Julia, 59 byte

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

Ciò crea una funzione senza nome che accetta due numeri interi come input e stampa il risultato su STDOUT. Per chiamarlo, dagli un nome, ad es f=(n,m)->....

Ungolfed + spiegazione:

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

Esempi:

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

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

Eventuali suggerimenti sono ben accetti

bash + coreutils, 57

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

Questo utilizza dcper stampare numeri binari che hanno 1s per i bordi della scatola e 0s per gli spazi.

• il numero uno X è calcolato da 2 ^ (width * 4 + 1) - 1, quindi spinto e stampato
• il 10001...0001numero viene calcolato da , quindi premutoX* 8 / 15 + 1
• lo stack viene quindi scaricato heightvolte

L' trpoi converte i 0s a caratteri di spazio.

Produzione

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

R, 83 81

Come una funzione senza nome prendendo h e w come parametri. Costruisce la prima e la seconda linea in un vettore per ogni riga e la replica hvolte. Aggiunge un vettore per la linea di fondo ed catelimina il vettore usando fillper limitare la lunghezza delle linee. Ora sfrutta qualsiasi regola del personaggio visibile.

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

Prova

> 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 byte

So che si può giocare a golf molto di più, vorrei alcuni suggerimenti in quanto questo è il mio primo tentativo di giocare a golf.

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

Grazie ai suggerimenti di @Cool Guy e @ Sp3000, ho ridotto le dimensioni appena sopra metà.

Ad esempio: d (3,3)

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

Provalo qui .

Scusa gli spazi bianchi finali.

KDB (Q), 37 byte

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

Spiegazione

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

Test

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

JavaScript, 92 85 byte

Speravo che questo fosse più breve dell'altra risposta JS (bel lavoro come sempre, edc65), ma vabbè. Ho la sensazione che la matematica qui possa essere ulteriormente giocata a golf.

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

Ottava, 69 65 64

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

Grazie a DLosc per aver segnalato i problemi che hanno portato a -1

Accetta input [1 1]e output:

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

Puoi anche inserire '1' e ottenere 1x1. Se l'input deve davvero essere 1 1, la dimensione aumenta88 8584 :

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

Nota: Matlab non consente il concatenamento o l'input di Octave (numero intero), ma ecco la versione di Matlab ( 67 ):

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

C, 76 byte

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

Richiamato come funzione con il numero di righe e colonne come argomenti. Per esempio:

f(5, 2)

CJam, 30 29 byte

Nuova versione con ridondante +alla fine rimosso (grazie, Dennis):

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

So che Dennis ha già pubblicato una soluzione CJam che la batte da miglia. Ma questo è il mio primo tentativo in CJam, quindi è un miracolo che funzioni affatto. :)

Forza abbastanza bruta. Costruisce la prima riga dai 4 * H + 1 =segni, quindi la seconda riga da tempi =ripetuti H, con un'altra =aggiunta. Quindi concatena le due righe, ripete l'intera cosa Vvolte e quindi aggiunge un'altra copia della prima riga.

Mi sento come se avessi troppe manipolazioni dello stack e ho persino finito per memorizzare la prima riga in una variabile perché ho dovuto mescolare le cose nello stack ancora di più.

Nel complesso non molto elegante, ma devi iniziare da qualche parte ... e prima volevo provare un semplice problema.

CJam, 23

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

Provalo online

Spiegazione:

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)

Dardo, 57

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

Provalo su: https://dartpad.dartlang.org/36ed632613395303ef51

Java, 181

Spero che secondo

È consentito scrivere un programma completo o una funzione.

è conforme alle regole per contare i byte della funzione , che in questo caso è 181

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

Questo non può davvero competere ma qui è solo per divertimento:

(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="";}}

Come eseguire:

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

Aperto per miglioramenti.

Python 2.7, 66 byte.

So che ci sono già soluzioni migliori in Python, ma è la migliore che mi è venuta in mente.

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

Esempio:

f(3,4)

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

Ruby, 57 48 45

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

Uso:

print f[2,5]

Grazie a manatwork per il salvataggio di 3 byte.

Java, 123 119 byte

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

Abusare dei parametri di input come contatori ha contribuito notevolmente a ridurre le dimensioni del codice.

Grazie a Cool Guy per aver suggerito l'abuso di sintassi.

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

Esempio:

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

Risultato:

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