Tome dos listas de enteros no negativos y envíe un cuadro ASCII como se define a continuación.

• Las esquinas y las intersecciones son ventajas: +(código ASCII 43)
• Las líneas verticales son barras |(código ASCII 124)
• Las líneas horizontales son menos -(código ASCII 45)

La primera lista de entrada especifica el número de desventajas entre cada signo más, en dirección horizontal.

La segunda lista de entrada especifica el número de barras entre cada signo más, en dirección vertical.

Es más fácil de explicar con algunos ejemplos:

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

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

Aclaraciones:

• El orden de entrada y el formato son opcionales
• Solo se deben imprimir / mostrar los cuadros, pero se acepta un espacio final o nuevas líneas.
• Opcionalmente, puede agregar 1 a todos los valores de entrada si es más conveniente. El segundo ejemplo sería entonces: 2 3; 2 3.

Este es el código de golf, por lo que gana el código más corto en bytes.

MATL , 25 22 21 bytes

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

Utiliza entradas con 1agregado (permitido por el desafío).

Pruébalo en línea!

Explicación

El código inicialmente construye una matriz que contiene 1los índices de columna de caracteres que no son espacios en el resultado final, y de lo 0contrario. Entonces, si la primera entrada es [2 1 4 1 3 1](estaría [1 0 3 0 2 0]en el formato basado en 0) esta matriz será

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

Observe cómo la longitud de las ejecuciones de ceros está relacionada con la entrada. Específicamente, esta matriz se construye de la siguiente manera:

1. Inicialice la matriz a una sola 1.
2. Calcule la suma acumulativa de la entrada y sume 1. En el ejemplo esto da [3 4 8 9 12 13].
3. Extienda la matriz del paso 1 asignándola 1a las entradas con índices (basados ​​en 1) dados en el paso 2. Las entradas intermedias se configuran automáticamente en 0.

Se crea una matriz similar para las filas. La segunda entrada [3 2 1 1](o [2 1 0 0 ]) da

1 0 0 1 0 1 1 1

Ahora la segunda matriz se multiplica 2, transpone y agrega con difusión a la primera. Esto le da a la 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

La indexación en la cadena '|-+ 'da el resultado final como una matriz de caracteres 2D. Como la indexación es modular y está basada en 1, el índice 0corresponde al último elemento (espacio).

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

Pruébalo con ideone.

No esperar demasiado de esto. Realmente simple, solo usa combinaciones de python y multiplicación de cadenas para unir todo.

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

La salida incluye dos nuevas líneas finales.

CJam, 50 bytes

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

Pruébalo en línea!

Pyth, 45 bytes

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

Un programa que toma la entrada de dos listas separadas por comas en STDIN e imprime el resultado.

Probablemente todavía hay algo de golf por hacer aquí.

Pruébalo en línea

Explicación después

Haskell, 55 bytes

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

Define una función gque toma las dos listas de entrada y devuelve una lista que contiene las líneas de la salida

PowerShell v2 +, 89 bytes

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

Dang, no creo que pueda atrapar JavaScript.

Toma entrada $ay $bcomo matrices explícitas. Establece que la variable $xsea ​​la fila superior de los cuadros según el bucle $ay alguna concatenación de cadenas. Eso está encapsulado en parens, por lo que se coloca en la tubería. Luego, recorremos $bcada iteración colocando dos cadenas en la tubería: la misma cadena de estilo pero con espacios y en |lugar de guiones y +, y $x. Todas esas cadenas se recopilan de la canalización con un implícito Write-Outputal finalizar el programa, con una nueva línea predeterminada entre ellas.

Ejemplos

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

Jalea , 30 26 bytes

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

Pruébelo en TryItOnline

¿Cómo?

La entrada tomada es una lista de las dos listas, [vertical, horizontal]y utiliza la opción incrementada
, por lo que el ejemplo 3 toma [[3,2,1,1], [2,1,4,1,3,1]]
Cada una de ellas se convierte en una matriz booleana que indica el tipo de fila o el Tipo de carácter de fila respectivamente, por ejemplo, los [[1,0,0,1,0,1,1,1], [1,0,1,1,0,0,0,1,1,0,0,1,1]]
cuadros se construyen haciendo las filas de los caracteres identificados por las combinaciones ROWTYPE y rowCharacterType - es decir, un ROWTYPE identifica cualquiera de "+-"o "| "y un rowCharacterType identifica uno de esos dos 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