# 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. Apr 7, 2017 at 14:10
• It might be hard to handle big input (ex. 64). Is there a limit to n? Apr 7, 2017 at 15:33
• @SIGSEGV There is no limit to n. Apr 7, 2017 at 16:12
• Would be amused to see an answer in Hexagony :)) Apr 7, 2017 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 :) Apr 7, 2017 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. Apr 7, 2017 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, 2017 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, 2017 at 21:12
• @Neil Thanks, that is pretty neat :) May 26, 2017 at 6:20

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]
l&t|a<-c[l,2*t]" _",b<-[c[l-i,1,2*t+2*i-2,1,l-i]" / \\ "|i<-[1..t]]=a:b++r(r<$>o[a]b) c=(concat.).z replicate o=max?' '?"" f?e=z f.(++repeat e) r=reverse z=zipWith  Try it online! # How it works • m is the main function. It uses & to generate the hexagons with proper padding, then folds them together with o. • l&t generates a small hexagon of side length t, padded inside a large one of side length l, as a list of String lines. • a is the top line of the hexagon, with the underscores. • b is a list of the other lines in the upper half of the hexagon. The lines of b are centered in the padding, which is rectangular; this allows the next step to work. • The bottom half of the hexagon is a overlaid on top of b with o, then reversed (both order of lines and within each line). • c takes two arguments, a list of lengths and a string, and generates a string that has as many copies of each character in the original as the corresponding length, e.g. c[1,3,2]"abc" == "abbbcc". It is used in & to generate the lines. • o takes two arguments representing pictures as lists of lines, and overlays the first, smaller one on top of the second one. • It is used both to combine hexagons and to add the bottom to each hexagon. • It essentially works by using ? twice to pad the first picture with infinitely many spaces both downwards and rightwards, then zipping together corresponding characters with max, which selects the non-space character if there is one. • (f?e)l m pads a list l by appending infinitely many 'e' elements, then zips the resulting list and the list m with the f function. • Nice solution! I think (#) can be max. – xnor Apr 8, 2017 at 3:11 • The zipping can be combined with p to save bytes: o=max?' '?"";f?e=z f.(++repeat e). Might be shorter pointfree. – xnor Apr 8, 2017 at 3:38 • (\n->(<$[1..n])) is replicate.
– xnor
Apr 8, 2017 at 3:47
+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. Apr 7, 2017 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, 2017 at 20:45 • 1<<n>>1: Nice symmetry ;-) – Luke Apr 8, 2017 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, 2017 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