Weź dwie listy nieujemnych liczb całkowitych i wyślij pole ASCII, jak zdefiniowano poniżej.

• Narożniki i skrzyżowania są plusami: +(kod ASCII 43)
• Pionowe linie to słupki |(kod ASCII 124)
• Poziome linie to minusy -(kod ASCII 45)

Pierwsza lista danych wejściowych określa liczbę minusów między każdym znakiem plus w kierunku poziomym.

Druga lista wejściowa określa liczbę słupków między każdym znakiem plus, w kierunku pionowym.

Łatwiej to wyjaśnić kilkoma przykładami:

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

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

Wyjaśnienia:

• Kolejność wprowadzania i format są opcjonalne
• Tylko pola powinny być drukowane / wyświetlane, ale spacja lub znaki nowej linii są akceptowane.
• Opcjonalnie możesz dodać 1 do wszystkich wartości wejściowych, jeśli jest to wygodniejsze. Drugim przykładem wówczas: 2 3; 2 3.

To jest kod golfowy, więc wygrywa najkrótszy kod w bajtach.

MATL , 25 22 21 bajtów

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

Wykorzystuje dane wejściowe z 1dodanymi (dozwolone przez wyzwanie).

Wypróbuj online!

Wyjaśnienie

Kod początkowo buduje tablicę zawierającą 1indeksy kolumn znaków spacji w wyniku końcowym i w 0przeciwnym razie. Więc jeśli pierwszym wejściem będzie [2 1 4 1 3 1](miałby [1 0 3 0 2 0]format 0), ta tablica będzie

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

Zwróć uwagę, jak długość przebiegów zer jest związana z danymi wejściowymi. W szczególności tablica ta jest zbudowana w następujący sposób:

1. Zainicjuj tablicę na jeden 1.
2. Oblicz skumulowaną sumę danych wejściowych i dodaj 1. W przykładzie daje to [3 4 8 9 12 13].
3. Rozszerz tablicę od kroku 1, przypisując 1do pozycji indeksy (oparte na 1) podane w kroku 2. Wpisy pośrednie są automatycznie ustawiane na 0.

Podobna tablica jest budowana dla wierszy. Drugie wejście [3 2 1 1](lub [2 1 0 0 ]) daje

1 0 0 1 0 1 1 1

Teraz druga tablica jest mnożona przez 2, transponowana i dodawana z emisją do pierwszej. To daje tablicę 2D

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

Indeksowanie w ciągu '|-+ 'daje końcowy wynik w postaci tablicy znaków 2D. Ponieważ indeksowanie jest modułowe i oparte na 1, indeks 0odpowiada ostatniemu elementowi (spacji).

'|-+ '                   % 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 bajtów

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

Wypróbuj na ideone.

Nie oczekuję po tym zbyt wiele. Naprawdę proste, po prostu używa sprzężeń Pythona i mnożenia ciągów, aby wszystko połączyć.

JavaScript (ES6), 83 bajty

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

Dane wyjściowe obejmują dwie końcowe znaki nowej linii.

CJam, 50 bajtów

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

Wypróbuj online!

Pyth, 45 bajtów

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

Program, który pobiera dane z dwóch oddzielonych przecinkami list na STDIN i drukuje wynik.

Prawdopodobnie jest tu jeszcze trochę golfa.

Wypróbuj online

Wyjaśnienie nastąpi później

Haskell, 55 bajtów

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

Definiuje funkcję, gktóra pobiera dwie listy danych wejściowych i zwraca listę zawierającą linie danych wyjściowych

PowerShell v2 +, 89 bajtów

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

Cholera, nie sądzę, że mogę całkiem złapać JavaScript.

Pobiera dane wejściowe $ai $bjako jawne tablice. Ustawia zmienną $xna górny rząd pól na podstawie zapętlania $ai konkatenacji ciągów. To jest zamknięte w parens, więc jest umieszczane na rurociągu. Następnie przechodzimy przez pętlę $b, a każda iteracja nakłada na ciąg dwa ciągi - ciąg tego samego stylu, ale ze spacjami i |zamiast łączników oraz +, i $x. Wszystkie te ciągi znaków są zbierane z potoku z domniemanym Write-Outputzakończeniem programu, z domyślną nową linią między nimi.

Przykłady

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

Rubin, 66 bajtów

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

Galaretka , 30 26 bajtów

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

Przetestuj w TryItOnline

W jaki sposób?

Pobrane dane wejściowe są listą dwóch list [vertical, horizontal]i wykorzystują opcję przyrostową
- więc przykład 3 bierze [[3,2,1,1], [2,1,4,1,3,1]]
Każda z nich jest następnie przekształcana w tablicę boolowską wskazującą odpowiednio rowType lub rowCharacterType, np [[1,0,0,1,0,1,1,1], [1,0,1,1,0,0,0,1,1,0,0,1,1]]
. Pola są następnie konstruowane przez utworzenie wierszy z znaki identyfikowane przez kombinacje rowType i rowCharacterType - tzn. rowType identyfikuje jeden "+-"lub "| "a rowCharacterType identyfikuje jeden z tych dwóch znaków.

Ḣị“+-“| ”ị@ - 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