Geek Challenge Results: Fractal Snowflake

The winner of the Fractal Snowflake Geek Challenge is John Jacobsma of Dickson. Tim Jager of DMC also responded with a correct value of C, 10830.

The Fractal Snowflake Challenge was a study in recursive programming. Recursive programming is a technique where a function calls itself, usually many times, until eventually instead of calling itself, it just does something. The program had two layers of recursive programming in it:

The function MakeTriangle was what actually did something in the end. It made one of the little blue triangles we were counting.

The function Sierpinski made the triangle shaped fractal. It is called with an Order parameter, and if the order is zero, then it calls MakeTriangle. If the order parameter is > 0, it just calls itself 3 times with an order decremented by 1.

The function KochSide is responsible for jagged looking sides of the snowflake. It also takes an Order parameter; At order 0, it does nothing, but at higher orders it calls itself 4 times, and Sierpinski once, all with order decremented by 1.

The function CombinedFractal calls Sierpinski once to fill in the largest fractal triangle, then calls KochSide 3 times to fill out the jagged edge pattern on all sides of the triangle.

To solve the puzzle of counting the little triangles, the easiest way to do it was to modify MakeTriangle to simply count instead of actually making triangles. Then run the program, and it will give the answer: 10830.

John Jacobsma simplified and re-wrote the program in Java. Without any of the geometry, this program shows just the recursive nature of the problem:

package counttriangles;

public class CountTriangles implements Runnable
{
  public static void main(String[] args)
  {
    new CountTriangles().run();
  }

  @Override
  public void run()
  {
    System.out.println(combined(6));
  }

  int combined(int order)
  {
    return sierpinski(order) + 3 * koch(order);
  }

  int koch(int order)
  {
    if (order <= 0)
      return 0;
    return sierpinski(order - 1) + 4 * koch(order - 1);
  }

  int sierpinski(int order)
  {
    if (order <= 0)
      return 1;
    return 3 * sierpinski(order - 1);
  }
}

The problem can also be solved without delving into the programming, but by analyzing the pattern.  

Order 0 has just 1 triangle. Each additional order spits each triangle into 3, so it has 3 times more triangles than the previous. So, the triangle counts of Sierpinski triangles are 1, 3, 9, 27, 81, 243 and 729. Also note that the order of a Sierpinski triangle can be determined by counting the interior white triangles down the middle.

Three white triangles down the middle indicates an order 3 Sierpinski triangle:  

Next, the Koch pattern can be analyzed. A level 2 Koch snowflake is shown here with the edges marked. The level pattern in Red is repeated 4 times by pattern in Green. Each additional level continues to multiply by 4.  But the first Red pattern is performed only 3 times, for the 3 sides of the center triangle.

So, the number of triangles that make up solid Koch snowflake is 1, 3, 12, 48, 192, 768, 3072.

Since the fractal snowflake pattern is made of Sierpinski triangles instead of solid triangles, the pattern of the order of the Sierpinski triangles has to be determined. It can be observed that the central triangle is order 6, and each smaller triangle on the perimeter is seen to be 1 level smaller, down to level 0 triangles on the fringes:

Now, the two numeric sequences can be combined and summed to determine the total number of triangles: