Pegue duas listas de números inteiros não negativos e produza uma caixa ASCII, conforme definido abaixo.

• Cantos e interseções são vantagens: +(código ASCII 43)
• Linhas verticais são barras |(código ASCII 124)
• Linhas horizontais são desvantagens -(código ASCII 45)

A primeira lista de entrada especifica o número de menos entre cada sinal de mais, na direção horizontal.

A segunda lista de entrada especifica o número de barras entre cada sinal de mais, na direção vertical.

É mais fácil explicar com alguns exemplos:

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

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

Esclarecimentos:

• A ordem e o formato da entrada são opcionais
• Somente as caixas devem ser impressas / exibidas, mas um espaço à direita ou novas linhas são aceitas.
• Opcionalmente, você pode adicionar 1 a todos os valores de entrada, se for mais conveniente. O segundo exemplo seria o seguinte: 2 3; 2 3.

Este é o código golf, portanto o código mais curto em bytes vence.

MATL , 25 22 21 bytes

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

Usa entradas 1adicionadas (permitidas pelo desafio).

Experimente online!

Explicação

O código inicialmente cria uma matriz que contém 1os índices da coluna de caracteres não espaciais no resultado final, e 0caso contrário. Portanto, se a primeira entrada for [2 1 4 1 3 1](seria [1 0 3 0 2 0]no formato 0), essa matriz será

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

Observe como o comprimento das execuções de zeros está relacionado à entrada. Especificamente, essa matriz é criada da seguinte maneira:

1. Inicialize a matriz em um único 1.
2. Calcule a soma cumulativa da entrada e adicione 1. No exemplo, isso dá [3 4 8 9 12 13].
3. Estenda a matriz da etapa 1 atribuindo 1às entradas os índices (com base em 1) fornecidos na etapa 2. As entradas intermediárias são definidas automaticamente como 0.

Uma matriz semelhante é criada para as linhas. A segunda entrada [3 2 1 1](ou [2 1 0 0 ]) fornece

1 0 0 1 0 1 1 1

Agora, o segundo array é multiplicado 2, transposto e adicionado com transmissão ao primeiro. Isso fornece à matriz 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

A indexação na string '|-+ 'fornece o resultado final como uma matriz de caracteres 2D. Como a indexação é modular e baseada em 1, o índice 0corresponde ao último elemento (espaço).

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

Experimente em ideone.

Não esperando muito com isso. Realmente simples, apenas usa junções python e multiplicação de strings para reunir tudo.

JavaScript (ES6), 83 bytes

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

A saída inclui duas novas linhas finais.

CJam, 50 bytes

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

Experimente online!

Pitão, 45 bytes

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

Um programa que recebe entrada de duas listas separadas por vírgula no STDIN e imprime o resultado.

Provavelmente ainda há golfe a ser feito aqui.

Experimente online

Explicação que vem depois

Haskell, 55 bytes

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

Define uma função gque pega as duas listas de entrada e retorna uma lista contendo as linhas da saída

PowerShell v2 +, 89 bytes

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

Caramba, acho que não consigo pegar JavaScript.

Recebe entrada $ae $bcomo matrizes explícitas. Define a variável $xcomo a linha superior das caixas com base no looping $ae em alguma concatenação de strings. Isso é encapsulado em parênteses, para ser colocado no pipeline. Então, percorremos $b, cada iteração colocando duas strings no pipeline - a mesma string de estilo, mas com espaços e, em |vez de hífens +, e, e $x. Essas seqüências são todas reunidas do pipeline com um implícito Write-Outputna conclusão do programa, com uma nova linha padrão entre elas.

Exemplos

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

Geléia , 30 26 bytes

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

Teste em TryItOnline

Quão?

A entrada obtida é uma lista das duas listas, [vertical, horizontal]e usa a opção incrementada
- portanto, o exemplo 3 leva. [[3,2,1,1], [2,1,4,1,3,1]]
Cada uma delas é então convertida em uma matriz booleana indicando respectivamente o rowType ou rowCharacterType, por exemplo, [[1,0,0,1,0,1,1,1], [1,0,1,1,0,0,0,1,1,0,0,1,1]]
as caixas são construídas criando as linhas de os caracteres identificados pelas combinações rowType e rowCharacterType - ou seja, um rowType identifica um "+-"ou "| "e um rowCharacterType identifica um desses dois caracteres.

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