Nehmen Sie zwei Listen nicht-negativer Ganzzahlen und geben Sie eine ASCII-Box wie unten definiert aus.

• Ecken und Schnittpunkte sind Pluspunkte: +(ASCII-Code 43)
• Vertikale Linien sind Striche |(ASCII-Code 124)
• Horizontale Linien sind Minuspunkte -(ASCII-Code 45)

Die erste Eingabeliste gibt die Anzahl der Minuspunkte zwischen den einzelnen Pluszeichen in horizontaler Richtung an.

Die zweite Eingabeliste gibt die Anzahl der Striche zwischen den einzelnen Pluszeichen in vertikaler Richtung an.

Es ist einfacher, mit ein paar Beispielen zu erklären:

0    // No minuses between each + sign
0    // No bars between + signs

++
++

------------------
1 2   // First a single minus, then two minuses 
1 2   // First  one bar, then two bars

+-+--+
| |  |
+-+--+
| |  |
| |  |
+-+--+


------------------
1 0 3 0 2 0
2 1 0 0

+-++---++--++
| ||   ||  ||
| ||   ||  ||
+-++---++--++
| ||   ||  ||
+-++---++--++
+-++---++--++
+-++---++--++

Klarstellungen:

• Eingabereihenfolge und Format sind optional
• Es sollten nur die Felder gedruckt / angezeigt werden, ein Leerzeichen oder Zeilenumbrüche werden jedoch akzeptiert.
• Sie können optional 1 zu allen Eingabewerten hinzufügen, wenn dies praktischer ist. Das zweite Beispiel wäre dann: 2 3; 2 3.

Das ist Code Golf, also gewinnt der kürzeste Code in Bytes.

MATL , 25 22 21 Bytes

'|-+ '2:"1tiYsQ(]E!+)

Verwendet Eingaben mit 1zusätzlichen (von der Herausforderung zugelassenen).

Probieren Sie es online!

Erläuterung

Der Code erstellt zunächst ein Array mit 1den Spaltenindizes für Nicht-Leerzeichen im Endergebnis 0. Wenn also die erste Eingabe im 0-basierten Format ist [2 1 4 1 3 1](wäre [1 0 3 0 2 0]), ist dies ein Array

1 0 1 1 0 0 0 1 1 0 0 1 1

Beachten Sie, wie die Länge der Nulldurchläufe mit der Eingabe zusammenhängt. Insbesondere ist dieses Array wie folgt aufgebaut:

1. Initialisieren Sie das Array zu einem einzelnen 1.
2. Berechnen Sie die kumulative Summe der Eingabe und addieren Sie 1. Im Beispiel gibt dies [3 4 8 9 12 13].
3. Erweitern Sie das Array von Schritt 1 durch Zuweisen 1zu den Einträgen mit (1-basierten) Indizes, die in Schritt 2 angegeben sind. Zwischeneinträge werden automatisch auf festgelegt 0.

Ein ähnliches Array wird für die Zeilen erstellt. Zweiter Eingang [3 2 1 1](oder [2 1 0 0 ]) gibt

1 0 0 1 0 1 1 1

Nun wird das zweite Array mit multipliziert 2, transponiert und mit Broadcast zum ersten hinzugefügt. Dies ergibt das 2D-Array

3 2 3 3 2 2 2 3 3 2 2 3 3
1 0 1 1 0 0 0 1 1 0 0 1 1
1 0 1 1 0 0 0 1 1 0 0 1 1
3 2 3 3 2 2 2 3 3 2 2 3 3
1 0 1 1 0 0 0 1 1 0 0 1 1
3 2 3 3 2 2 2 3 3 2 2 3 3
3 2 3 3 2 2 2 3 3 2 2 3 3
3 2 3 3 2 2 2 3 3 2 2 3 3

Indizieren in den String '|-+ 'ergibt das Endergebnis als 2D-Zeichen-Array. Da die Indizierung modular und 1-basiert ist, 0entspricht der Index dem letzten Element (Leerzeichen).

'|-+ '                   % Push this string
      2:"       ]        % Do this twice
         1               % Push 1 (initial array)
          t              % Push another 1 (contents to be filled in)
           i             % Take input
            Ys           % Cumulative sum
              Q          % Add 1
               (         % Fill 1 into those entries of the array
                 E       % Multiply by 2
                  !      % Transpose
                   +     % Add, with broadcast
                    )    % Index (modular, 1-based) into the string

Python 2, 117 Bytes

def f(h,v):r="+"+"+".join("-"*i for i in h)+"+\n";print r+r.join(("|"+"|".join(" "*i for i in h)+"|\n")*i for i in v)+r

Probiere es auf ideone aus.

Ich erwarte nicht zu viel davon. Ganz einfach: Verwenden Sie einfach Python-Joins und String-Multiplikation, um alles zusammenzuführen.

JavaScript (ES6), 83 Byte

(a,b,g=(a,[s,t])=>t+a.map(n=>s.repeat(n)+t).join``+`
`)=>g(b,[g(a,` |`),g(a,`-+`)])

Die Ausgabe enthält zwei nachgestellte Zeilenumbrüche.

CJam, 50 Bytes

0lS/:i0++:H;lS/:i0+{H{'-*}%'+*N+o{H{S*}%'|*N+o}*}%

Probieren Sie es online!

Pyth, 45 Bytes

AQj.i*hlH]Js.i*hlG\+m*d\-G-mjb*d]XJ"+-""| "Hk

Ein Programm, das zwei durch Kommas getrennte Listen in STDIN eingibt und das Ergebnis ausgibt.

Hier gibt es wahrscheinlich noch einiges zu golfen.

Probieren Sie es online aus

Erklärung kommt später

Haskell, 55 Bytes

f[a,b]x=a:do n<-x;(b<$[1..n])++[a]
g x=f[f"+-"x,f"| "x]

Definiert eine Funktion, gdie die beiden Eingabelisten aufnimmt und eine Liste mit den Zeilen der Ausgabe zurückgibt

PowerShell v2 +, 89 Byte

param($a,$b)($x="+$(($a|%{'-'*$_})-join'+')+")
$b|%{,"|$(($a|%{' '*$_})-join'|')|"*$_;$x}

Verdammt, ich glaube nicht, dass ich JavaScript richtig einfangen kann.

Übernimmt Eingaben $aund $bals explizite Arrays. Setzt die Variable $xauf die oberste Zeile der Felder, basierend auf dem Durchschleifen $aund einer gewissen Verkettung von Zeichenfolgen. Das ist in Parens eingekapselt, damit es in der Pipeline platziert wird. Dann durchlaufen wir eine Schleife $b, wobei jede Iteration zwei Zeichenfolgen in die Pipeline einfügt - dieselbe Zeichenfolge mit Leerzeichen und |anstelle von Bindestrichen und +und $x. Diese Zeichenfolgen werden alle mit einem impliziten Write-OutputZeilenumbruch bei Programmabschluss aus der Pipeline abgerufen.

Beispiele

PS C:\Tools\Scripts\golfing> .\make-some-ascii-boxes.ps1 @(0) @(0)
++
++

PS C:\Tools\Scripts\golfing> .\make-some-ascii-boxes.ps1 @(1,0,3,0,2,0) @(2,1,0,0)
+-++---++--++
| ||   ||  ||
| ||   ||  ||
+-++---++--++
| ||   ||  ||
+-++---++--++
+-++---++--++
+-++---++--++

PS C:\Tools\Scripts\golfing> .\make-some-ascii-boxes.ps1 @(1,4,1) @(1,2,1)
+-+----+-+
| |    | |
+-+----+-+
| |    | |
| |    | |
+-+----+-+
| |    | |
+-+----+-+

Ruby, 66 Bytes

->x,y{d=->c,m,z=x{c+z.map{|w|m*w}*c+c+$/}
d[d[?+,?-],d[?|,' '],y]}

Gelee , 30 26 Bytes

Ḣị“+-“| ”ị@
1;+\Ṭ
Ç€,€/Ñ€Y

Testen Sie es bei TryItOnline

Wie?

Die Eingabe ist eine Liste der beiden Listen [vertical, horizontal]und verwendet die inkrementierte Option.
Beispiel 3 Takes [[3,2,1,1], [2,1,4,1,3,1]]
Jedes von diesen wird dann in ein boolesches Array konvertiert, das den rowType bzw. rowCharacterType angibt. [[1,0,0,1,0,1,1,1], [1,0,1,1,0,0,0,1,1,0,0,1,1]]
Die Boxen werden dann konstruiert, indem die Zeilen aus erstellt werden Die durch die Kombinationen rowType und rowCharacterType identifizierten Zeichen - dh ein rowType identifiziert entweder "+-"oder "| "und ein rowCharacterType identifiziert eines dieser beiden Zeichen.

Ḣị“+-“| ”ị@ - Link 1, create a row: [rowType, [rowCharaterTypes]]
Ḣ           - head - get the rowType
  “+-“| ”   - list of strings ["+-", "| "]
 ị          - index into (if rowType is 1 "+-"; if rowType is 0 "| ")
         ị@ - index into with reversed operands (index into that from rowCharaterTypes)
                (replace each 1 in rowCharaters with "+" or "|" and each 0 with "-" or " ")

1;+\Ṭ - Link 2, create the Type lists from the inputs: int[] nCharacters
1;    - 1 concatenated with the input
  +\  - reduce with addition (accumulation provides the indices)
    Ṭ - boolean array with 1s at those indices
            As an example take the vertical of example 3:
            [3,2,1,1] -> [1,3,2,1,1] -> [1,4,6,7,8] -> [1,0,0,1,0,1,1,1]
            each of which will be passed as a rowType for Link 1

Ç€,€/Ñ€Y - Main link, takes one argument: [Vertical, Horizontal] (incremented option)
Ç€       - call the last link (2) for each of the two lists in the input
  ,€/    - pair each and reduce (making a list of [rowtype [rowCharacterTypes]])
     р  - call the next link (1) for each
       Y - join on line feeds