Take two lists of non-negative integers, and output an ASCII-box as it's defined below.
- Corners and intersections are pluses:
+(ASCII-code 43) - Vertical lines are bars
|(ASCII-code 124) - Horizontal lines are minuses
-(ASCII-code 45)
The first input list specifies the number of minuses between each plus sign, in the horizontal direction.
The second input list specifies the number of bars between each plus sign, in the vertical direction.
It's easier to explain with a few examples:
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
+-++---++--++
| || || ||
| || || ||
+-++---++--++
| || || ||
+-++---++--++
+-++---++--++
+-++---++--++
Clarifications:
- Input order and format are optional
- Only the boxes should be printed/displayed, but a trailing space or newlines are accepted.
- You may optionally add 1 to all input values if that's more convenient. The second example would then be:
2 3; 2 3.
This is code golf, so the shortest code in bytes win.
-
\$\begingroup\$ Related: codegolf.stackexchange.com/questions/70377/ascii-box-rendering \$\endgroup\$12Me21– 12Me212017年02月03日 21:03:58 +00:00Commented Feb 3, 2017 at 21:03
9 Answers 9
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
Not expecting too much from this. Really simple, just uses python joins and string multiplication to pull everything together.
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,`-+`)])
Output includes two trailing newlines.
-
\$\begingroup\$ Wow. So similar answers posted almost at the same time. ;) \$\endgroup\$Arnauld– Arnauld2016年09月18日 13:50:01 +00:00Commented Sep 18, 2016 at 13:50
-
\$\begingroup\$ (You beat me by 2 minutes and 2 bytes, though.) \$\endgroup\$Arnauld– Arnauld2016年09月18日 13:53:20 +00:00Commented Sep 18, 2016 at 13:53
-
\$\begingroup\$ @Arnauld You wasted time on your demo ;-) \$\endgroup\$Neil– Neil2016年09月18日 14:01:32 +00:00Commented Sep 18, 2016 at 14:01
-
\$\begingroup\$ Yeah, I guess so. ^^ Interestingly, my version would be 81 bytes with the two trailing newlines. \$\endgroup\$Arnauld– Arnauld2016年09月18日 14:07:58 +00:00Commented Sep 18, 2016 at 14:07
MATL, (削除) 25 (削除ここまで) (削除) 22 (削除ここまで) 21 bytes
'|-+ '2:"1tiYsQ(]E!+)
Uses inputs with 1 added (allowed by the challenge).
Explanation
The code initially builds an array containing 1 for the column indices of non-space characters in the final result, and 0 otherwise. So if the first input is [2 1 4 1 3 1] (would be [1 0 3 0 2 0] in the 0-based format) this array will be
1 0 1 1 0 0 0 1 1 0 0 1 1
Note how the length of runs of zeros is related to the input. Specifically, this array is built as follows:
- Initiallize the array to a single
1. - Compute the cumulative sum of the input and add
1. In the example this gives[3 4 8 9 12 13]. - Extend the array from step 1 by assigning
1to the entries with (1-based) indices given by step 2. Intermediate entries are automatically set to0.
A similar array is built for the rows. Second input [3 2 1 1] (or [2 1 0 0 ]) gives
1 0 0 1 0 1 1 1
Now the second array is multiplied by 2, transposed and added with broadcast to the first. This gives the 2D array
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
Indexing into the string '|-+ ' gives the final result as a 2D char array. Since indexing is modular and 1-based, index 0 corresponds to the last element (space).
'|-+ ' % 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
Pyth, 45 bytes
AQj.i*hlH]Js.i*hlG\+m*d\-G-mjb*d]XJ"+-""| "Hk
A program that takes input of two comma-separated lists on STDIN and prints the result.
There is probably still some golfing to be done here.
Explanation coming later
Haskell, 55 bytes
f[a,b]x=a:do n<-x;(b<$[1..n])++[a]
g x=f[f"+-"x,f"| "x]
Defines a function g which takes the two input lists and returns a list containing the lines of the output
PowerShell v2+, 89 bytes
param($a,$b)($x="+$(($a|%{'-'*$_})-join'+')+")
$b|%{,"|$(($a|%{' '*$_})-join'|')|"*$_;$x}
Dang, don't think I can quite catch JavaScript.
Takes input $a and $b as explicit arrays. Sets variable $x to be the top row of the boxes based on looping through $a and some string concatenation. That's encapsulated in parens so it's placed on the pipeline. Then, we loop through $b, each iteration putting two strings on the pipeline -- the same style string but with spaces and | instead of hyphens and +, and $x. Those strings are all gathered from the pipeline with an implicit Write-Output at program completion, with default newline between them.
Examples
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]}
Jelly, (削除) 30 (削除ここまで) 26 bytes
Ḣị"+-"| "ị@
1;+\Ṭ
Ç,ドル€/Ñ€Y
Test it at TryItOnline
How?
The input taken is a list of the two lists, [vertical, horizontal], and uses the incremented option
- so example 3 takes [[3,2,1,1], [2,1,4,1,3,1]]
Each of these is then converted to a boolean array indicating the rowType or rowCharacterType respectively, e.g. [[1,0,0,1,0,1,1,1], [1,0,1,1,0,0,0,1,1,0,0,1,1]]
The boxes are then constructed by making the rows from the characters identified by the rowType and rowCharacterType combinations - i.e. a rowType identifies either "+-" or "| " and a rowCharacterType identifies one of those two characters.
Ḣị"+-"| "ị@ - 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