Creating a Sierpinski Triangle in Go Lang

The Sierpinski Triangle is a well-known fractal that exhibits self-similarity, meaning it looks the same at different scales. This pattern is formed by recursively subdividing an equilateral triangle into smaller triangles. In this blog post, we'll explore how to generate a Sierpinski Triangle using the Go programming language.

Understanding the Sierpinski Triangle

The Sierpinski Triangle starts with a single equilateral triangle. This triangle is subdivided into four smaller equilateral triangles, and the central triangle is removed. This process is repeated recursively for the remaining triangles. The result is a fractal pattern that is infinitely complex, yet can be described with a simple recursive algorithm.

Why Use Go?

Go, also known as Golang, is a modern programming language designed for simplicity and efficiency. It is particularly well-suited for concurrent programming and has a rich standard library. Using Go to generate the Sierpinski Triangle allows us to leverage its straightforward syntax and powerful features.

Generating the Sierpinski Triangle in Go

We will use a simple console-based approach to generate and display the Sierpinski Triangle. Below is the Go code to create this fractal pattern:

package main

import (
    "fmt"
    "strings"
    "unicode/utf8"
)

func main() {
    var order = 4
    var star = "*"

    t := []string{star + strings.Repeat(" ", utf8.RuneCountInString(star))}
    for ; order > 0; order-- {
        sp := strings.Repeat(" ", utf8.RuneCountInString(t[0])/2)
        top := make([]string, len(t))
        for i, s := range t {
            top[i] = sp + s + sp
            t[i] += s
        }
        t = append(top, t...)
    }

    for _, r := range t {
        fmt.Println(r)
    }
}

output

               *                
              * *               
             *   *              
            * * * *             
           *       *            
          * *     * *           
         *   *   *   *          
        * * * * * * * *         
       *               *        
      * *             * *       
     *   *           *   *      
    * * * *         * * * *     
   *       *       *       *    
  * *     * *     * *     * *   
 *   *   *   *   *   *   *   *  
* * * * * * * * * * * * * * * *

Run code on Go PlayGround

Code Explanation

Let's break down the code to understand how it generates the Sierpinski Triangle.

Imports and Initialization:
```
import (
   "fmt"
   "strings"
   "unicode/utf8"
)
```
We import the necessary packages. The fmt package is used for printing, strings for string manipulation, and unicode/utf8 for counting runes in a string.
Main Function:
```
func main() {
   var order = 4
   var star = "*"
```
We define the order of the triangle, which determines the depth of recursion, and the character used to draw the triangle (star).
Initial Triangle Setup:
```
t := []string{star + strings.Repeat(" ", utf8.RuneCountInString(star))}
```
We initialize the first row of the triangle with a single star followed by spaces.
Generating the Triangle:
```
for ; order > 0; order-- {
   sp := strings.Repeat(" ", utf8.RuneCountInString(t[0])/2)
   top := make([]string, len(t))
   for i, s := range t {
       top[i] = sp + s + sp
       t[i] += s
   }
   t = append(top, t...)
}
```
The loop runs for the specified order, generating the triangle. For each iteration:
- We calculate the spaces needed to center-align the current rows (sp).
- Create a copy of the current rows (top) and update them to include spaces on both sides.
- Update the original rows (t) by duplicating the pattern.
- Append the modified rows (top) to t to create the next level of the triangle.
Printing the Triangle:
```
for _, r := range t {
   fmt.Println(r)
}
```
Finally, we print each row of the triangle.

Running the Code

To run the code, save it to a file named main.go and execute the following commands in your terminal:

go run main.go

You should see an output resembling a Sierpinski Triangle, depending on the specified order.

Conclusion

Creating a Sierpinski Triangle in Go is a great way to explore recursive algorithms and understand how fractals work. Go's simplicity and performance make it an excellent choice for such tasks. This code provides a basic but powerful demonstration of generating fractal patterns using recursion. Feel free to experiment with different orders and characters to create your unique fractal art. Happy coding!