# Embedded Hexagons!

Your task: given an integer n, generate an embedded hexagon pattern following the below rules, to the nth depth.

An embedded hexagon has the basic shape of this: (n=0)

 __
/  \
\__/


Embedded Hexagons n=1 and n=2:

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

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


The length of each side is 2 times the length of the same side in the previous depth times two. The top and bottom sides are 2 characters long when n=0 and the rest start out as 1 character long. The non top-bottom side lengths should be 2^n long (OEIS: A000079) and the top and bottom sides should follow the rule 2^(n+1) (same OEIS).

The current hexagons are 0-indexed, you may chose to use 1-indexed if you want.

This is , so the shortest answer wins!

• @LuisMendo Okay, I'll change the name. – Comrade SparklePony Apr 7 '17 at 14:10
• It might be hard to handle big input (ex. 64). Is there a limit to n? – Matthew Roh Apr 7 '17 at 15:33
• @SIGSEGV There is no limit to n. – Comrade SparklePony Apr 7 '17 at 16:12
• Would be amused to see an answer in Hexagony :)) – Mr. Xcoder Apr 7 '17 at 18:23
• Heh, the turtle graphics of my Koch curve submission can do this too (only first function changed). Definitely too long for this, though :) – Ørjan Johansen Apr 7 '17 at 18:25

# Charcoal, 40 29 bytes

11 bytes saved thanks to @Neil by changing the while loop to a for-loop amongst other tricks

ＦＮ«ＡＸ²ιβ×__β↓↘β←↙β↑←×__β↖β→↗β


Try it online!

### Explanation (outdated)

This program starts with generating the largest hexagon, and then does the smaller ones one-by-one in a while loop (1-indexed). For reference, α is the input number, β is the variable that contains 2^(α-1) and ι is the iterating variable in the loop.

Ｎα                        # Take input and store in α
Ｗα«                       # While α do:
×_Ｘ²ι                    #  Write "_"*(2**ι); this forms the top edge of the hexagon
↓                         #  Go down
ＡＸ²⁻ι¹β                 #  Assign 2**(ι-1) to β
↘β←                       #  Write \ β times in a SE direction (top right edge) and then go left
↙β↑                       #  Write / β times in a SW direction (bottom right edge) and then go up
←×_Ｘ²ι                   #  Write the bottom edge
↖β→↗β                    #  Just like before, write the top and bottom left edges
Ａ⁻α¹α                    #  Decrement α
# Now the pointer is at the top left corner of the hexagon,
# from where the other smaller hexagons will soon be generated

• I noticed there's no "Hello, World!" program for Charcoal yet. You should add it. – mbomb007 Apr 7 '17 at 21:09
• @mbomb007 Wouldn't that just be a duplicate of the trivial "this language prints its source file if it contains no commands" answer? – Neil May 25 '17 at 20:58
• I saved some bytes when I realised that ×_Ｘ²ι is the same as ×__β, and some more bytes by converting your Ｗ into a Ｆ, which also avoids having to store the input number. Try it online!. – Neil May 25 '17 at 21:12
• @Neil Thanks, that is pretty neat :) – Cows quack May 26 '17 at 6:20

# Haskell, 230217 207 bytes

EDIT:

• -13 bytes: @xnor saw that my # could be just max.
• -10 bytes: And also that zipWith and p could be merged into a ? operator, and that I'd (somehow!) reimplemented replicate.

m takes an Integer and returns a String.

m n=unlines.foldr1 o$((2^n)&).(2^)<$>[0..n]
+s.replace(/ /g,"$'/$'$'$$$$\$'\n")).replace(/ /g,(c,i)=>p[i+(1<<n>>1)])+s.replace(/ /g,"\$$  $'$'$'$'/$\n").replace(/ +\/( *)\n$/,t+/$1 ) <input type=number min=0 oninput=o.textContent=f(+this.value)><pre id=o> Explanation: For hexagons after the first, the previous hexagon is first generated and padded on each side (this relies on the output being a rectangle). (For the first heading, some dummy padding is created.) The top and top sides of the hexagon are generated, and all the spaces merged with the previous hexagon. (There's some trickery in order to get the hexagons to line up; this would be easier if extra margins were allowed.) The bottom sides of the hexagon are generated analogously to the top sides, and the bottom of the hexagon is then filled in. Care has to be taken to return rectangular output, including a trailing newline, for the recursion to work. • So, you're demonstrating that this, the Teflon one, and the Deep Dish Pizza one, are all really similar construction? That's kinda neat. – AdmBorkBork Apr 7 '17 at 20:37 • @AdmBorkBork I have a few other answers that do that; those diagonal /s are popular in ASCII art and the replace method is a relatively cheap way of generating them in JavaScript. – Neil Apr 7 '17 at 20:45 • 1<<n>>1: Nice symmetry ;-) – Luke Apr 8 '17 at 20:51 • @Luke I could change the variable to, say, v but sadly the 1 isn't symmetric in any of my usual fonts. – Neil Apr 8 '17 at 20:55 # PHP, 337 Bytes 0 Indexing $h=array_fill(0,1+2*$v=2**($c=$argn),str_pad("",4*$v));for(;1+$c;$c--)for($i=0;$i<$e=2**$c*2+1;$i++){$z=$e-$i<2;$y=$i&&$i<$e/2;$x=$i>=$e/2&$i<$e-1;$h[$i]=substr_replace($h[$i],$s=str_pad(!$y?$z|$x?"\\":"":"/",$e-1+$z-$y+$y*$i*2-$x+$x*2*($e-$i),$z|!$i?"_":" ").(!$y?$z|$x?"/":"":"\\"),$v-$z-$y*$i-$x*($e-$i),strlen($s));}echo join("\n",$h);


Try it online!

Expanded

$h=array_fill(0,1+2*$v=2**($c=$argn),str_pad("",4*$v)); # fill array with maximal width for(;1+$c;$c--) # greatest hexagon to lowest for($i=0;$i<$e=2**$c*2+1;$i++){ # loop through the rows
$z=$e-$i<2;$y=$i&&$i<$e/2;$x=$i>=$e/2&$i<$e-1; # booleans last first ad second half
$h[$i]=substr_replace($h[$i], # replace substring
$s=str_pad($z?"\\":($y?"/":($x?"\\":"")),
$e-1+$z-$y+$y*$i*2-$x+$x*2*($e-$i),$z|!$i?"_":" " ).(!$z?!$y?$x?"/":"":"\\":"/"), # with string for smaller hexagon
$v-$z-$y*$i-$x*($e-$i), # at offset strlen($s));
}
echo join("\n",\$h); # Output