Prenez deux listes d'entiers non négatifs et sortez une boîte ASCII telle que définie ci-dessous.

• Les coins et les intersections sont des atouts: +(code ASCII 43)
• Les lignes verticales sont des barres |(code ASCII 124)
• Les lignes horizontales sont des inconvénients -(code ASCII 45)

La première liste d'entrée spécifie le nombre de points négatifs entre chaque signe plus, dans le sens horizontal.

La deuxième liste d'entrée spécifie le nombre de barres entre chaque signe plus, dans le sens vertical.

C'est plus facile à expliquer avec quelques exemples:

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

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

Précisions:

• L'ordre et le format d'entrée sont facultatifs
• Seules les cases doivent être imprimées / affichées, mais un espace de fin ou des retours à la ligne sont acceptés.
• Vous pouvez éventuellement ajouter 1 à toutes les valeurs d'entrée si cela est plus pratique. Le deuxième exemple serait alors: 2 3; 2 3.

C'est le golf de code, donc le code le plus court en octets gagne.

MATL , 25 22 21 octets

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

Utilise des entrées avec 1ajout (autorisé par le défi).

Essayez-le en ligne!

Explication

Le code crée initialement un tableau contenant 1pour la colonne des indices de caractères non-espace dans le résultat final, et 0autrement. Donc, si la première entrée est [2 1 4 1 3 1](serait [1 0 3 0 2 0]au format de base 0), ce tableau sera

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

Notez comment la longueur des exécutions de zéros est liée à l'entrée. Plus précisément, ce tableau est construit comme suit:

1. Initialisez le tableau en un seul 1.
2. Calculez la somme cumulée de l'entrée et ajoutez 1. Dans l'exemple, cela donne [3 4 8 9 12 13].
3. Étendez le tableau à partir de l'étape 1 en attribuant 1aux entrées avec des indices (basés sur 1) donnés à l'étape 2. Les entrées intermédiaires sont automatiquement définies sur 0.

Un tableau similaire est construit pour les lignes. La deuxième entrée [3 2 1 1](ou [2 1 0 0 ]) donne

1 0 0 1 0 1 1 1

Maintenant, le deuxième tableau est multiplié par 2, transposé et ajouté avec diffusion au premier. Cela donne le tableau 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'indexation dans la chaîne '|-+ 'donne le résultat final sous la forme d'un tableau de caractères 2D. L'indexation étant modulaire et basée sur 1, l'index 0correspond au dernier élément (espace).

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

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

Essayez-le sur ideone.

Ne pas trop en attendre. Vraiment simple, utilise simplement les jointures python et la multiplication de chaînes pour tout rassembler.

JavaScript (ES6), 83 octets

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

La sortie comprend deux nouvelles lignes de fin.

CJam, 50 octets

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

Essayez-le en ligne!

Pyth, 45 octets

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

Un programme qui prend en entrée deux listes séparées par des virgules sur STDIN et imprime le résultat.

Il y a probablement encore du golf à faire ici.

Essayez-le en ligne

Explication à venir plus tard

Haskell, 55 octets

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

Définit une fonction gqui prend les deux listes d'entrée et renvoie une liste contenant les lignes de la sortie

PowerShell v2 +, 89 octets

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

Dang, ne pense pas que je puisse tout à fait attraper JavaScript.

Prend des entrées $aet $bdes tableaux explicites. Définit variable $xcomme étant la ligne supérieure des cases en fonction de la boucle $aet de la concaténation de chaînes. C'est encapsulé en parens donc il est placé sur le pipeline. Ensuite, nous bouclons $b, chaque itération mettant deux chaînes sur le pipeline - la même chaîne de style mais avec des espaces et |au lieu de tirets et +, et $x. Ces chaînes sont toutes collectées à partir du pipeline avec un implicite Write-Outputà la fin du programme, avec une nouvelle ligne par défaut entre elles.

Exemples

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

Rubis, 66 octets

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

Gelée , 30 26 octets

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

Testez-le sur TryItOnline

Comment?

L'entrée prise est une liste des deux listes [vertical, horizontal], et utilise l'option incrémentée
- donc l'exemple 3 prend[[3,2,1,1], [2,1,4,1,3,1]]
Chacune d'entre elles est ensuite convertie en un tableau booléen indiquant respectivement le rowType ou le rowCharacterType, par exemple. [[1,0,0,1,0,1,1,1], [1,0,1,1,0,0,0,1,1,0,0,1,1]]
Les boîtes sont ensuite construites en créant les lignes à partir de les caractères identifiés par les combinaisons rowType et rowCharacterType - c'est-à-dire qu'un rowType identifie l'un "+-"ou l' autre "| "et un rowCharacterType identifie l'un de ces deux caractères.

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