Prendi due elenchi di numeri interi non negativi e genera una casella ASCII come definito di seguito.

• Gli angoli e le intersezioni sono vantaggi: +(codice ASCII 43)
• Le linee verticali sono barre |(codice ASCII 124)
• Le linee orizzontali sono dei punti negativi -(codice ASCII 45)

Il primo elenco di input specifica il numero di svantaggi tra ciascun segno più, in direzione orizzontale.

Il secondo elenco di input specifica il numero di barre tra ciascun segno più, in direzione verticale.

È più facile da spiegare con alcuni esempi:

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

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

chiarimenti:

• L'ordine e il formato di input sono facoltativi
• Solo le caselle devono essere stampate / visualizzate, ma sono accettati uno spazio finale o nuove righe.
• Se lo desideri, puoi aggiungere 1 a tutti i valori di input. Il secondo esempio sarebbe allora: 2 3; 2 3.

Questo è il codice golf, quindi vince il codice più breve in byte.

MATL , 25 22 21 byte

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

Utilizza input con 1aggiunto (consentito dalla sfida).

Provalo online!

Spiegazione

Il codice inizialmente crea un array contenente 1gli indici di colonna di caratteri non spaziali nel risultato finale e in caso 0contrario. Quindi, se il primo input è [2 1 4 1 3 1](sarebbe [1 0 3 0 2 0]nel formato basato su 0) questo array sarà

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

Nota come la lunghezza delle esecuzioni degli zeri è correlata all'input. In particolare, questo array è costruito come segue:

1. Inizializza l'array su un singolo 1.
2. Calcola la somma cumulativa dell'input e aggiungi 1. Nell'esempio questo dà [3 4 8 9 12 13].
3. Estendere l'array dal passaggio 1 assegnando 1alle voci con indici (basati su 1) forniti dal passaggio 2. Le voci intermedie vengono automaticamente impostate su 0.

Un array simile è stato creato per le righe. Secondo input [3 2 1 1](o [2 1 0 0 ]) dà

1 0 0 1 0 1 1 1

Ora il secondo array viene moltiplicato per 2, trasposto e aggiunto con trasmissione al primo. Questo dà l'array 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

L'indicizzazione nella stringa '|-+ 'fornisce il risultato finale come array di caratteri 2D. Poiché l'indicizzazione è modulare e basata su 1, l'indice 0corrisponde all'ultimo elemento (spazio).

'|-+ '                   % 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 byte

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

Provalo su ideone.

Non mi aspetto troppo da questo. Davvero semplice, usa solo i join Python e la moltiplicazione delle stringhe per riunire tutto.

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,`-+`)])

L'output include due nuove righe finali.

CJam, 50 byte

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

Provalo online!

Pyth, 45 byte

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

Un programma che accetta input di due elenchi separati da virgole su STDIN e stampa il risultato.

Probabilmente c'è ancora del golf da fare qui.

Provalo online

Spiegazione in arrivo

Haskell, 55 byte

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

Definisce una funzione gche accetta i due elenchi di input e restituisce un elenco contenente le righe dell'output

PowerShell v2 +, 89 byte

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

Dang, non credo di riuscire a catturare JavaScript.

Accetta input $ae $bcome matrici esplicite. Imposta la variabile $xcome la riga superiore delle caselle in base al looping $ae alla concatenazione di stringhe. È incapsulato in parentesi quindi posizionato sulla pipeline. Quindi, passiamo in rassegna $b, ogni iterazione mettendo due stringhe sulla pipeline - la stessa stringa di stile ma con spazi e |invece di trattini e +, e $x. Tali stringhe vengono tutte raccolte dalla pipeline con implicito Write-Outputal completamento del programma, con una nuova riga predefinita tra loro.

Esempi

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

Rubino, 66 byte

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

Jelly , 30 26 byte

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

Provalo a Provalo TryItOnline

Come?

L'input preso è un elenco dei due elenchi [vertical, horizontal]e utilizza l'opzione incrementata,
quindi l'esempio 3 prende [[3,2,1,1], [2,1,4,1,3,1]]
Ognuno di questi viene quindi convertito in un array booleano che indica rispettivamente rowType o rowCharacterType, ad es. [[1,0,0,1,0,1,1,1], [1,0,1,1,0,0,0,1,1,0,0,1,1]]
Le scatole vengono quindi costruite facendo le righe da i caratteri identificati dalle combinazioni rowType e rowCharacterType - ovvero un rowType identifica uno "+-"o "| "e un rowCharacterType identifica uno di quei due caratteri.

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