# Draw Concentric ASCII Hexagons

Write the shortest program possible that takes in a set of distinct positive integers and outputs an ASCII rendering of concentric hexagons with those side lengths, made from slashes, underscores, spaces, and newlines.

The shortest program in bytes as counted by https://mothereff.in/byte-counter wins.

# Examples

(They look better with less line spacing.)

If the input is 1 the output should be the hexagon with side length 1:

 __
/  \
\__/


Notice that two underscores are used for the top and bottom of the hexagon so it is better proportioned.

In general, the size N hexagon contains N slashes on each angled side and 2*N underscores on on both the top and bottom.

If the input is 1 2 the output should be the concentric hexagons with side length 1 and 2:

  ____
/ __ \
/ /  \ \
\ \__/ /
\____/


If the input is 1 3 the output should be:

   ______
/      \
/   __   \
/   /  \   \
\   \__/   /
\        /
\______/


If the input is 1 3 2 the output should be:

   ______
/ ____ \
/ / __ \ \
/ / /  \ \ \
\ \ \__/ / /
\ \____/ /
\______/


etc.

# I/O Rules

Input must come from either the command line or stdin but may be in whatever format is most convenient.

For example, you might give each number as a command line argument: > myprogram 1 3 2, or you might prompt the user to input the numbers as a preformatted list: [1, 3, 2].

Output must go to stdout or your language's closest equivalent.

• The input will always be a set of distinct positive integers, not necessarily in any order.
• The output must...
• not contain any characters besides /\ _ and newlines.
• have no trailing spaces or unnecessary leading spaces.
• not contain extraneous leading newlines but may have one optional trailing newline.
• If nothing is input then output nothing (except possibly one newline).
• If it helps you may assume that the input integers are less than 216.
• Does the 1 refer to the innermost or outermost hexagon? – NinjaBearMonkey Sep 8 '14 at 1:28
• @hsl The 1 (or any number) refers to the hexagon with side length of 1. (With the caveat that 1 slash = 2 underscores.) So 1 will always refer to the innermost hexagon. – Calvin's Hobbies Sep 8 '14 at 1:32

# CJam, 148116 109 bytes

This took a lot longer than I expected. Originally, I just wanted to iteratively build the upper left quadrant, as in the diamond challenges, and then get the rest from mirroring. But I didn't notice that the underscores don't obey mirror symmetry between the upper and lower half. So I had to redo most of that, to generate the right half iteratively and then only mirror once (to the left).

S]2[l~]:(f#:+2bW%{_,2/~:T;{IT):T1<'\'/?S?S++}%__,2/=,2/I'_S?*_S+a@+\I'/S?S++a+}fI{)T)2*2$,-*1$W%"\/"_W%er@N}/


Test it here.

A Fibonacci-esque example:

8 3 1 5 2

        ________________
/                \
/                  \
/     __________     \
/     /          \     \
/     /   ______   \     \
/     /   / ____ \   \     \
/     /   / / __ \ \   \     \
/     /   / / /  \ \ \   \     \
\     \   \ \ \__/ / /   /     /
\     \   \ \____/ /   /     /
\     \   \______/   /     /
\     \            /     /
\     \__________/     /
\                    /
\                  /
\________________/


## Explanation:

As stated at the top, I start by building the right half iteratively. That is, initially I've got only a single space in the grid, and then for each possible ring, I either surround the existing grid in spaces or a new semi-hexagon.

Once that's done, I mirror each line to the left and pad it with leading spaces for correct alignment. Here is a breakdown of the code:

"Prepare the input and the grid:";
S]2[l~]:(f#:+2bW%
S]                "Push string with a space and wrap it in an array. This is the grid.";
2               "Push a 2 for future use.";
[l~]           "Read and evaluate the input, wrap it in an array.";
:(         "Decrement each number by 1.";
f#       "Map each number i to 2^i.";
:+     "Sum them all up.";
2b   "Get the base two representation.";
W% "Reverse the array.":
"At this point, the stack has the proto-grid at the bottom, and an array of 1s and
0s on top, which indicates for each hexagon if it's present or not.";

"Next is a for loop, which runs the block for each of those 0s and 1s, storing the
actual value in I. This block adds the next semi-hexagon or spaces.";
{ ... }fI

"First, append two characters to all existing lines:";
_,2/~:T;{IT):T1<'\'/?S?S++}%
_                            "Duplicate the previous grid.";
,2/                         "Get its length, integer-divide by 2.";
~:T;                     "Get the bitwise complement and store it in T. Discard it.";
{                 }% "Map this block onto each line of the grid.";
I                   "Push the current hexagon flag for future use.";
T):T               "Push T, increment, store the new value.";
1<'\'/?        "If T is less than 1, push \, else push /.";
S?      "If the current flag is 0, replace by a space.";
S++   "Append a space and add it to the current line.";

"So for hexagons this appends '\ ' to the top half and '/ ' to the bottom half.
For empty rings, it appends '  ' to all lines.";

"Now add a new line to the top and the bottom:"
__,2/=,2/I'_S?*_S+a@+\I'/S?S++a+
__                               "Get two copies of the grid.";
,2/                            "Get its length, integer-divide by 2.";
=                           "Get that line - this is always the middle line.";
,2/                        "Get ITS length, integer'divide by 2.";
I'_S?*                  "Get a string of that many _ or spaces depending on the
current flag.";
_S+               "Duplicate and a space.";
a@+            "Wrap in an array, pull up the grid, and prepend the line.";
\           "Swap with the other copy.";
I'/S?      "Choose between / and a space depending on the flag.";
S++   "Append a space, and add both characters to the line.";
a+ "Wrap in an array, and append line to the grid.";

"This is all. Rinse and repeat for all rings. The result will look something like this:

_____
\
___   \
__ \   \
_ \ \   \
\ \ \   \
_/ / /   /
__/ /   /
___/   /
/
_____/

Note that there are still trailing spaces.";

"Finish up all lines. These will not be joined together any more, but simply left
on the stack in pieces to printed out back-to-back at the end of the program.
The following runs the given block for each line:";
{ ... } /

"This generates the necessary indentation, then mirrors the lines and puts them
in the right order:"
)T)2*2$,-*\_W%"\/"_W%er\N ) "Slice off that trailing space, but leave it on the stack."; T "Remember T? That still has something like the the size of the grid from the last iteration. In fact it's N-1, where N is the largest visible hexagon. We can use that to figure out how many spaces we need."; )2* "Increment and double."; 2$                   "Copy the current line.";
,-                 "Subtract its length from 2*N.";
*                "Repeat the space that often. This is our indentation.";
\_              "Swap with the line and duplicate.";
W%            "Reverse the line.";
"\/"_W%er   "Replace slashes with backslashes and vice versa.";
\  "Swap with the original line.";
N "Push a line break.";


# Python - 251, 240, 239 228

l=input()+[0];m=max(l);A=abs;R=range
for j in R(2*m+1):print''.join([[' \\'[(A(j-i+m-1)/2.in l)*(2*m-i)/(j-m-.5)>1],'/'][(A(3*m-i-j)/2.in l)*(i-m-j+.5)/(j-.5-m)>0],'_'][(A(m-j)in l)*(A(2*m-i-.5)<A(m-j))]for i in R(4*m)).rstrip()


Alternative approach (251):

l=input()+[0]
l.sort()
m=max(l)
M=2*m
s=[[' ']*m*4for j in' '*(M+1)]
for i in l:
I=2*i;s[m-i][M-i:M+i]=s[m+i][M-i:M+i]='_'*I
for k in range(i):K=k+1;s[m-k][M-I+k]=s[m+K][M+I-K]='/';s[m-k][M+I-K]=s[m+K][M-I+k]='\\'
for t in s:print''.join(t).rstrip()


## APL (222 bytes in UTF-8)

(and 133 chars)

Since this question specifically asks for amount of bytes in UTF8 representation, I had to actually ungolf it a bit so that it is longer but its UTF8 representation is shorter. (In particular, the commute operator's character ⍨ is three bytes while () is only two, so that optimalisation doesn't work anymore, and it also makes assignment very expensive.)

{⎕←(~⌽∧\⌽⍵=' ')/⍵}¨↓⊃{⍵{⍺=' ':⍵⋄⍺}¨K↑(-.5×(K←⍴⍵)+⍴⍺)↑⍺}/{Z⍪⌽⊖Z←↑(⊂(⍵/' '),(2×⍵)/'-'),⍵{((-⍵)↑'/'),((2 4-.×⍵⍺)/' '),'\'}¨⌽⍳⍵}¨N[⍋N←,⎕]


Previous version, which is shorter in characters (124) but uses more bytes when represented in UTF-8 (230, which would put it in second place):

M←' '⋄{⎕←⍵/⍨~⌽∧\⌽⍵=M}¨↓⊃{⍵{⍺=M:⍵⋄⍺}¨K↑⍺↑⍨-.5×(K←⍴⍵)+⍴⍺}/{Z⍪⊖⌽Z←↑(⊂(⍵/M),'-'/⍨2×⍵),⍵{('/'↑⍨-⍵),'\',⍨M/⍨2 4-.×⍵⍺}¨⌽⍳⍵}¨N[⍋N←,⎕]


Test:

      {⎕←(~⌽∧\⌽⍵=' ')/⍵}¨↓⊃{⍵{⍺=' ':⍵⋄⍺}¨K↑(-.5×(K←⍴⍵)+⍴⍺)↑⍺}/{Z⍪⌽⊖Z←↑(⊂(⍵/' '),(2×⍵)/'-'),⍵{((-⍵)↑'/'),((2 4-.×⍵⍺)/' '),'\'}¨⌽⍳⍵}¨N[⍋N←,⎕]
⎕:
3 1 5 2
----------
/          \
/   ------   \
/   / ---- \   \
/   / / -- \ \   \
/   / / /  \ \ \   \
\   \ \ \  / / /   /
\   \ \ -- / /   /
\   \ ---- /   /
\   ------   /
\          /
----------

• This doesn't seem to meet the spec for top and bottom sides (they should be underscores, not hyphens) and consequently be offset by one line for the bottom sides. – Martin Ender Jan 27 '15 at 21:59

# Perl 5, 352 (349 bytes + 3 for anE flags)

This could probably be golfed down a lot more..

@b=sort{$a>$b}@F;map{$_<$j||($j=$_)}@b;$k=++$j;for(;$j--;){$z=$"x$j;for($e=$k;--$e>$j;){$z.=$e~~@b?'/ ':'  '} $z.=($j~~@b?'_':$")x(2*$j);$z.=$_~~@b?' \\':'  'for($j+1..$k-1);say$z}for(0..$k-2){$z=$"x$_;for($e=$k;--$e>$_;){$z.=($e-$k+1?$":'').($e~~@b?'\\':$")}$z.=(($_+1)~~@b?'_':$")x(2*$_+2);$z.=($_~~@b?'/':$").($_-$k+1?$":'')for($_+1..$k-1);say$z}


Ungolfed:

# sort list of side lengths
@b=sort{$a>$b}@F;
# set $k and$j to max side length + 1
map{$_<$j||($j=$_)}@b;$k=++$j;
for(;$j--;){$z=$"x$j;
for($e=$k;--$e>$j;){$z.=$e~~@b?'/ ':'  '}
$z.=($j~~@b?'_':$")x(2*$j);
$z.=$_~~@b?' \\':'  'for($j+1..$k-1);
say$z } for(0..$k-2){
$z=$"x$_; for($e=$k;--$e>$_;){$z.=($e-$k+1?$":'').($e~~@b?'\\':$")}$z.=(($_+1)~~@b?'_':$")x(2*$_+2);$z.=($_~~@b?'/':$").($_-$k+1?$":'')for($_+1..$k-1); say$z
}


Example (1 5 3 14):

              ____________________________
/                            \
/                              \
/                                \
/                                  \
/                                    \
/                                      \
/                                        \
/                                          \
/                 __________                 \
/                 /          \                 \
/                 /   ______   \                 \
/                 /   /      \   \                 \
/                 /   /   __   \   \                 \
/                 /   /   /  \   \   \                 \
\                 \   \   \__/   /   /                 /
\                 \   \        /   /                 /
\                 \   \______/   /                 /
\                 \            /                 /
\                 \__________/                 /
\                                            /
\                                          /
\                                        /
\                                      /
\                                    /
\                                  /
\                                /
\                              /
\____________________________/


# C# - 388 316 bytes

Edit: Changed how it avoids printing trailing spaces and threw in some LINQ

Simple program that takes command line arguments. It iterates through every possible char in each line of a rectangle defined by the maximum hexagon dimension and appends it to the current line, before trimming the lines and printing them successively (it produces the optional trailing new-line).

Golfed Code:

using System.Linq;class P{static void Main(string[]A){var I=A.Select(int.Parse);int m=I.Max(),i,j,y,x;for(j=m+1;j-->-m;){var r="";for(i=-2*m-1;++i<2*m-(y=j<0?-j-1:j);)r+="/\\_- "[(x=i<0?-i-1:i)>y&(x+=y)%2>0&x/2<m&&I.Contains(x/2+1)?(i^j)&1:x-y<(y=j<0?-j:j)&y<=m&I.Contains(y)?j<0?2:3:4];System.Console.WriteLine(r);}}}


Ungolfed code:

using System.Linq; // all important

class P
{
static void Main(string[]A)
{
var I=A.Select(int.Parse); // create int array

for(int m=I.Max(),j=m+1,i,y,x;j-->-m;) // for each line...
{
var r=""; // current line

for(i=-2*m-1;++i<2*m-(y=j<0?-j-1:j);) // for each char...
r+="/\\_- "[// append something to the current line
(x=i<0?-i-1:i)>y&(x+=y)%2>0&x/2<m&&I.Contains(x/2+1)?
(i^j)&1: // slashes as appropriate - I can't work out why this bit works, but it seems to
x-y<(y=j<0?-j:j)&y<=m&I.Contains(y)?
j<0?2:3: // _ or - if required
4]; // otherwise a space

System.Console.WriteLine(r); // print current line
}
}
}


# APL (Dyalog Classic), 151 bytes (93 with the classic APL encoding)

{a←0⍴⍨1 0+1 2×n←⌈/⍵⋄a[⊃,/i,¨¨⍵+⍵-1+i←⍳¨⍵]←1⋄a←(⊖⍪-)a⋄a[⊃,/(n+⍵,-⍵),¨¨,⍨i]←2⋄' /_\'[4|(⌽,-)a]}


Try it online!