Ihre Aufgabe ist es, Boxen mit einem beliebigen ASCII-Zeichen in Bezug auf die angegebenen Eingaben zu generieren.

Testfälle

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

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

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

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

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

Eingang

• Die Eingabe kann aus einer der folgenden Quellen erfolgen

  • stdin
  • Kommandozeilenargumente
  • Funktionsargumente (2 Argumente, eines für jede Zahl)

• Eingaben, die aus stdinoder Befehlszeilenargumenten stammen, enthalten zwei positive Ganzzahlen, die durch ein Leerzeichen getrennt sind.

• Die beiden Zahlen geben die Anzahl der Kästchen in jeder Spalte und Zeile an

Ausgabe

• Boxen müssen ausgegeben werden in stdout(oder gleichwertig)
• Jedes Kästchen sollte drei horizontale Felder enthalten

Regeln

• Beide Zahlen sind größer als 0, gehen jedoch nicht über 1000 hinaus
• Jedes sichtbare Zeichen kann zur Ausgabe der Kästchen verwendet werden. (Solange sie das Auge nicht zu hart treffen!)
• Sie dürfen ein vollständiges Programm oder eine Funktion schreiben.
• Es sollten keine unnötigen Zeichen außer einem optionalen nachgestellten Zeilenumbruchzeichen vorhanden sein.

Wertung

Dies ist Code-Golf , also gewinnt die kürzeste Übermittlung (in Bytes).

Pyth, 23 Bytes

Mjbmsm@"= "&%k4dh*4HhyG

Definiert die Funktion, gdie wie gewünscht funktioniert .

Demonstration.

Retina , 57 Bytes

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


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

Nimmt die Eingabe unärgerlich mit einer nachgestellten Newline auf.

Jede Zeile sollte in eine eigene Datei gehen und #in den Dateien in eine neue Zeile geändert werden. Dies ist unpraktisch, aber Sie können den Code so wie er ist als eine Datei mit dem -sFlag #ausführen , wobei die Markierungen erhalten bleiben (und die nachgestellte Zeile auch #in der Eingabe geändert wird). Sie können die #Zeilen in der Ausgabe zur besseren Lesbarkeit in Zeilenumbrüche ändern . Z.B:

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

Methode: 5 einzelne Substitutionsschritte. Die ersten beiden (ersten 4 Zeilen) erzeugen ein 2*N+1By- MGrid von Einsen und die nächsten 3 Schritte (6 Zeilen) formatieren es in die gewünschte Ausgabe.

Die Zwischenzeichenfolgen (durch -'s begrenzt):

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

JavaScript ( ES6 ), 83

Eine Funktion mit Parameterzeilen und -spalten. Unter Verwendung von Vorlagenzeichenfolgen gibt es 2 eingebettete Zeilenumbrüche, die signifikant sind und gezählt werden.

Ausgabe über alert(Popup). Wenn Sie alerteine proportionale Schriftart verwenden, erzielen Sie ein besseres Ergebnis, wenn Sie einen Buchstaben mit einer ähnlichen Breite wie das Leerzeichen anstelle von verwenden =.

Testen Sie in Firefox mit der Konsole, um die tatsächliche alertAusgabe zu erhalten, oder führen Sie das folgende Snippet aus.

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

Unter Verwendung zahlreicher repeatAufrufe wiederholen wir diese Schritte |, wiederholen sie dann |mit nachgestellten Leerzeichen und wiederholen beide Wiederholungen, um Zeilen zu erstellen:

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

(Zeilenumbrüche sind laut dem Vorschlag von edc65, Vorlagenzeichenfolgen zu verwenden, erheblich.)

Snippet:

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

Ohne Vorlagenzeichenfolgen, ohne Wiederverwendung von Methodennamen und mit zusätzlichen Leerzeichen:

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

(Verwenden Sie die Empfehlung von edc65 , um den |visuellen Abstand zu verbessern .)

Pip, 29 24 = 23 + 1 Bytes

Benötigt die -nFlagge. Nimmt die Höhe und Breite als Kommandozeilenargumente und baut Boxen mit 1s auf.

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

Erläuterung:

                         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)

Dieses Programm macht sich die Tatsache zunutze, dass Zeichenfolgen Zahlen und in Pip Zeichenfolgen sind. (Und die drei Felder in diesen Feldern waren genau richtig, um die eingebaute mVariable zu nutzen!)

So wird die Liste mit der Eingabe erstellt 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]

Und die endgültige Ausgabe:

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

Mehr zu Pip

Perl, 72 63 52 50 Bytes

Meine bisher kürzeste Version verwendet $/, um ein Newline-Zeichen kompakter zu erhalten:

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

Das vorherige Update fügt die meist leeren Zeilen in das Trennzeichen für Ausgabedatensätze ein $,und druckt eine Liste fortlaufender Zeilen.

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

Die vorherige Version könnte für den Gelegenheitsleser etwas klarer sein:

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

Die erste Version verwendet @ARGVanstelle von 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 Bytes

Ziemlich unkomplizierte Implementierung.

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

Schau es dir hier an.

Vielen Dank an Sp3000 für das Speichern eines Bytes.

GNU sed -r, 160

Seufz, ich dachte das wäre kleiner, aber hier ist es trotzdem. Leider haben sed reguläre Ausdrücke keine Suchfunktion.

:
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

Eingaben von STDIN als unärgern:

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

CJam, 25 Bytes

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

Probieren Sie es online im CJam-Interpreter aus .

Wie es funktioniert

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 Bytes

Diese Antwort funktioniert aufgrund der Einschränkungen der Sprache Marbelous nur bis zu 255x255, nicht bis zu 1000x1000. Ich arbeite an einer 32-Bit-Bibliothek, aber sie wird in Kürze nicht fertig sein.

Die Eingabe erfolgt als zwei Befehlszeilenparameter oder Funktionsparameter für die Hauptplatine.

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

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

Danke an Sp3000 für -5 Zeichen

Dank an Martin Büttner ♦ für weitere 5 Zeichen

Versuch es

c Funktion, 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);}

Testprogramm:

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 Bytes

Das ist so gut wie ich nur kann.

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

Dies setzt voraus, dass der Schlüssel Hdie Anzahl der Zeilen und Vdie Anzahl der Kästchen pro Zeile hat.

Ich benutze -und |nur damit die Kisten tatsächlich wie Kisten aussehen. Bei Bedarf kann ich es ändern =. Es spielt keine Rolle, welches Zeichen verwendet wird.
Verlassen -und |hilft auch, das Chaos zu verstehen, das gerade passiert.

Alte Methode, 76 Bytes:

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

Ausgabebeispiel:

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

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

Julia, 59 Bytes

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

Dadurch wird eine unbenannte Funktion erstellt, die zwei Ganzzahlen als Eingabe akzeptiert und das Ergebnis an STDOUT ausgibt. Um es zu nennen, geben Sie ihm einen Namen, z f=(n,m)->....

Ungolfed + Erklärung:

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

Beispiele:

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

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

Anregungen sind willkommen.

bash + coreutils, 57

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

Hiermit werden dcBinärzahlen gedruckt, die 1s für die Rahmenkanten und 0s für die Leerzeichen enthalten.

• Die Einzahl X wird mit berechnet 2 ^ (width * 4 + 1) - 1, dann gedrückt und gedruckt
• Die 10001...0001Zahl wird mit berechnet und dann gedrücktX* 8 / 15 + 1
• der stapel wird dann heightmal abgeladen

Das trkonvertiert dann die 0s in Leerzeichen.

Ausgabe

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

R 83 81

Als unbenannte Funktion mit h und w als Parametern. Bildet für jede Zeile die erste und die zweite Zeile zu einem Vektor und repliziert diesen hmal. Hängt einen Vektor an die unterste Zeile an und gibt catden Vektor mit aus fill, um die Länge der Zeilen zu begrenzen . Nutzt nun die Regel für alle sichtbaren Zeichen.

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

Testlauf

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

Ich weiß, dass man viel mehr Golf spielen kann. Ich hätte gerne einige Vorschläge, da dies mein erster Versuch ist, Golf zu spielen.

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

Dank der Tipps von @Cool Guy und @ Sp3000 konnte ich die Größe auf knapp über die Hälfte reduzieren .

ZB: d (3,3)

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

Probieren Sie es hier aus .

Entschuldigen Sie die nachgestellten Leerzeichen.

KDB (Q), 37 Bytes

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

Erläuterung

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

Prüfung

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

JavaScript, 92 85 Bytes

Ich hatte gehofft, dass dies kürzer sein würde als die andere Antwort von JS (gute Arbeit wie immer, edc65), aber na ja. Ich habe das Gefühl, dass die Mathematik hier weiter verbessert werden kann.

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

Oktave, 69 65 64

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

Vielen Dank an DLosc für den Hinweis auf Probleme, die zu -1 geführt haben

Nimmt Input als [1 1]und Outputs:

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

Sie können auch einfach '1' eingeben und 1x1 erhalten. Wenn der Eingang wirklich sein muss 1 1, steigt die Größe auf88 8584 :

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

Hinweis: Matlab erlaubt keine Octave-Verkettung oder Eingabe (Integer), aber hier ist die Matlab-Version ( 67 ):

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

C 76 Bytes

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

Wird als Funktion mit der Anzahl der Zeilen und Spalten als Argumente aufgerufen. Beispielsweise:

f(5, 2)

CJam, 30 29 Bytes

Neue Version mit redundanten +am Ende entfernt (danke, Dennis):

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

Ich weiß, dass Dennis bereits eine CJam-Lösung gepostet hat, die diese um ein Vielfaches übertrifft. Aber dies ist mein allererster Versuch bei CJam, es ist also ein Wunder, dass es überhaupt funktioniert. :)

Ziemlich rohe Gewalt. Bildet die erste Zeile aus 4 * H + 1 =Zeichen und die zweite Zeile aus =wiederholten Zeichen H, wobei eine weitere =hinzugefügt wird. Verkettet dann die zwei Zeilen, wiederholt das Ganze Vmal und fügt dann eine weitere Kopie der ersten Zeile hinzu.

Es fühlt sich so an, als hätte ich viel zu viele Stapelmanipulationen und habe sogar die erste Zeile in einer Variablen gespeichert, weil ich sonst noch mehr Zeug auf dem Stapel herum mischen musste.

Insgesamt nicht sehr elegant, aber man muss irgendwo anfangen ... und ich wollte zuerst ein einfaches Problem versuchen.

CJam, 23

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

Probieren Sie es online aus

Erläuterung:

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

Versuchen Sie es unter: https://dartpad.dartlang.org/36ed632613395303ef51

Java, 181

Ich hoffe das laut

Sie dürfen ein vollständiges Programm oder eine Funktion schreiben.

Es entspricht den Regeln, die Bytes der Funktion zu zählen , in diesem Fall also 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

Dies kann nicht wirklich konkurrieren, aber hier ist es nur zum Spaß:

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

Wie läuft man:

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

Offen für Verbesserungen.

Python 2.7, 66 Bytes.

Ich weiß, dass es in Python bereits bessere Lösungen gibt, aber das ist das Beste, was ich mir ausgedacht habe.

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

Beispiel:

f(3,4)

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

Rubin, 57 48 45

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

Verwendung:

print f[2,5]

Dank an manatwork für die Einsparung von 3 Bytes.

Java, 123 bis 119 Bytes

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

Der Missbrauch der Eingabeparameter als Zähler trug erheblich zur Verringerung der Codegröße bei.

Vielen Dank an Cool Guy für den Hinweis auf den Missbrauch der Syntax.

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

Beispiel:

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

Ergebnis:

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