# 绘制同心ASCII六边形

15

https://mothereff.in/byte-counter计数的最短程序（以字节为单位）获胜。

# 例子

（它们看起来更好，行距更少。）

`````` __
/  \
\__/
``````

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

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

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

# 附加规则

• 输入将始终是一组不同的正整数，不一定按任何顺序
• 输出必须...
• `/\ _`和换行符外，不包含任何字符。
• 没有尾随空格或不必要的前导空格。
• 不包含多余的前导换行符，但可以有一个可选的尾随换行符。
• 如果未输入任何内容，则不输出任何内容（可能只有一个换行符）。
• 如果有帮助，您可以假设输入整数小于2 16

`1`指最里面的六角形还是最外面的六角形？
NinjaBearMonkey

@hsl `1`（或任何数字）是指边长为1的六边形。（警告是1斜杠= 2下划线。）因此，`1`总是指最里面的六边形。

4

# CJam，148个116 109字节

``````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}/
``````

``````8 3 1 5 2
``````
``````        ________________
/                \
/                  \
/     __________     \
/     /          \     \
/     /   ______   \     \
/     /   / ____ \   \     \
/     /   / / __ \ \   \     \
/     /   / / /  \ \ \   \     \
\     \   \ \ \__/ / /   /     /
\     \   \ \____/ /   /     /
\     \   \______/   /     /
\     \            /     /
\     \__________/     /
\                    /
\                  /
\________________/
``````

## 说明：

``````"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.";
``````

5

# 蟒- 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()
``````

``````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()
``````

3

## APL（UTF-8中为222字节）

（和133个字符）

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

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

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

1

# Perl 5，352（349字节+ 3用于`anE`标志）

``@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}``

``````# 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
}``````

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

1

# C＃-388316字节

``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);}}}``

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

0

# APL（Dyalog Classic），151字节（使用经典APL编码为93）

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