Hexagonal Triangles!

Question

Your task: make a hexagonal triangle with side length n, where n is a positive whole number or 0.

First, let me define a hexagon:

 / \
|   |
 \ /

(Amazing ASCII art, right?)

Hexagons can be linked together by sharing sides:

 / \ / \
|   |   |
 \ / \ /

   / \  
  |   |
 / \ /
|   |
 \ /

A hexagonal triangle is the following:

   / \
  |   |
 / \ / \
|   |   |
 \ / \ /

That hexagonal triangle has a side length of 2-- 2 hexagons are required to make one side. A hexagonal triangle with side-length 1 is just a single hexagon, and a hexagon with side-length 0 is empty.

More formally, a hexagonal triangle is a triangle made of hexagons linked by their sides. The top hexagon links to the two below it on its bottom two sides. The triangle in the bottom left links to the one to its right and top-right, and the one in the bottom right links to the ones on its left and upper left. There are hexagons in between the corner ones, connected by their opposite sides, and their number is n-2. The triangles are not filled.

More examples:

Side length 3:
     / \
    |   |
   / \ / \
  |   |   |
 / \ / \ / \
|   |   |   |
 \ / \ / \ /

Side length 4:
       / \
      |   |
     / \ / \
    |   |   |
   / \ / \ / \
  |   |   |   |
 / \ / \ / \ / \
|   |   |   |   |
 \ / \ / \ / \ /
(This triangle isn't really filled, the borders make it look like there is a hexagon in the middle, but there is not.)

Side length 5:
         / \
        |   |
       / \ / \
      |   |   |
     / \ / \ / \
    |   |   |   |
   / \ /     \ / \
  |   |       |   |
 / \ / \ / \ / \ / \
|   |   |   |   |   |
 \ / \ / \ / \ / \ /

Side length 6:
           / \
          |   |
         / \ / \
        |   |   |
       / \ / \ / \
      |   |   |   |
     / \ /     \ / \
    |   |       |   |
   / \ /         \ / \
  |   |           |   |
 / \ / \ / \ / \ / \ / \
|   |   |   |   |   |   |
 \ / \ / \ / \ / \ / \ /

If there isn't a Hexagony answer for this, I will lose all faith in @MartinEnder. — caird coinheringaahin g, Apr 23, 2017 at 20:00
@Soyoucanreplytomeincomments Let's just say if I could folow users on here, they'd be on the list. — phyrfox, Apr 23, 2017 at 20:04
I expect to see a short answer in Charcoal. I'd do it myself, but I'd have to learn it first, and I want to watch a movie instead, sorry. — Neil, Apr 23, 2017 at 21:20
@Neil you are forgiven for not learning an entirely new programming language. But that's your first warning! — caird coinheringaahin g, Apr 23, 2017 at 21:58

Neil · Accepted Answer · 2017-08-08 00:14:23Z

11

Charcoal, 62 43 39 bytes

ＮβＦ³«Ｆ⁻β‹ι²« / \¶|   |¶ \ /Ｍ×²ι↑¿⁻¹ιＭ⁶←

Try it online! Edit: Saved some bytes thanks to @ASCII-only (not sure exactly how many as I also saved another 6 10 bytes but then needed to spend 4 bytes on a bugfix). Now using nested loops, which is what this should have been all along.

edited Aug 8, 2017 at 0:14

answered Apr 23, 2017 at 23:35

Neil

163k12 gold badges69 silver badges270 bronze badges

\$\begingroup\$ 45 bytes: Ａ / \¶| |¶ \ /αＮβＦβ«α←←»Ｆβ«α↖↖Ｍ⁶←»Ｆβ«αＭ⁴↑←← (btw charcoal autocompletes any needed » at the end) \$\endgroup\$
– ASCII-only
May 2, 2017 at 23:00
\$\begingroup\$ @ASCII-only Sadly I can't seem to find the Charcoal documentation any more, so I have no idea what your code does. \$\endgroup\$
– Neil
May 3, 2017 at 9:37
\$\begingroup\$ commands are on the wiki here, basically Assign(hexagon_with_space_to_left, a);InputNumber(b);for(b){Print(a);Move(:Left);Move(:Left);}for(b){Print(a);Move(:UpLeft);Move(:UpLeft);Move(6, :Left);}for(b){Print(a);Move(4, :Up);Move(:Left);Move(:Left);}, each for loop draws one side \$\endgroup\$
– ASCII-only
May 3, 2017 at 9:40
\$\begingroup\$ So pretty much what you were you doing but with the string saved as a variable \$\endgroup\$
– ASCII-only
May 3, 2017 at 9:45
\$\begingroup\$ @ASCII-only By reversing the direction of drawing I was able to save a further 2 bytes. (Also I'm slightly disappointed that the best way of drawing the hexagon is a string literal, but at least this makes it easy to repeat.) \$\endgroup\$
– Neil
May 3, 2017 at 9:57

| Show 2 more comments

math junkie · Accepted Answer · 2017-04-24 01:12:48Z

7

Python 2, 184 177 174 164 bytes

n=input();p='|   |';e=' \\ /'
for i in range(n):k=' '*(4*i-5);w='  '*~(i-n);print w+[' / \\'*-~i+'\n'+w+p[:4]*i+p,' /'+e+k[3:]+e+' \\\n'+w+p+k+p][2<i<n-1]
print e*n

Try it Online!

-7 bytes thanks to Ørjan Johansen

edited Apr 24, 2017 at 1:12

answered Apr 23, 2017 at 23:39

math junkie

7,2271 gold badge21 silver badges46 bronze badges

\$\begingroup\$ You are missing the rightmost |s on the top three and the bottom hexagon row. \$\endgroup\$
– Ørjan Johansen
Apr 24, 2017 at 0:00
\$\begingroup\$ p[:4]*(i+2) instead of p[:4]*(i+1) seems to fix it. \$\endgroup\$
– Ørjan Johansen
Apr 24, 2017 at 0:10
\$\begingroup\$ You are only using b in one spot, so combining that with your ~ trick, w=' '*2*~(i-n) is 7 bytes shorter. \$\endgroup\$
– Ørjan Johansen
Apr 24, 2017 at 0:25
\$\begingroup\$ @ØrjanJohansen Thanks, the code went through a lot of refactoring and i forgot to change those things \$\endgroup\$
– math junkie
Apr 24, 2017 at 0:28

Add a comment |

Neil · Accepted Answer · 2017-04-23 21:24:13Z

6

JavaScript (ES6), 243 bytes

f=n=>(n=n*2-2,a=[...Array(n+3)].map(_=>Array(n*2+5).fill` `),g=(y,x)=>(a[y+1][x]=a[y+1][x+4]=`|`,a[y][x+1]=a[y+2][x+3]=`/`,a[y][x+3]=a[y+2][x+1]=`\\`),[...Array(n+!n)].map((_,i)=>i%2||(g(n,i*2),g(i,i=n-i),g(i,n+i))),a.map(a=>a.join``).join`
`)

<input type=number oninput=o.textContent=f(this.value)><pre id=o>

answered Apr 23, 2017 at 21:24

Neil

163k12 gold badges69 silver badges270 bronze badges

Add a comment |

Arnauld · Accepted Answer · 2017-04-26 09:32:16Z

JavaScript (ES6), 133 129 128 126 bytes

Builds the output character by character with two for loops.

n=>{for(s='',y=n*2,n*=4;~y--;s+=`
`)for(x=n;~x--;)s+=' \\ /|'[x>y-2&x<n-y&(k=x+y&3,x>n-y-6|x<y+4|y<2)?y&1?k:k+1&4:0];return s}

How it works

In the outer loop, y iterates from n*2-1 to -1. In the inner loop, x iterates from n*4-1 to -1. We set k = (x+y) & 3, which is the underlying pattern that is used to generate the hexagons.

Below is the resulting grid for n = 4:

     15 14 13 12 11 10  9  8  7  6  5  4  3  2  1  0 -1
   +---------------------------------------------------
 7 |  2  1  0  3  2  1  0  3  2  1  0  3  2  1  0  3  2
 6 |  1  0  3  2  1  0  3  2  1  0  3  2  1  0  3  2  1
 5 |  0  3  2  1  0  3  2  1  0  3  2  1  0  3  2  1  0
 4 |  3  2  1  0  3  2  1  0  3  2  1  0  3  2  1  0  3
 3 |  2  1  0  3  2  1  0  3  2  1  0  3  2  1  0  3  2
 2 |  1  0  3  2  1  0  3  2  1  0  3  2  1  0  3  2  1
 1 |  0  3  2  1  0  3  2  1  0  3  2  1  0  3  2  1  0
 0 |  3  2  1  0  3  2  1  0  3  2  1  0  3  2  1  0  3
-1 |  2  1  0  3  2  1  0  3  2  1  0  3  2  1  0  3  2

On even rows, a cell is filled with a pipe character when k = 3, and a space otherwise. The pipe is the 5th character in our reference string " \ /|", so the correct index is given by (k+1) & 4.

On odd rows, each cell is filled directly with the corresponding character in the reference string:

k = 0 → space
k = 1 → "\"
k = 2 → space
k = 3 → "/"

Below is our updated example (spaces replaced with dots):

     15 14 13 12 11 10  9  8  7  6  5  4  3  2  1  0 -1
   +---------------------------------------------------
 7 |  .  \  .  /  .  \  .  /  .  \  .  /  .  \  .  /  .
 6 |  .  .  |  .  .  .  |  .  .  .  |  .  .  .  |  .  .
 5 |  .  /  .  \  .  /  .  \  .  /  .  \  .  /  .  \  .
 4 |  |  .  .  .  |  .  .  .  |  .  .  .  |  .  .  .  |
 3 |  .  \  .  /  .  \  .  /  .  \  .  /  .  \  .  /  .
 2 |  .  .  |  .  .  .  |  .  .  .  |  .  .  .  |  .  .
 1 |  .  /  .  \  .  /  .  \  .  /  .  \  .  /  .  \  .
 0 |  |  .  .  .  |  .  .  .  |  .  .  .  |  .  .  .  |
-1 |  .  \  .  /  .  \  .  /  .  \  .  /  .  \  .  /  .

In the following formulas, we define N = n*4 for readability (although the same variable is used in the code).

The triangle shape is obtained by testing:

x > y - 2 → removes the right corner
AND x < N - y → removes the left corner

And the inner part is removed by testing:

x > N - y - 6 → keeps only the left edge
OR x < y + 4 → keeps only the right edge
OR y < 2 → keeps only the bottom edge

Demo

let f =

n=>{for(s='',y=n*2,n*=4;~y--;s+=`
`)for(x=n;~x--;)s+=' \\ /|'[x>y-2&x<n-y&(k=x+y&3,x>n-y-6|x<y+4|y<2)?y&1?k:k+1&4:0];return s}

console.log(f(3))
console.log(f(4))
console.log(f(5))
console.log(f(6))
console.log(f(7))

Does [x>y-2&x<n-y&(x>n-y-6|x<y+4|y<2)&&y&1?x+y&3:x-~y&4] work? — Neil, Apr 26, 2017 at 16:01
@Neil Hmm, I don't think so. We'd need parenthesis around the ternary expression and (x+y+1)&4 is not the same as (((x+y)&3)+1)&4. — Arnauld, Apr 26, 2017 at 16:16

Jonathan Allan · Accepted Answer · 2017-04-24 21:35:48Z

Jelly, 62 61 bytes

Currently containing six sixes.

_‘<×⁸>6
Rµ‘⁾| ẋ⁾/\ẋ⁸¤ż;/K€µ⁶ðMṀ_6r6ẋð¦"Jç¥
ḤḶUẋ@€⁶;"Çµ-ịṙ6ṭ⁸Y

Try it online!

How?

_‘<×⁸>6 - Link 1, should we eat the praline? row number, triangle size
_       - row number minus triangle size
 ‘      - plus one
  <     - less than triangle size? (1 if one of the last rows else 0)
   ×⁸   - multiply by row number   (row number or 0)
     >6 - greater than 6?          (row number if between row 6 and last two rows)

Rµ‘⁾| ẋ⁾/\ẋ⁸¤ż;/K€µ⁶ðMṀ_6r6ẋð¦"Jç¥ - Link 2, build a solid triangle: triangle size
                                              (except the very bottom row)
R                                  - range: [1,2,...,size]
 µ                                 - monadic chain separation, call that r
  ‘                                - increment: [2,3,...,size+1]
   ⁾| <space                       - literal "| "
      ẋ                            - repeat: ["| | ","| | | ",...]
            ¤                      - nilad followed by link(s) as a nilad:
       ⁾/\                         -   literal "/\"
           ⁸                       -   link's left argument, r
          ẋ                        -   repeat (vectorises): ["/\","/\/\",...]
             ż                     - zip the two repeated lists together: [["/\","| | "],["/\/\","| | | "],...]
              ;/                   - reduce by concatenation: ["/\","| | ","/\/\","| | | ",...]
                K€                 - join with spaces for €ach: ["/ \","|   |  ","/ \ / \","|   |   |  ",...]
                  µ                - monadic chain separation call that s
                                 ¥ - last two links a a dyad:
                               J   -   range(length(s))  
                                ç  -   call the last (1) link as a dyad (left = result of J, right = size)
                              "    - zip with: (call those d)
                    ð       ð¦     -   apply to indexes:
                   ⁶               -   a literal space character
                     M             -     indexes of maximal elements in an element of s (a row)
                      Ṁ            -     maximum (this is the rightmost non-space index, MṀ working like length ignoring trailing spaces)
                       _6          -     subtract 6  (6 indexes back from the right)
                         r6        -     range from there to 6, i.e [l-6,l-7,...,6]
                           ẋ       -     repeat d times (1 or 0), thus applying to the middle rows but not the bottom and top ones.

ḤḶUẋ@€⁶;"Çµ-ịṙ6ṭ⁸Y - Main link: triangle size
Ḥ                  - double(size)
 Ḷ                 - unlength: [0,1,2,...,double(size)-1]
  U                - upend: [double(size)-1,...,2,1,0]
      ⁶            - literal space character
   ẋ@€             - repeat for €ach with reversed arguments ["  ...  ",...,"  "," ",""]
         Ç         - call the last link (2) as a monad(size)
       ;"          - zip with concatenation (zips the leading spaces with the solid triangle body)
          µ        - monadic chain separation, call that t
           -ị      - index -1 (last but one row of t)
             ṙ6    - rotate left by 6 (any number congruent to 2 mod 4 would do)
               ṭ⁸  - tack to t (add this new row on)
                 Y - join all the rows by new lines
                   - implicit print

@RomanGräf thanks I edited the explanation! If you just meant more than "the ẋ under the space in the explanation is misaligned", let me know. — Jonathan Allan, Apr 24, 2017 at 21:36

Leaky Nun · Accepted Answer · 2017-04-24 18:08:22Z

1

Pyth, 82 bytes

jb+Rt_.rd"/\\"_.e<s[dd*dkb*dyQ)hyQ*,"|   |""/ \\ /"tQ*Q" / \\"+*Q"|   "\|*Q" \\ /"

Try it online!

answered Apr 24, 2017 at 18:08

Leaky Nun

49.5k6 gold badges107 silver badges281 bronze badges

Add a comment |

Not a tree · Accepted Answer · 2017-04-25 01:47:51Z

Mathematica, 155 bytes

""<>Table[If[i+j<d||i-j>d+1||i+j>d+5&&i-j<d-3&&j<d-1," ",Switch[Mod[i+d+{j,-j},4],{1,3},"/",{3,1},"\\",{1,1},"|",_," "]],{j,(d=2#)+1},{i,4#+1}]~Riffle~"\n"&

with \n replaced with a newline.

Stack Exchange Network

Hexagonal Triangles!

7 Answers 7

Charcoal, 62 43 39 bytes

Python 2, 184 177 174 164 bytes

JavaScript (ES6), 243 bytes

JavaScript (ES6), 133 129 128 126 bytes

How it works

Demo

Jelly, 62 61 bytes

Currently containing six sixes.

How?

Pyth, 82 bytes

Mathematica, 155 bytes

Your Answer

Not the answer you're looking for? Browse other questions tagged
code-golf
ascii-art
geometry
hexagonal-grid
or ask your own question.

Hot Network Questions

Hexagonal Triangles!

7 Answers 7

Charcoal, 62 43 39 bytes

Python 2, 184 177 174 164 bytes

JavaScript (ES6), 243 bytes

JavaScript (ES6), 133 129 128 126 bytes

How it works

Demo

Jelly, 62 61 bytes

Currently containing six sixes.

How?

Pyth, 82 bytes

Mathematica, 155 bytes

Your Answer

Sign up or log in

Post as a guest

Not the answer you're looking for? Browse other questions tagged code-golfascii-artgeometryhexagonal-grid or ask your own question.

Related

Hot Network Questions

Not the answer you're looking for? Browse other questions tagged
code-golf
ascii-art
geometry
hexagonal-grid
or ask your own question.