55 entries

Sorted by:

4

444
3
8

This snowflake generator creates unique ASCII art based on random seeds. Each snowflake maintains hexagonal symmetry and natural characteristics. The algorithm uses mathematical principles to generate branches, create symmetry, and add natural variations.

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>ASCII Snowflake Generator</title>
    <style>
        body {
            font-family: 'Courier New', monospace;
            background: linear-gradient(135deg, #1e3c72, #2a5298);
            color: white;
            margin: 0;
            padding: 20px;
            min-height: 100vh;
        }
        
        .container {
            max-width: 1200px;
            margin: 0 auto;
            background: rgba(255, 255, 255, 0.1);
            border-radius: 20px;
            padding: 30px;
            backdrop-filter: blur(10px);
            border: 1px solid rgba(255, 255, 255, 0.2);
        }
        
        h1 {
            text-align: center;
            font-size: 2.5em;
            margin-bottom: 30px;
            text-shadow: 2px 2px 4px rgba(0, 0, 0, 0.5);
            background: linear-gradient(45deg, #fff, #a8e6cf);
            -webkit-background-clip: text;
            -webkit-text-fill-color: transparent;
            background-clip: text;
        }
        
        .controls {
            display: flex;
            gap: 20px;
            justify-content: center;
            align-items: center;
            margin-bottom: 30px;
            flex-wrap: wrap;
        }
        
        .control-group {
            display: flex;
            flex-direction: column;
            align-items: center;
            gap: 5px;
        }
        
        label {
            font-weight: bold;
            font-size: 0.9em;
        }
        
        input, select, button {
            padding: 10px;
            border: none;
            border-radius: 8px;
            font-family: 'Courier New', monospace;
            font-size: 14px;
        }
        
        input, select {
            background: rgba(255, 255, 255, 0.2);
            color: white;
            border: 1px solid rgba(255, 255, 255, 0.3);
        }
        
        input::placeholder {
            color: rgba(255, 255, 255, 0.7);
        }
        
        button {
            background: linear-gradient(45deg, #4CAF50, #45a049);
            color: white;
            cursor: pointer;
            font-weight: bold;
            transition: transform 0.2s, box-shadow 0.2s;
            border: 1px solid rgba(255, 255, 255, 0.2);
        }
        
        button:hover {
            transform: translateY(-2px);
            box-shadow: 0 5px 15px rgba(0, 0, 0, 0.3);
        }
        
        .snowflake-display {
            display: grid;
            grid-template-columns: repeat(auto-fit, minmax(300px, 1fr));
            gap: 20px;
            margin-top: 20px;
        }
        
        .snowflake {
            background: rgba(0, 0, 0, 0.3);
            border-radius: 15px;
            padding: 20px;
            border: 1px solid rgba(255, 255, 255, 0.2);
            box-shadow: 0 5px 15px rgba(0, 0, 0, 0.3);
        }
        
        .snowflake-header {
            text-align: center;
            margin-bottom: 15px;
            font-weight: bold;
            color: #a8e6cf;
        }
        
        .snowflake-art {
            font-family: 'Courier New', monospace;
            white-space: pre;
            font-size: 12px;
            line-height: 1;
            color: #ffffff;
            text-align: center;
            overflow-x: auto;
            background: rgba(0, 0, 0, 0.2);
            padding: 15px;
            border-radius: 8px;
            border: 1px solid rgba(255, 255, 255, 0.1);
        }
        
        .info-panel {
            background: rgba(255, 255, 255, 0.1);
            border-radius: 15px;
            padding: 20px;
            margin-bottom: 20px;
            border: 1px solid rgba(255, 255, 255, 0.2);
        }
        
        .info-panel h3 {
            margin-top: 0;
            color: #a8e6cf;
        }
        
        @media (max-width: 768px) {
            .controls {
                flex-direction: column;
                gap: 15px;
            }
            
            .snowflake-display {
                grid-template-columns: 1fr;
            }
            
            .snowflake-art {
                font-size: 10px;
            }
        }
    </style>
</head>
<body>
    <div class="container">
        <h1>❄️ ASCII Snowflake Generator ❄️</h1>
        
        <div class="info-panel">
            <h3>Snowflake Generator</h3>
        </div>
        
        <div class="controls">
            <div class="control-group">
                <label for="seedInput">Seed:</label>
                <input type="text" id="seedInput" placeholder="Enter seed (text/number)" value="snowflake2024">
            </div>
            
            <div class="control-group">
                <label for="sizeSelect">Size:</label>
                <select id="sizeSelect">
                    <option value="small">Small (15x15)</option>
                    <option value="medium" selected>Medium (25x25)</option>
                    <option value="large">Large (35x35)</option>
                </select>
            </div>
            
            <div class="control-group">
                <label for="styleSelect">Style:</label>
                <select id="styleSelect">
                    <option value="classic">Classic</option>
                    <option value="delicate" selected>Delicate</option>
                    <option value="bold">Bold</option>
                    <option value="ornate">Ornate</option>
                </select>
            </div>
            
            <button onclick="generateSnowflake()">Generate Snowflake</button>
            <button onclick="generateMultiple()">Generate 4 Snowflakes</button>
            <button onclick="randomSeed()">Random Seed</button>
        </div>
        
        <div class="snowflake-display" id="snowflakeDisplay">
        </div>
    </div>

    <script>
        // Seeded random number generator for reproducible results
        class SeededRandom {
            constructor(seed) {
                this.seed = this.hashCode(seed.toString());
            }
            
            hashCode(str) {
                let hash = 0;
                for (let i = 0; i < str.length; i++) {
                    const char = str.charCodeAt(i);
                    hash = ((hash << 5) - hash) + char;
                    hash = hash & hash; // Convert to 32-bit integer
                }
                return Math.abs(hash);
            }
            
            next() {
                this.seed = (this.seed * 9301 + 49297) % 233280;
                return this.seed / 233280;
            }
            
            nextInt(min, max) {
                return Math.floor(this.next() * (max - min + 1)) + min;
            }
            
            choice(array) {
                return array[this.nextInt(0, array.length - 1)];
            }
        }

        class SnowflakeGenerator {
            constructor(seed, size = 'medium', style = 'delicate') {
                this.rng = new SeededRandom(seed);
                this.size = this.getSizeValue(size);
                this.style = style;
                this.center = Math.floor(this.size / 2);
                this.grid = Array(this.size).fill().map(() => Array(this.size).fill(' '));
                
                // Character sets for different styles
                this.charSets = {
                    classic: ['*', '+', 'x', '|', '-', '/', '\\'],
                    delicate: ['·', '•', ':', ';', ',', '.', '´', '`'],
                    bold: ['#', '@', '%', '&', '$', '=', 'X', 'O'],
                    ornate: ['❋', '❊', '✦', '✧', '✶', '✷', '❈', '❅', '*', '+', 'x']
                };
            }
            
            getSizeValue(size) {
                const sizes = { small: 15, medium: 25, large: 35 };
                return sizes[size] || 25;
            }
            
            getChar(intensity = 1) {
                const chars = this.charSets[this.style] || this.charSets.delicate;
                const index = Math.min(Math.floor(intensity * chars.length), chars.length - 1);
                return chars[index];
            }
            
            drawPoint(x, y, char = null) {
                if (x >= 0 && x < this.size && y >= 0 && y < this.size) {
                    this.grid[y][x] = char || this.getChar(this.rng.next());
                }
            }
            
            drawLine(x1, y1, x2, y2, char = null) {
                const dx = Math.abs(x2 - x1);
                const dy = Math.abs(y2 - y1);
                const sx = x1 < x2 ? 1 : -1;
                const sy = y1 < y2 ? 1 : -1;
                let err = dx - dy;
                
                let x = x1, y = y1;
                
                while (true) {
                    this.drawPoint(x, y, char);
                    
                    if (x === x2 && y === y2) break;
                    
                    const e2 = 2 * err;
                    if (e2 > -dy) { err -= dy; x += sx; }
                    if (e2 < dx) { err += dx; y += sy; }
                }
            }
            
            drawBranch(startX, startY, angle, length, thickness = 1) {
                if (length < 1) return;
                
                const endX = startX + Math.cos(angle) * length;
                const endY = startY + Math.sin(angle) * length;
                
                this.drawLine(
                    Math.round(startX), Math.round(startY),
                    Math.round(endX), Math.round(endY)
                );
                
                // Add sub-branches with some probability
                if (length > 3 && this.rng.next() > 0.4) {
                    const subLength = length * (0.3 + this.rng.next() * 0.4);
                    const angleOffset = (this.rng.next() - 0.5) * Math.PI / 3;
                    
                    // Draw sub-branches
                    if (this.rng.next() > 0.3) {
                        this.drawBranch(endX, endY, angle + angleOffset, subLength);
                    }
                    if (this.rng.next() > 0.3) {
                        this.drawBranch(endX, endY, angle - angleOffset, subLength);
                    }
                }
                
                // Add decorative elements at branch tips
                if (length < 4 && this.rng.next() > 0.5) {
                    const decorChar = this.getChar(0.8 + this.rng.next() * 0.2);
                    this.drawPoint(Math.round(endX), Math.round(endY), decorChar);
                }
            }
            
            generate() {
                // Draw center
                this.drawPoint(this.center, this.center, this.getChar(1));
                
                // Generate 6 main branches (hexagonal symmetry)
                const maxRadius = Math.floor(this.size / 2) - 2;
                const numBranches = 6;
                
                for (let i = 0; i < numBranches; i++) {
                    const angle = (i * Math.PI * 2) / numBranches;
                    const branchLength = maxRadius * (0.6 + this.rng.next() * 0.4);
                    
                    // Main branch
                    this.drawBranch(this.center, this.center, angle, branchLength);
                    
                    // Add intermediate branches
                    const midRadius = branchLength * 0.5;
                    const midX = this.center + Math.cos(angle) * midRadius;
                    const midY = this.center + Math.sin(angle) * midRadius;
                    
                    if (this.rng.next() > 0.3) {
                        const sideLength = branchLength * 0.3;
                        this.drawBranch(midX, midY, angle + Math.PI/3, sideLength);
                        this.drawBranch(midX, midY, angle - Math.PI/3, sideLength);
                    }
                }
                
                // Add inner hexagonal pattern
                const innerRadius = maxRadius / 3;
                for (let i = 0; i < 6; i++) {
                    const angle1 = (i * Math.PI * 2) / 6;
                    const angle2 = ((i + 1) * Math.PI * 2) / 6;
                    
                    const x1 = this.center + Math.cos(angle1) * innerRadius;
                    const y1 = this.center + Math.sin(angle1) * innerRadius;
                    const x2 = this.center + Math.cos(angle2) * innerRadius;
                    const y2 = this.center + Math.sin(angle2) * innerRadius;
                    
                    if (this.rng.next() > 0.4) {
                        this.drawLine(Math.round(x1), Math.round(y1), Math.round(x2), Math.round(y2));
                    }
                }
                
                // Add random crystalline details
                const numDetails = this.rng.nextInt(5, 15);
                for (let i = 0; i < numDetails; i++) {
                    const angle = this.rng.next() * Math.PI * 2;
                    const radius = this.rng.next() * maxRadius * 0.8;
                    const x = this.center + Math.cos(angle) * radius;
                    const y = this.center + Math.sin(angle) * radius;
                    
                    if (this.rng.next() > 0.6) {
                        this.drawPoint(Math.round(x), Math.round(y), this.getChar(0.5 + this.rng.next() * 0.5));
                    }
                }
                
                return this.grid.map(row => row.join('')).join('\n');
            }
        }
        
        function generateSnowflake() {
            const seed = document.getElementById('seedInput').value || 'default';
            const size = document.getElementById('sizeSelect').value;
            const style = document.getElementById('styleSelect').value;
            
            const generator = new SnowflakeGenerator(seed, size, style);
            const snowflake = generator.generate();
            
            displaySnowflakes([{seed, snowflake, size, style}]);
        }
        
        function generateMultiple() {
            const baseSeed = document.getElementById('seedInput').value || 'default';
            const size = document.getElementById('sizeSelect').value;
            const style = document.getElementById('styleSelect').value;
            
            const snowflakes = [];
            for (let i = 0; i < 4; i++) {
                const seed = baseSeed + '_' + i;
                const generator = new SnowflakeGenerator(seed, size, style);
                const snowflake = generator.generate();
                snowflakes.push({seed, snowflake, size, style});
            }
            
            displaySnowflakes(snowflakes);
        }
        
        function randomSeed() {
            const words = ['frost', 'winter', 'crystal', 'ice', 'snow', 'cold', 'white', 'pure', 'frozen', 'chill'];
            const numbers = Math.floor(Math.random() * 10000);
            const randomSeed = words[Math.floor(Math.random() * words.length)] + numbers;
            document.getElementById('seedInput').value = randomSeed;
            generateSnowflake();
        }
        
        function displaySnowflakes(snowflakes) {
            const display = document.getElementById('snowflakeDisplay');
            display.innerHTML = '';
            
            snowflakes.forEach((data, index) => {
                const snowflakeDiv = document.createElement('div');
                snowflakeDiv.className = 'snowflake';
                snowflakeDiv.innerHTML = `
                    <div class="snowflake-header">
                        Seed: "${data.seed}" | Size: ${data.size} | Style: ${data.style}
                    </div>
                    <div class="snowflake-art">${data.snowflake}</div>
                `;
                display.appendChild(snowflakeDiv);
            });
        }
        
        generateSnowflake();
    </script>
</body>
</html>

IA Disclosure: I used Claude to help structure and debug ideas, but all code and design choices were made by myself.

Jun 17 at 16:41, edited Jun 17 at 16:47

27

Anerdw

2.4k
3
18
44

The challenge is stated as such:

Devise a mechanism to create snowflake art using ASCII characters given a random seed.

It is not stated as:

Devise a mechanism to create randomized snowflake art using ASCII characters given a random seed.

Thus, Python:

def create_snowflake(seed: int) -> str:
    return "."

Unfortunately, my vision is bad and I can't make out snowflakes beyond little dots.

Note: I actually really like this challenge, but I saw this interpretation and couldn't resist.

Jun 17 at 16:59, edited Jul 10 at 4:05

15

Anon Coward

10.9k
3
31
42

Here's a simple snowflake. We start with six branches of a random height, and at each point, decide if we want to create a sub-branch based off a random choice. The end result is a simple ASCII snowflake, based off the initial seed:

#!/usr/bin/env python3

import math, random, sys

def show_grid(grid):
    # Just find the limits of the grid, and show 
    # whatever text is in it
    min_x, max_x = min(x for x, y in grid), max(x for x, y in grid)
    min_y, max_y = min(y for x, y in grid), max(y for x, y in grid)
    # Add some padding 
    min_x -= 2
    min_y -= 1
    max_y += 1
    for y in range(min_y, max_y + 1):
        row = ""
        for x in range(min_x, max_x + 1):
            row += grid.get((x, y), " ")
        print(row)

def make_snowflake(ice, size, seed=None, grid={}, center=(0, 0)):
    if seed is not None: random.seed(seed)

    # Pick the size of the snowflake at random as well
    if isinstance(size, int):
        size = [random.randint(size - 4, size)]
        for _ in range(0, len(ice) - 1):
            if random.random() > 0.25: size.append(random.randint(size[-1] // 3, size[-1] // 2))

    # Nothing to do when we run out of values
    if len(size) == 0: return
    
    # Place center, note that the grid can extend into the negative values
    if center not in grid: grid[center] = ice[0]
    
    # Find a few points along each branch that'll trigger a sub-branch
    next_branches = list(range(size[0] // 4, size[0]))
    random.shuffle(next_branches)
    next_branches = next_branches[:random.randint(0, 3)]

    sub_branches = []
    # Generate 6 branches for this point
    for r in range(1, size[0]):
        # Use a sub-seed based off our RNG so each branch looks the same
        sub_seed = random.random()
        for branch in range(6):
            base_angle = branch * math.pi / 3

            x = ((r / 2) * math.cos(base_angle))
            y = ((r / 2) * math.sin(base_angle))
            # When calculating the postiion, double X so it looks reasonable in a ASCII output
            pt = (center[0] + round(x * 2), center[1] + round(y))

            if pt not in grid: grid[pt] = ice[0]

            if r in next_branches:
                # And based off our random picks, add some sub-branches
                sub_branches.append((pt, sub_seed))
                pass

    # Draw out the sub-branches    
    for pt, sub_seed in sub_branches:
        make_snowflake(ice=ice[1:], size=size[1:], center=pt, grid=grid, seed=sub_seed)

    return grid

def main():
    # Either use some hardcoded seeds, or let the user enter their own
    if len(sys.argv) == 1:
        seeds = [42, 123, 999]
    else:
        seeds = map(int, sys.argv[2:])

    for i, seed in enumerate(seeds, 1):
        print("")
        msg = f"Snowflake {i} (seed: {seed}):"
        print("-" * 5 + " " + msg + " " + "-" * (50 - len(msg)))
        snowflake = make_snowflake(ice="Xo.", size=20, seed=seed)
        show_grid(snowflake)

if __name__ == "__main__":
    main()

This outputs:


----- Snowflake 1 (seed: 42): ---------------------------
                                 
         XX             XX       
          oX   oo oo   Xo        
           oX oo   oo Xo         
        oooooXXoooooXXooooo      
       oo   ooXX   XXooo  oo     
        oo oo  XX XX  ooooo      
  XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
         o oo   XoXX   oooo      
        o   oo Xo  XX oo  oo     
         ooooXXoooooXXooooo      
            XX oo   o Xo         
           XX   oo o   Xo        
          XX            XX       
                                 

----- Snowflake 2 (seed: 123): --------------------------
                                       
          oo.   .oo   oo.   .oo        
           oo   oo     oo   oo         
           .XX oo.     .oo XX.         
       oooooooXoooooooooooXooooooo     
            .ooXooo   oo.Xooo.         
     oo.   oooooXXoooooXXooooo   .oo   
      oo  ooo  ooXX   XXooo ooo  oo    
      .oo ooo oo  XX XX  oooooo oo.    
  oooXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXooo
       .o.ooo oo   XoXX   ooooo.oo.    
       o   oo. oo.Xo  XX.oo .oo  oo    
     .o.   .ooooXXoooooXXooooo   .oo   
            .ooXXooo   ooXooo.         
        ooooooXXooooooooooXooooooo     
             XX.oo.     .o.XX.         
             o   oo     o   oo         
           .o.   .oo  .o.   .oo        
                                       

----- Snowflake 3 (seed: 999): --------------------------
                                               
            o..... ..o.. ..o.. .....o          
           ...oo.....oo...oo.....oo...         
          .....oo.oooo..  .oo.oooo.....        
         o..o...XXooo...o...oooXX...o..o       
         ..oooooooXoooooooooooXooooooo..       
       .. .....o.ooXooo. .oo.Xooo...... ..     
     o..ooo....oooooXXoooooXXooooo....ooo..o   
    ..oo.ooo..ooo..ooXX...XXooo.ooo..ooo..o..  
   ......o.oooooo.oo. XX XX .ooooooooo.o...... 
  o..ooooXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXoooo..o
    ......o.o.ooo.oo. .XoXX ..ooooo.oo.oo..... 
    .....ooo..ooo..oo.Xo..XX.oo..oo..ooo..o..  
      ....o.....ooooXXoooooXXooooo....ooo..o   
        . .....o.ooXXooo ..ooXooo...... ..     
         ..oooooooXXooooooooooXooooooo..       
          o.o..ooXX.oo..o..o.o.XX.o.o..o       
            ....ooo.ooo. ...o.o.oo.....        
            ....o.....oo...o.....oo...         
              .o... .o..  . .. .....o

Jun 17 at 16:59

5

Daniel T

1.3k
14
18

Bash, 14 bytes

printf \ %$1s*

Try it online!

This time I learned to start by thinking what's the simplest approach. No AI necessary. The ASCII asterisk technically already resembles a snowflake (use a font where it's hexagon-like not pentagon-like), so only minor shifting was needed to incorporate the random seed.

Every snowflake is unique. Not only does the snowflake drawn differ in position based on the seed, one could say it's also unique for every viewer. One might displayed on the clean left side of your screen, making it relatively simple. The right side of your touchscreen might be dirty from scrolling, temperature, humidity, or other factors, so the snowflake will be intricate. This is most relevant for this answer because dirt affects small images like a single asterisk more.

Examples:

$ ./test.sh 10
           *
$ ./test.sh 50
                                                   *

Jun 17 at 19:52

1

eklavya agal

1
1

An explanation of my snowflake creation approach

To generate snowflakes with unique and natural-looking patterns, I focused on two ideas that are true to how real snowflakes form:

Six-fold symmetry – Real snowflakes have six arms due to the way ice crystals form. So, I only created one "wedge" or 60-degree section of the snowflake and then rotated it five more times to complete the shape.
Random but consistent structure – Each snowflake uses a random seed so that the pattern is deterministic. That means if you use the same seed again, you get the exact same snowflake — but a different seed creates a new one.

The "wedge" starts at the center and extends outward with a main arm. At each step outward, there's a chance of sprouting a small side branch. The seed controls the randomness so every snowflake is unique, but symmetrical.

The code I wrote to create the snowflake(s)

python

import argparse
import math
import random

def generate_wedge(radius, prob, length, rnd):
    pts = []
    for i in range(1, radius + 1):
        pts.append((i, 0))
        if rnd.random() < prob:
            for j in range(1, rnd.randint(1, length) + 1):
                pts.append((i, j))
    pts += [(x, -y) for (x, y) in pts if y != 0]
    return pts

def rotate(p, theta):
    x, y = p
    return (round(x * math.cos(theta) - y * math.sin(theta)),
            round(x * math.sin(theta) + y * math.cos(theta)))

def snowflake(seed, radius=15, charset=("*", "+", "o", "x", "@", "#"), prob=0.3):
    try:
        s = int(seed)
    except:
        s = hash(seed)
    rnd = random.Random(s)
    base = generate_wedge(radius, prob, max(1, radius // 3), rnd)
    points = []
    for i in range(6):
        angle = math.pi / 3 * i
        points.extend(rotate(p, angle) for p in base)
    size = radius * 2 + 3
    cx = cy = radius + 1
    grid = [[" "] * size for _ in range(size)]
    for dx, dy in points:
        x, y = cx + dx, cy + dy
        if 0 <= x < size and 0 <= y < size:
            grid[y][x] = rnd.choice(charset)
    grid[cy][cx] = "*"
    return "\n".join("".join(row).rstrip() for row in grid).rstrip()

def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("seed")
    parser.add_argument("-r", "--radius", type=int, default=15)
    args = parser.parse_args()
    print(snowflake(args.seed, args.radius))

if __name__ == "__main__":
    main()

Some example snowflakes

Seed: `8675309`, Radius: 15

python

        o               @
         @             *
         #             +
          @           @
           x         +
           x         +
            #       #
            x       #
             @*o o**
             x     x
            + *   x +
           o   x x   o
           +   # +   *
 o++@++o@+*@**@**#o++o+#@@o#+x+@
           *    o@   x
           #   @ *   +
            o o*  # @
             *#    +
             #*x @+@
             x      x
            *       x
            *        +
           *         @
          o+          x
          @            o
         x             o
         @              #

Seed: `winter2025`, Radius: 18

nginx

 o          + +
        @            x 
         o         @  o
           *      o   o
            x     o   #
             o   +     o
             +x o     +o
               *+     o
              x       +
               o+   +*x
              +*x @+*++
       +@o@#@@*+##**##+@#x#@+o
              @x * @+@x
               +   x@+
               o    o
             +      *
            +        o
           +         o
          o           *
         x            x
         +            +

How to run it

Save the code in a file, e.g., snowflake.py.
Make sure you have Python 3 installed.
Run it from the terminal or command line like this:

bash

python snowflake.py 42
python snowflake.py 20250618 -r 20

You can pass any seed (number or word) and optionally change the size with -r.

AI usage disclosure

I wrote the code myself, but I did use ChatGPT to help brainstorm some design decisions and refine how to make the snowflake symmetrical using rotation logic. The final implementation and structure are entirely my own, but the AI helped improve clarity and consistency.

Things I learned and challenges I faced



Getting the rotation math right took a few tries. I had to make sure the symmetry looked perfect and didn’t introduce glitches from rounding errors.

I had to be careful with coordinate handling — it’s easy to mix up grid and Cartesian coordinates (row/col vs x/y).

Balancing randomness and beauty was key. Too random, and the flakes look messy; too regular, and they look boring. Tweaking the branch probability and charset made a big difference.

I learned how a small piece of symmetry can be repeated to make complex patterns — kind of like fractals but simpler.

Jun 18 at 7:03, edited Jun 18 at 7:03

0

Paolo Gibellini

320
15
23

Strange and beautiful snowflakes, even scaling is fun

Jul 2 at 6:22

6

Ale_Bianco

665
2
9
26

❄️ Rainbow ASCII Snowstorm – A Seed-Based Animated Snowflake Generator

🔗 Live Demo: Rainbow ASCII Snowstorm

What It Does

This project creates a snowstorm of animated ASCII snowflakes, each generated from a unique random seed. It’s all done in vanilla HTML, CSS, and JavaScript — no frameworks, no images, and no external libraries.

Each snowflake is:

Created from a random seed, so it’s unique and reproducible
Built with 6-fold radial symmetry using ASCII characters
Animated with rainbow shimmer via CSS hue rotation
Falling from the top of the screen with random drift speeds
Labeled with its seed so you can regenerate any snowflake at any time

There’s also a “Generate New Snowstorm” button that spawns 25 brand new snowflakes instantly.

How It Works

A seeded pseudo-random number generator creates repeatable randomness
A grid is filled with characters like *, /, x, + in one wedge, and mirrored around a center point
CSS animations apply filter: hue-rotate() to each character, each with different delays
Snowflakes are positioned randomly and fall at independent speeds using @keyframes

How to Try It

Open this link: Rainbow ASCII Snowstorm
Watch the snowflakes drift down the screen in rainbow colors
Click “Generate New Snowstorm” to create 25 new snowflakes

Everything runs in the browser — no install, no setup needed.

AI Usage Disclosure

Everything was written, tested, and styled by me directly in CodePen. AI was used only to help format and organize this submission text.

What I Learned

How to apply symmetry using geometry in grid-based ASCII art
How filter: hue-rotate() requires a non-white base color
How to balance performance and visual richness using only HTML and CSS
That it’s possible to make something feel magical with just characters and colors

Thanks for reading — and happy snowstorming! ❄️

Jun 18 at 7:34

22

André

1.8k
12
26

Approach to create ❄

The creation is based on a game of life on a hexagonal grid. Instead of birth and death, the neighbor count determines whether to freeze or thaw the current cell. This way symmetric and hexagonal structures are created that for many seeds resemble natural snowflakes. The random seed determines the number of iterations, the freezing rules, and the ASCII symbol (out of a small list of symmetric characters) to use for visualization.

The grid is composed to hold a hexagonal grid, thus every other row (row % 2) has to be shifted to the left and right, respectively. This is especially necessary when counting the number of frozen neighbors in get_frozen_neighbors(), where the col_offset picks the correct neighbors for each cell. Similarly, upon printing the grid in grid2ascii(), we have to add a space in front of even rows, in order to shift them to the correct position.

The actual growing process starts with an initial frozen cell (set to 1) in the center of a large enough grid (initialized unfrozen, i.e. with zeros), which then updates in every iteration via update_grid(). To not saw off the branch we are sitting on, we have to work with a copy of the grid, thus updated_grid will be populated according to the rules and finally returned. In each iteration we count the number of frozen neighbors, check whether to freeze or unfreeze the current cell based on the freeze-rule and repeat iterating the grid.

Code to create ❄

snowflakes.py contains the following:

# This script generates a snowflake using a hexagonal grid and cell rules for freezing/thawing cells.
import sys
import numpy as np

ROWS, COLS = 30, 30  # Size of the grid

def get_frozen_neighbors(grid, row, col):
    # Return -1 for border cells so that they are not processed by any rules
    if row <= 0 or row >= grid.shape[0] - 1 or col <= 0 or col >= grid.shape[1] - 1:
        return -1

    col_offset = 1 if ((row % 2) == 0) else -1  # Adjust column offset for hexagonal grid

    return (
        grid[row - 1, col]
        + grid[row - 1, col + col_offset]
        + grid[row, col - 1]
        + grid[row, col + 1]
        + grid[row + 1, col]
        + grid[row + 1, col + col_offset]
    )


def update_grid(grid, freeze):
    updated_grid = grid.copy()
    for row in range(grid.shape[0]):
        for col in range(grid.shape[1]):
            if get_frozen_neighbors(grid, row, col) in freeze:
                updated_grid[row, col] = 1
            else:
                updated_grid[row, col] = 0

    return updated_grid


def grid2ascii(grid, ascii_symbol):
    for row_idx, row in enumerate(grid):
        if np.all(row == 0):
            continue  # Skip fully empty rows
        line = ''
        if row_idx % 2 == 0:
            line += ' '  # Offset even rows for hexagonal appearance
        line += ' '.join((ascii_symbol if cell == 1 else ' ') for cell in row)
        print(line)
    print("\n")


if __name__ == "__main__":
    if len(sys.argv) > 1:
        seed = int(sys.argv[1])
    else:
        seed = 40

    np.random.seed(seed)

    # Select symbol and number of iterations based on random seed
    ascii_symbol = np.random.choice(['+', 'X', '*', '#'])
    iterations   = np.random.randint(5, 15)

    # Randomly generate freezing rule based on the seed
    freeze = [1]  # Has to be included, otherwise, we would never start growing
    for i in range(2, 7):
        if np.random.choice([True, False]):
            freeze.append(i)

    grid = np.zeros((ROWS, COLS), dtype=int)

    # Freeze the center cell (We have to start somewhere...)
    center_row, center_col       = ROWS // 2, COLS // 2
    grid[center_row, center_col] = 1

    for _ in range(iterations):
        grid = update_grid(grid, freeze)

    # Finally, print the grid using the selected ASCII symbol
    grid2ascii(grid, ascii_symbol)

Examples of some ❄ that my code has created

seed = 40:

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

seed = 256:

                   +       +       +       +
                    +   +           +   +
              +   +       +       +       +   +
                    +       +   +       +
          +           +               +           +
            +   +   +                   +   +   +
      +   +                   +                   +   +
            +   +   +                   +   +   +
          +           +               +           +
                    +       +   +       +
              +   +       +       +       +   +
                    +   +           +   +
                  +       +       +       +

seed = 9876:

                   # # # #         # # # #
                  #       #       #       #
                 #           # #           #
                #         # #   # #         #
                 #         #     #         #
                    #         #         #
                 # # #       # #       # # #
                #         #   #   #         #
           # #   #   # #             # #   #   # #
          #     # #   # #   #   #   # #   # #     #
         #                                         #
        #             #   #       #   #             #
         #                                         #
          #     # #   # #   #   #   # #   # #     #
           # #   #   # #             # #   #   # #
                #         #   #   #         #
                 # # #       # #       # # #
                    #         #         #
                 #         #     #         #
                #         # #   # #         #
                 #           # #           #
                  #       #       #       #
                   # # # #         # # # #

AI usage disclosure

No AI has been used to generate the code.

Instructions for running my code

Just run python snowflakes.py <your seed> via command line and observe the action.

Lessons learned

I learned a lot about the beauty and symmetry of natural patterns, especially about the physics of snowflakes. I did not dare to even try to mimic the physical process but rather came up with an art-driven approach.

Finally, because of the hexagonal pattern formed by the water molecules, I had to come up with a way to represent a hexagonal grid in an easy way, both for computing the updates, but also for displaying the result.

Upon some research I found that - of course - my solution is far from being unique. There is a GitHub repo that creates colorful snowflakes in a "Game of Hex" fashion and a keen adventurer even dared to use Scratch to simulate snowflakes.

Jun 18 at 10:08, edited Jun 23 at 8:59

1

ᴇɴᴅᴇʀᴍᴀɴ

386
3
23

Great implementation! I would appreciate a little more detailed description of how the snowflake algorithm was implemented though!

Jun 20 at 17:09

1

André

1.8k
12
26

Thanks for your feedback. I edited some more details in. I also think most of the magic is in the evolving pattern, find some bonus code to see the evolution:

import matplotlib.pyplot as plt

def plot_grid(grid):
    """Plot the hexagonal grid."""
    hex_radius = 0.4

    rows, cols = grid.shape
    for row in range(rows):
        for col in range(cols):
            # Calculate hexagon center position
            x = col * 2.0 * hex_radius + (hex_radius if (row % 2 == 0) else 0)
            y = row * np.sqrt(3) * hex_radius

            # Draw pointy-topped hexagons (rotated by 30 degrees)
            angles = [np.pi / 6 + np.pi / 3 * i for i in range(7)]
            x_hex  = [x + hex_radius * np.cos(a) for a in angles]
            y_hex  = [y + hex_radius * np.sin(a) for a in angles]

            # If the cell is frozen, fill it with a different color
            if grid[row, col] == 1:
                plt.fill(x_hex, y_hex, color='blue', alpha=0.8)
            else:
                plt.fill(x_hex, y_hex, color='lightgray', alpha=0.5)

    plt.xlim(-hex_radius, cols * 2.0 * hex_radius + hex_radius)
    plt.ylim(-hex_radius, rows * np.sqrt(3) * hex_radius + hex_radius)
    plt.gca().set_aspect('equal', adjustable='box')
    plt.grid(False)
    plt.axis('off')
    plt.tight_layout()

Example image

Jun 23 at 9:03

0

ᴇɴᴅᴇʀᴍᴀɴ

386
3
23

You're welcome @André! Do you have any feedback to improve my submission?

Just another suggestion - I think it'd be cool to create an animation for each snowflake like in the example image in your comment, that would make your project even cooler than it already is!

Jun 24 at 18:14, edited Jun 24 at 18:23

1

The_spider

1.3k
1
9
21

I do like some of the snowflakes it generates, but for quite a lot of seeds I tried, it generates only simple, not-snowflaky patterns of hexagons. For example, try 1235678, 12358, 1235864, 123864.

Jun 30 at 15:55

1

André

1.8k
12
26

@The_spider - Yes, that is indeed one of the downsides of the method. A big plus, however, is the evolution and simple rules. Feel free to experiment with evolving/changing freezing rules or permanently freezing certain cells that have been frozen for a number of iterations. There is a lot to build on top, but I wanted to keep it simple as a starting point.

Jun 30 at 20:42

13

Nevpzo

187
2
15

OG ASCII Snowflake generator

Some snowflakes I liked

Snowflake 339 | Snowflake 525 | Snowflake 90
   _/\_       |     /\        |     \/    
/_\\\///_\    | __\_\/_/__    | / _\/\/_ \
 \_ /\ _/     |  \\//\\//     |  \_\\//_/
 /‾ \/ ‾\     |  //\\//\\     |  /‾//\\‾\
\‾///\\\‾/    | ‾‾/‾/\‾\‾‾    | \ ‾/\/\‾ /
   ‾\/‾       |     \/        |     /\

Approach

I wanted to keep the simple look of the original ASCII art so I first tried creating my own snowflakes by hand, taking inspiration from here. I figured a 6 rows with 10 columns rectangle of characters worked best.

In python, I split the snowflake creation into four parts:

Start from a core: I hardcoded 4 possible "cores" and a random one is chosen from those.
Base pattern: A small 2x4 pattern generated randomly from seed input.
Horizontal symmetry: Mirroring the base pattern horizontally with specific character mappings.
Vertical symmetry: Mirroring the top half of the snowflake vertically to complete the bottom half.

I used integers and mapped them to characters only at print time. The snowflakes are random based on the inputed seed but given the limited possibilities, I can't fully guarentee that there will be no duplicates. Since the core is always the same, the snowflakes also often look similar.

AI disclosure: I have taken AI (ChatGPT) help just a little for debugging some parts but all design and implementation are mine.

Full code

The seed in set by the user at the very end of the program printFlake(makeFlake(random.randint(0, 999))).

import random

def insertPattern(snowflake, pattern, x1, x2, y1, y2):
    for i, row in enumerate(pattern):
        snowflake[y1 + i][x1:x2] = row

    return snowflake

def basePattern(seed):
    random.seed(seed)
    choices = [0, 1, 2, 3]
    weights = [1, 3, 3, 3]

    return [
        [random.choices(choices, weights=weights)[0] for _ in range(4)],
        [0] + [random.choices(choices, weights=weights)[0] for _ in range(3)]
    ]

def mirrorPattern(pattern, axis):
    if axis == 0:
        mirrorMap = {0:0, 1:2, 2:1, 3:3, 4:4, 5:6, 6:5, 7:7, 8:8}
        rows, cols = 2, 4
        sym = [[0]*cols for _ in range(rows)]

        for i in range(rows):
            for j in range(cols):
                sym[i][cols - 1 - j] = mirrorMap[pattern[i][j]]

    elif axis==1:
        mirrorMap = {0:0, 1:2, 2:1, 3:4, 4:3, 5:7, 6:8, 7:5, 8:6}
        rows, cols = 3, 10
        sym = [[0]*cols for _ in range(rows)]

        for i in range(rows):
            for j in range(cols):
                sym[rows - 1 - i][j] = mirrorMap[pattern[i][j]]
    else:
        raise ValueError('Unknown axis')

    return sym

def createCore(seed):
    tops = [
       [[5, 5, 1, 2, 6, 6],
        [0, 0, 2, 1, 0, 0],
        [0, 0, 1, 2, 0, 0]],

       [[0, 0, 1, 2, 0, 0],
        [0, 0, 2, 1, 0, 0],
        [0, 0, 1, 2, 0, 0]],

       [[0, 0, 2, 1, 0, 0],
        [0, 0, 1, 2, 0, 0],
        [0, 0, 2, 1, 0, 0]],

       [[0, 3, 1, 2, 3, 0],
        [0, 0, 2, 1, 0, 0],
        [0, 0, 1, 2, 0, 0]],
    ]

    return tops[seed % len(tops)]


def makeFlake(seed):
    print(f"Snowflake {seed}:")
    snowflake = [[0]*10 for _ in range(6)]
    
    #Create core of snowflake
    core = createCore(seed)
    snowflake = insertPattern(snowflake, core, 2, 7, 0, 3)

    # Create top of snowflake
    pattern = basePattern(seed)
    horSym = mirrorPattern(pattern, 0)
    snowflake = insertPattern(snowflake, pattern, 0, 4, 1, 3)
    snowflake = insertPattern(snowflake, horSym,  6, 10, 1, 3)
 
    # Mirror on bottom
    verSym = mirrorPattern(snowflake[0:3], 1)
    snowflake = insertPattern(snowflake, verSym, 0, 10, 3, 6)

    return snowflake

# -------------------------------
# PRINTING

def printFlake(snowflake):
    mapping = {
        0: " ",
        1: "/",
        2: "\\",
        3: "_",
        4: "‾",
        5: "⠠",
        6: "⠄",
        7: "⠈",
        8: "⠁"
    }

    for i in range(len(snowflake)):
        row = ""
        for elem in snowflake[i]:
            try:
                row += mapping[elem]
            except:
                row += elem
        print(row)

printFlake(makeFlake(random.randint(0, 999)))

Jun 18 at 23:49, edited Jul 1 at 11:14

0

ᴇɴᴅᴇʀᴍᴀɴ

386
3
23

Great implementation! However, I would love to see additional feature such as added characters and adjustable sizes!

Jun 20 at 17:06

1

Hiroshi Ashikaga

333
4
12

I make the snowflake creation code from scratch. And I think this method could be cool.

My approach

I generate ASCII snowflakes using Python and I grid the snowflake which is centered around the natural hexagonal symmetry of real snowflake. So the core concept is to construct the snowflake layer by layer, expanding outward from a central point. And the snowflake is visualized on a 2D grid of characters. First, I grid the main six primary arms of the snowflake, which extend from the center. And next, I adds smaller, secondary branches to these main arms in an iterative fashion. The main key of the snowflake function is random seek. It governs several key parameters like length of the main arms, branching probability and so on. And Snowflake has symmetrical structure, so identical random decisions are applied across all six arms of the snowflake.
Code

I added comment for each function.

import math
import random
import sys
import time

class Random:
    """A simple pseudo-random number generator for reproducibility."""
    def __init__(self, seed):
        self.seed = int(seed)

    def next(self, min_val, max_val):
        self.seed = (self.seed * 1103515245 + 199552) & 0x7FFFFFFF
        return min_val + (self.seed % (max_val - min_val + 1))

    def choice(self, seq):
        """Picks a random element from a sequence."""
        index = self.next(0, len(seq) - 1)
        return seq[index]

def draw_line(grid, x0, y0, x1, y1, char):
    """Draws a line of characters on the grid using a basic DDA algorithm."""
    size = len(grid)
    dx = x1 - x0
    dy = y1 - y0
    steps = max(abs(dx), abs(dy))
    
    # Avoid division by zero if it's a single point
    if steps == 0:
        if 0 <= x0 < size and 0 <= y0 < size:
            grid[y0][x0] = char
        return

    x_increment = dx / float(steps)
    y_increment = dy / float(steps)

    x, y = float(x0), float(y0)
    for _ in range(int(steps) + 1):
        ix, iy = int(round(x)), int(round(y))
        if 0 <= ix < size and 0 <= iy < size:
            grid[iy][ix] = char
        x += x_increment
        y += y_increment


def generate_snowflake(seed):
    """Generates and prints a more complex snowflake for a given seed."""
    rand = Random(seed)
    size = 45  # Increased size for more detail
    grid = [[' ' for _ in range(size)] for _ in range(size)]
    center_x = size // 2
    center_y = size // 2

    # --- Charactor class ---
    center_chars = ['@', '#', '*', 'O']
    arm_chars = ['|', '-', '/', '\\', '*']
    branch_chars = ['.', ':', "'", '`']
    tip_chars = ['*', 'o', '+', 'x']

    # --- Randomly select characters for this snowflake ---
    center_char = rand.choice(center_chars)
    arm_char = rand.choice(arm_chars)
    branch_char = rand.choice(branch_chars)
    sub_branch_char = rand.choice(branch_chars)
    tip_char = rand.choice(tip_chars)

    grid[center_y][center_x] = center_char

    # --- Generate varied lengths for opposing arms ---
    main_arm_lengths = [rand.next(7, 18) for _ in range(3)]

    for i in range(6):
        # Use mirrored lengths for opposite arms
        main_arm_length = main_arm_lengths[i % 3]

        angle = i * math.pi / 3.0
        end_x = center_x + int(main_arm_length * math.cos(angle))
        # Adjust for character aspect ratio (less aggressive for more variety)
        end_y = center_y + int(main_arm_length * math.sin(angle) * 0.6)

        draw_line(grid, center_x, center_y, end_x, end_y, arm_char)

        # Add a tip
        if 0 <= end_x < size and 0 <= end_y < size:
            grid[end_y][end_x] = tip_char

        # --- Add more complex secondary branches ---
        num_branches = rand.next(2, 5)
        for j in range(1, num_branches + 1):
            # Vary the position along the arm
            branch_pos = rand.next(40, 90) / 100.0
            branch_start_x = int(center_x + branch_pos * (end_x - center_x))
            branch_start_y = int(center_y + branch_pos * (end_y - center_y))

            # Vary the branch length
            branch_length = rand.next(2, main_arm_length // 2)
            
            # Vary the branch angle
            branch_angle_offset = (math.pi / rand.choice([2.5, 3.0, 3.5])) * (1 if rand.next(0, 1) == 0 else -1)

            # Draw two symmetrical branches
            for k in range(2):
                current_branch_angle = angle + branch_angle_offset * (1 if k == 0 else -1)
                branch_end_x = branch_start_x + int(branch_length * math.cos(current_branch_angle))
                branch_end_y = branch_start_y + int(branch_length * math.sin(current_branch_angle) * 0.6)
                draw_line(grid, branch_start_x, branch_start_y, branch_end_x, branch_end_y, branch_char)

                # --- Add a chance for sub-branches (tertiary) ---
                if rand.next(1, 100) > 60: # 40% chance of sub-branch
                    sub_branch_length = rand.next(1, branch_length // 2 + 1)
                    sub_branch_angle_offset = (math.pi / 4.0) * (1 if rand.next(0, 1) == 0 else -1)

                    sub_branch_end_x = branch_end_x + int(sub_branch_length * math.cos(current_branch_angle + sub_branch_angle_offset))
                    sub_branch_end_y = branch_end_y + int(sub_branch_length * math.sin(current_branch_angle + sub_branch_angle_offset) * 0.6)
                    draw_line(grid, branch_end_x, branch_end_y, sub_branch_end_x, sub_branch_end_y, sub_branch_char)


    print(f"Snowflake generated with seed: {seed}")
    for row in grid:
        print("".join(row))

if __name__ == "__main__":
    if len(sys.argv) > 1:
        try:
            seed = int(sys.argv[1])
        except ValueError:
            print("Error: Seed must be an integer.")
            sys.exit(1)
    else:
        seed = int(time.time())

    generate_snowflake(seed)

Example of snowflake output.

Snowflake generated with seed: 1750292063
                                             
                                             
                                             
                                             
                                             
                                             
                                             
                                             
                                             
                                             
                    ```                      
              `       ```                    
              `  `  ``````                   
        `````` `` `     ``     x             
          ````` ``      ````  /              
           `````         `` ````             
          `     /  ``    ` ``````````        
                 /``      `````````          
             ``````       /                  
                   /     /    `              
         `````      /   /    ``` `           
           `````     / /   ``````            
            x``/`/////////```/`/x            
           `````     / /   ``````            
          ````      /   /    ```````         
              `````/     ````  ````   `      
             ``````    `` `````````  `       
            ````````  ` `` /     ````        
            `````/` `` ` `  `````````        
           `````/``` `` ` `` /               
               /`` ``   `` `  /              
              x   `    `` `    x             
                      ` ` `                  
                      ` ``                   
                          `                  
                                             
                                             
                                             
                                             
                                             
                                             
                                             
                                             
                                             
                                             

---------------------------------------------

Snowflake generated with seed: 1750291386
                                             
                                             
                                             
                                             
                                             
                                             
                                             
                                             
                                             
                                             
                                             
                                             
                                             
                                             
                                             
                  :      :                   
             '':::  :    :: x                
                 * ::  :  :::':              
             ::':::::::   *                  
              ::::::     *                   
                    *   *                    
                 '   * *  '''''              
              '':::******:*::x               
                ''   * *  ' ::               
                    *   ::::                 
             ':::::*   : ::::                
            ::::::::    : :::::              
                 *::    :: :::'              
                x   :: ' :: x                
                    '  '

AI disclosure

I didn't use AI to generate the code.

How to run my code?

python snowflakes.py 23849502

What I learn?

An interesting part was porting the line-drawing algorithm. Bresenham's algorithm is a classic, and implementing it in python was straightforward but important step to ensure the arms and branches were rendered correctly on the character grid.

The adjustment for character aspect ratio( *0.5 on the sin calculation for the y-coordinate) remains a crucial detail.

In conclusion, this project shows how simple, repeatable rules can create complex and visually appealing patterns, and it reinforces the timeless appeal of ASCII art as a creative outlet.

Jun 19 at 0:28

1

ᴇɴᴅᴇʀᴍᴀɴ

386
3
23

Great implementation! I would appreciate a little more detailed description of how the snowflake algorithm was implemented though!

Jun 20 at 17:08

1

Avneet K

1

import random

def generate_snowflake(seed: str, size: int = 15):
    random.seed(seed)
    canvas = [[' ' for _ in range(size)] for _ in range(size)]
    center = size // 2
    arms = 6

    
    for i in range(center):
        if random.random() < 0.7:
            canvas[center - i][center] = '*'

    # Reflect that pattern into all 6 arms
    for angle in range(arms):
        radians = angle * (3.14159 / 3)  # 60 degrees
        for r in range(center):
            if canvas[center - r][center] == '*':
                x = int(round(center + r * -1 * round(math.sin(radians), 3)))
                y = int(round(center + r * round(math.cos(radians), 3)))
                if 0 <= x < size and 0 <= y < size:
                    canvas[y][x] = '*'

    
    canvas[center][center] = '+'

    return '\n'.join(''.join(row) for row in canvas)


import math
if __name__ == "__main__":
    print(generate_snowflake("frostbyte"))

Jun 19 at 6:31

0

Rohit Singh

1

function generateSnowflake(seed, size = 21) {
const mid = Math.floor(size / 2);
let grid = Array.from({ length: size }, () => Array(size).fill(' '));

for (let y = 0; y <= mid; y++) {
for (let x = 0; x <= y; x++) {
const randomness = Math.abs(Math.sin(seed + x * 31 + y * 17));
const char = randomness > 0.75 ? '*' : randomness > 0.6 ? '+' : randomness > 0.4 ? '.' : ' ';

  const coords = \[  
    \[ x,  y\], \[ y,  x\],  
    \[-x,  y\], \[-y,  x\],  
    \[ x, -y\], \[ y, -x\],  
    \[-x, -y\], \[-y, -x\],  
  \];  
  for (const \[dx, dy\] of coords) {  
    const px = mid + dx;  
    const py = mid + dy;  
    if (px \>= 0 && px \< size && py \>= 0 && py \< size)  
      grid\[py\]\[px\] = char;  
  }  
}

}

return grid.map(row => row.join('')).join('\n');
}

output will look like :-

                                                              \*...\*          
                                                          +.\*\*\*\*.+        
                                                        \*.\*\*++++\*\*.\*      
                                                         \*.+\*....\*+.\*      
                                                          .+.\*....\*.+.      
                                                         ...+.++.+...      
                                                           ...+....+...      
                                                         .+..+..+..+.      
                                                          .+........+.      
                                                           +......+        
                                                             +..+          
                                                            +......+        
                                                          .+........+.      
                                                         .+..+..+..+.      
                                                          ...+....+...      
                                                        ...+.++.+...      
                                                         .+.\*....\*.+.      
                                                        \*.+\*....\*+.\*      
                                                     \*.\*\*++++\*\*.\*      
                                                        +.\*\*\*\*.+        
                                                           \*...\*

Jun 19 at 9:11

0

Madavi16

21
2

//FOR THE CAT ASCII ART


import random

def decorate_cat(seed="winter"):
    random.seed(seed)

    cat_lines = [
        " /\\_/\\  ",
        "( o.o ) ",
        " > ^ <  "
    ]

  
    flakes = ['❄', '*', '✶', '✳', '❅']

  
    top_decor = ' '.join(random.choices(flakes, k=5))
    bottom_decor = ' '.join(random.choices(flakes, k=5))

 
    decorated_cat = []
    for line in cat_lines:
        left = random.choice(flakes)
        right = random.choice(flakes)
        decorated_cat.append(f"{left} {line} {right}")

 
    print(top_decor)
    for line in decorated_cat:
        print(line)
    print(bottom_decor)


decorate_cat("snowqueen")

// FOR A RANDOM SEED

import random
import math

def generate_snowflake(seed: str, size: int = 11):
    random.seed(seed)
    
    
    grid = [[' ' for _ in range(size)] for _ in range(size)]
    center = size // 2

  
    chars = ['*', '+', 'o', '@', '#', 'x']

    
    def plot_symmetric(x, y, char):
        angles = [0, 60, 120, 180, 240, 300]
        for angle in angles:
            rad = math.radians(angle)
            rx = int(round((x - center) * math.cos(rad) - (y - center) * math.sin(rad))) + center
            ry = int(round((x - center) * math.sin(rad) + (y - center) * math.cos(rad))) + center
            if 0 <= rx < size and 0 <= ry < size:
                grid[ry][rx] = char

   
    for i in range(1, center):
        char = random.choice(chars)
        plot_symmetric(center, center - i, char)

       
        if random.random() < 0.7:
            char = random.choice(chars)
            plot_symmetric(center + 1, center - i, char)
        if random.random() < 0.7:
            char = random.choice(chars)
            plot_symmetric(center - 1, center - i, char)

   
    grid[center][center] = '+'

    
    return '\n'.join(''.join(row) for row in grid)


print(generate_snowflake("frost", size=15))

Jun 20 at 2:20

0

Madavi16

21
2

// OUTPUT

       \   |   /       
        *  o  *        
     *    +    *       
        o  *  o        
       /   |   \

//WE CAN TRY IT WITH DIFFERENT SEEDS :

print(generate_snowflake("crystal"))

print(generate_snowflake("winter"))

print(generate_snowflake("blizzard"))

Jun 20 at 2:23

0

wdce aoe

1
1

#include <stdio.h>

int main()

{

     printf ("hello world\n");
return 0;
}

sry , i am noob. i just want to see other's work.:)

Jun 20 at 8:13, edited Jun 20 at 8:15

4

ᴇɴᴅᴇʀᴍᴀɴ

386
3
23

ASCII Snowflake Generator

Approach

Snowflakes are beautiful, symmetrical, and unique. My approach uses these principles:

Symmetry: Most natural snowflakes have 6-fold (hexagonal) symmetry. We'll draw one "wedge" and replicate it around a central point.
Randomness: Each snowflake is unique. We'll use a random seed to control all randomness in the generation process so the same seed always produces the same snowflake.
ASCII Art: We'll use only printable ASCII characters (*, ., +, |, /, and \).

The main steps:

Seeded Randomness: Use Python's random.seed() so the same seed always produces the same snowflake.
Canvas: Use a 2D list to represent the ASCII grid. The grid is square and the center is the origin.
Arm Generation: For each of the 6 main axes, randomly draw lines and branches according to the provided seed.
Symmetry: Rotate drawn arms to all other axes.
Output: Print the grid as ASCII art.

The Code

import random
import math

def snowflake(seed, size=21):
    """
    Draws a hex-symmetry ASCII snowflake based on a seed.
    size: Must be odd, controls the size of the snowflake
    """
    random.seed(seed)
    if size % 2 == 0:
        size += 1  # Ensure odd size

    grid = [[' ' for _ in range(size)] for _ in range(size)]
    center = size // 2

    # Parameters for snowflake "arms"
    num_arms = 6
    arm_len = center - 1
    arm_chars = ['*', '+', 'o', '.', 'x']
    branch_chars = ['|', '/', '\\', '-', '.']

    # Draw main arms and branches, then rotate for symmetry
    for arm in range(num_arms):
        angle = math.pi/3 * arm  # 60 degrees per arm
        for r in range(1, arm_len+1):
            # Main arm
            x = int(round(center + r * math.cos(angle)))
            y = int(round(center + r * math.sin(angle)))
            grid[y][x] = random.choice(arm_chars)
            # Randomly add a branch
            if r > arm_len//3 and random.random() < 0.2:
                branch_len = random.randint(1, 3)
                branch_angle = angle + (random.choice([-1,1]) * math.pi/6)  # branch out 30 deg
                for b in range(1, branch_len+1):
                    bx = int(round(center + (r + b) * math.cos(branch_angle)))
                    by = int(round(center + (r + b) * math.sin(branch_angle)))
                    if 0 <= bx < size and 0 <= by < size:
                        grid[by][bx] = random.choice(branch_chars)
    # Make it perfectly symmetric by reflecting arms
    # Copy each cell to its 6-fold symmetrical positions
    for y in range(size):
        for x in range(size):
            if grid[y][x] != ' ':
                for arm in range(1, num_arms):
                    angle = math.pi/3 * arm
                    dx = x - center
                    dy = y - center
                    rx = int(round(center + dx * math.cos(angle) - dy * math.sin(angle)))
                    ry = int(round(center + dx * math.sin(angle) + dy * math.cos(angle)))
                    if 0 <= rx < size and 0 <= ry < size:
                        grid[ry][rx] = grid[y][x]

    # Draw the center
    grid[center][center] = '*'

    # Output
    for row in grid:
        print(''.join(row))

# Example snowflakes
print("Snowflake (seed=42):")
snowflake(42)
print("\nSnowflake (seed=stack):")
snowflake("stack")
print("\nSnowflake (seed=overflow):")
snowflake("overflow")

seed = input("Enter a seed: ");
size = int(input("Enter a size: "));
print("Snowflake (seed=" + seed + "):")
snowflake(seed, size)

Examples

Here are the three example snowflakes generated with different seeds:

Snowflake (seed=42):
          .          
         /           
     ++   |   +      
     +x   \   x+     
\     x   -  x      \
 .     x // .x   / . 
  /|\  .+ / +   \|   
    \-  o  .o /-\    
     ///.o o //      
 +        +  . .   + 
 +xxx+++o+*+o+++xxx+ 
 +   . .  +        + 
      // o o.///     
    \-/ o.  o  -\    
   |\   + / +.  \|/  
 . /   x. // x     . 
\      x  -   x     \
     +x   \   x+     
      +   |   ++     
           /         
          .          

Snowflake (seed=stack):
          /          
         .\.         
     ++   -   +      
     +*   .   *+     
      +   |  +       
 / .   o  \ .o   .\/ 
  .-   .+ . +   .-.  
    .|  .  +. \|     
      \.+x x ..      
 +        o  + .   + 
 +*+o+++xo*ox+++o+*+ 
 +   . +  o        + 
      \. x x+.\      
     |  .+  .  |.    
  \-.   + . +.   -.  
 /\.   o. \  o   . / 
       +  |   +      
     +*   .   *+     
      +   -   ++     
         .\.         
          /          

Snowflake (seed=overflow):
          .          
         \\          
     **   |   *      
     *.   -   .*     
\     +   |  +      \
 .     .    ..   \\. 
  \|-  .o   o   -|   
    -|  +  .+  |-    
        .* *         
 *        +  . .   * 
 *.+.oo.*+*+*.oo.+.* 
 *   . .  +        * 
         * *.        
    -|  +.  +  |-    
  \|-   o   o.  -|\  
 . \   ..    .     . 
\      +  |   +     \
     *.   -   .*     
      *   |   **     
          \\         
          .

How to Run

Save the code above as snowflake.py.
Run it from the command line:
```
python3 snowflake.py
```
To generate your own snowflake, call the snowflake() function with your chosen seed and optionally a size (defaults to 21):
```
snowflake("your_seed_here", 21)
```

AI Usage Disclosure

I did not use AI to generate ideas, code, or any part of my Code Challenge description.

What I Learned and Challenges

Symmetry: Rotating and reflecting ASCII art for perfect symmetry is fun but requires careful math, especially on a grid.
Randomness: Using a seed guarantees reproducibility, which is important for this challenge.
ASCII limitations: Limited resolution and character choices mean you have to get creative with how to represent "branches" and "arms."
Open-endedness: There are infinite ways to improve—more realistic branching, different character palettes, color (if using ANSI), or even animated snowflakes!

Happy coding and have fun snowflake-making!

Jun 20 at 14:28, edited Jun 20 at 16:33

16

jwezorek

9.9k
2
36
63

Snowflake Creation Approach

This project generates ASCII images of snowflake-like structures on a hexagonal grid using cellular automata evolved via a simple genetic algorithm.

Each snowflake begins with a randomly initialized state table that governs the automata's behavior. Each initial configuration is created such that it already exhibits six-fold symmetry and the kind of CA rules I use guarantee that the symmetry will be maintained as the automata evolve.

Snowflakes are scored based on structural and aesthetic properties such as connectedness, airiness, spikiness, and cragginess. The top-performing snowflakes are selected, and mixed producing new rule tables -- evolving the population over multiple generations until scores stabilize or a maximum generation is reached.

The hex grid uses "cube coordinates" and is rendered in ASCII using pairs of characters like "[]" or "oo" in a staggered brick-layer layout. This visually approximates a true hex grid and works especially well with monospaced fonts in terminal environments.

Code

The code is written in C++23 and uses only the standard library along with a vendored copy of nlohmann/json. You can view the full source code here:

https://github.com/jwezorek/ascii_snowflake

Example Snowflakes

See the readme in the linked github repo where I have several good ones as images (this Challenge entry won't let me post images...)

Below are some as text but they are too big to fit in the block text window without popping up scroll bars, or are kind of small :

                                    <><>    ()                          ()    <><>
                                   {}    ()()                            ()()    {}
                                    <>  <>  []()                      ()[]  <>  <>
                                     ()<>  <>()    <>            <>    ()<>  <>()
                        <>{}          {}[]<>          ()      ()          <>[]{}          {}<>
                       <>  <>          <>        []  ()[][][][]()  []        <>          <>  <>
                            ()    <><>  []    <>()                  ()<>    []  <><>    ()
                       ()<><>{}  <>  <>    []        ()  [][]  ()        []    <>  <>  {}<><>()
                    ()()    []<>  <>  ()        ()    []      []    ()        ()  <>  <>[]    ()()
                       []<><>  []  ()<>  ()  []()  []  []    []  []  ()[]  ()  <>()  []  <><>[]
                      ()()            <>[]    <><>()[]    <>    []()<><>    []<>            ()()
                               []  ()[]()            []        []            ()[]()  []
                            <>          ()        []()          ()[]        ()          <>
                     <>  []()    []              []  {}        {}  []              []    ()[]  <>
                              ()()<>          <>()    []()<>()[]    ()<>          <>()()
                     ()()        <>            []  []  ()    ()  []  []            <>        ()()
                      []  ()  []()      <>  [][]<>  ()          ()  <>[][]  <>      ()[]  ()  []
                     []    []  []  [][]()[][]  <>{}                {}<>  [][]()[][]  []  []    []
                    []  []  []  []()      <><>{}  {}  <>      <>  {}  {}<><>      ()[]  []  []  []
                 ()[]  []          {}  []  {}  [][]  <>        <>  [][]  {}  []  {}          []  []()
              <>  ()        <>      []  ()  {}[]    []          []    []{}  ()  []      <>        ()  <>
                     ()[][]        ()()          ()<>()        ()<>()          ()()        [][]()
      ()  ()    []                <>      <><>[]<>                  <>[]<><>      <>                []    ()  ()
       ()[]()    ()    [][][]    ()            ()  <>  ()    ()  <>  ()            ()    [][][]    ()    ()[]()
      ()  <>    <>  ()  ()  (){}[]()                  <><>  <><>                  ()[]{}()  ()  ()  <>    <>  ()
   <>  <>  <>        ()<>  []                    ()<>[]()[][]()[]<>()                    []  <>()        <>  <>  <>
  <>    <>[]    []  []<>    []  []()  <>          <>()[]{}[]{}[]()<>          <>  ()[]  []    <>[]  []    []<>    <>
   {}<>(){}<>[]              ()        <>          []{}  ()()  {}[]          <>        ()              []<>{}()<>{}
                  ()        <>[]<>{}{}  []()  ()<>[][]()      ()[][]<>()  ()[]  {}{}<>[]<>        ()
           <><>()  []          []<>  []  <>    <>(){}()        (){}()<>    <>  []  <>[]          []  ()<><>
          <>    <><>()()      []  {}[]  ()  <>  [][]              [][]  <>  ()  []{}  []      ()()<><>    <>
           <><>()  []          []<>  []  <>    <>(){}()        (){}()<>    <>  []  <>[]          []  ()<><>
                  ()        <>[]<>{}{}  []()  ()<>[][]()      ()[][]<>()  ()[]  {}{}<>[]<>        ()
   {}<>(){}<>[]              ()        <>          []{}  ()()  {}[]          <>        ()              []<>{}()<>{}
  <>    <>[]    []  []<>    []  []()  <>          <>()[]{}[]{}[]()<>          <>  ()[]  []    <>[]  []    []<>    <>
   <>  <>  <>        ()<>  []                    ()<>[]()[][]()[]<>()                    []  <>()        <>  <>  <>
      ()  <>    <>  ()  ()  (){}[]()                  <><>  <><>                  ()[]{}()  ()  ()  <>    <>  ()
       ()[]()    ()    [][][]    ()            ()  <>  ()    ()  <>  ()            ()    [][][]    ()    ()[]()
      ()  ()    []                <>      <><>[]<>                  <>[]<><>      <>                []    ()  ()
                     ()[][]        ()()          ()<>()        ()<>()          ()()        [][]()
              <>  ()        <>      []  ()  {}[]    []          []    []{}  ()  []      <>        ()  <>
                 ()[]  []          {}  []  {}  [][]  <>        <>  [][]  {}  []  {}          []  []()
                    []  []  []  []()      <><>{}  {}  <>      <>  {}  {}<><>      ()[]  []  []  []
                     []    []  []  [][]()[][]  <>{}                {}<>  [][]()[][]  []  []    []
                      []  ()  []()      <>  [][]<>  ()          ()  <>[][]  <>      ()[]  ()  []
                     ()()        <>            []  []  ()    ()  []  []            <>        ()()
                              ()()<>          <>()    []()<>()[]    ()<>          <>()()
                     <>  []()    []              []  {}        {}  []              []    ()[]  <>
                            <>          ()        []()          ()[]        ()          <>
                               []  ()[]()            []        []            ()[]()  []
                      ()()            <>[]    <><>()[]    <>    []()<><>    []<>            ()()
                       []<><>  []  ()<>  ()  []()  []  []    []  []  ()[]  ()  <>()  []  <><>[]
                    ()()    []<>  <>  ()        ()    []      []    ()        ()  <>  <>[]    ()()
                       ()<><>{}  <>  <>    []        ()  [][]  ()        []    <>  <>  {}<><>()
                            ()    <><>  []    <>()                  ()<>    []  <><>    ()
                       <>  <>          <>        []  ()[][][][]()  []        <>          <>  <>
                        <>{}          {}[]<>          ()      ()          <>[]{}          {}<>
                                     ()<>  <>()    <>            <>    ()<>  <>()
                                    <>  <>  []()                      ()[]  <>  <>
                                   {}    ()()                            ()()    {}
                                    <><>    ()                          ()    <><>

                                        []                                          []
                                       []{}                                        {}[]
                                {}  []{}      <>()      [][]      [][]      ()<>      {}[]  {}
                                 {}<>{}{}    [][]{}    {}[][]    [][]{}    {}[][]    {}{}<>{}
                              []<>    {}{}()  ()[]      <>  {}  {}  <>      []()  (){}{}    <>[]
                         [][]{}{}      <>{}    <>[]  ()()    ()()    ()()  []<>    {}<>      {}{}[][]
                          {}  {}{}    [][][]  []{}      []()      ()[]      {}[]  [][][]    {}{}  {}
                               {}<>[]  []  ()()()(){}    ()        ()    {}()()()()  []  []<>{}
                              (){}[][]    {}    []    <><><>      <><><>    []    {}    [][]{}()
                         <>[]    []      []  <>  []<>        ()()        <>[]  <>  []      []    []<>
                        ()[]()    (){}[]{}[]()[]  ()  []<><>{}{}{}<><>[]  ()  []()[]{}[]{}()    ()[]()
                         {}[]<>[]()    []  {}()  ()[]{}()    {}{}    (){}[]()  (){}  []    ()[]<>[]{}
                            []{}()  <>(){}<>    {}  {}[]      {}      []{}  {}    <>{}()<>  (){}[]
                               ()[]  []()        {}  ()<>            <>()  {}        ()[]  []()
                    []{}  ()  {}  []          {}[]{}{}(){}{}      {}{}(){}{}[]{}          []  {}  ()  {}[]
                   [][]<>()      <>()(){}  {}{}  {}[][]{}  <>    <>  {}[][]{}  {}{}  {}()()<>      ()<>[][]
                    []    []  <>    []  {}[]    ()  ()<>  <>()  ()<>  <>()  ()    []{}  []    <>  []    []
                     {}  ()()<>  []{}{}  {}{}()  {}<>    {}<>{}{}<>{}    <>{}  (){}{}  {}{}[]  <>()()  {}
                      ()    <>  <>()[](){}[]  {}[]    ()[]{}<>{}<>{}[]()    []{}  []{}()[]()<>  <>    ()
               [][]{}()        <>    <>()[]()<>  []{}[]{}{}<>{}{}<>{}{}[]{}[]  <>()[]()<>    <>        (){}[][]
              [][]          (){}      {}{}<>    {}[]    <>          <>    []{}    <>{}{}      {}()          [][]
               {}<>  ()    (){}{}    {}      ()[]    ()  <>[]    []<>  ()    []()      {}    {}{}()    ()  <>{}
                  ()[]()<>  {}{}{}    <><>{}[]{}  ()      {}()()(){}      ()  {}[]{}<><>    {}{}{}  <>()[]()
                 ()    <>  <>          ()<>{}{}<>      {}{}        {}{}      <>{}{}<>()          <>  <>    ()
          (){}        <>  <>            {}<><>  <>  {}  {}{}      {}{}  {}  <>  <><>{}            <>  <>        {}()
         <>[][][]  {}    []()    {}<>(){}{}{}  []{}{}{}{}  {}    {}  {}{}{}{}[]  {}{}{}()<>{}    ()[]    {}  [][][]<>
          []()<>{}()  <>  {}[]<>{}  <><><>{}    ()  {}  [][]      [][]  {}  ()    {}<><><>  {}<>[]{}  <>  (){}<>()[]
   []{}        []()[][]()[]{}()(){}  {}{}<>    ()    {}[]<>        <>[]{}    ()    <>{}{}  {}()(){}[]()[][]()[]        {}[]
    []    ()    ()      ()    {}[]<>  []{}  []()            {}  {}            ()[]  {}[]  <>[]{}    ()      ()    ()    []
     {}{}{}{}[]()  <>[]  {}{}{}[]()  (){}<><>{}          {}  [][]  {}          {}<><>{}()  ()[]{}{}{}  []<>  ()[]{}{}{}{}
    []{}{}<>[]  {}  ()()    []{}  <>  []      {}{}{}      [][]<>[][]      {}{}{}      []  <>  {}[]    ()()  {}  []<>{}{}[]
     <>    [][]  [][]{}    {}  (){}  {}  ()  {}{}  []  {}[]<>    <>[]{}  []  {}{}  ()  {}  {}()  {}    {}[][]  [][]    <>
  {}{}            {}  <>    {}    [][][]        {}[]<>    []      []    <>[]{}        [][][]    {}    <>  {}            {}{}
     <>    [][]  [][]{}    {}  (){}  {}  ()  {}{}  []  {}[]<>    <>[]{}  []  {}{}  ()  {}  {}()  {}    {}[][]  [][]    <>
    []{}{}<>[]  {}  ()()    []{}  <>  []      {}{}{}      [][]<>[][]      {}{}{}      []  <>  {}[]    ()()  {}  []<>{}{}[]
     {}{}{}{}[]()  <>[]  {}{}{}[]()  (){}<><>{}          {}  [][]  {}          {}<><>{}()  ()[]{}{}{}  []<>  ()[]{}{}{}{}
    []    ()    ()      ()    {}[]<>  []{}  []()            {}  {}            ()[]  {}[]  <>[]{}    ()      ()    ()    []
   []{}        []()[][]()[]{}()(){}  {}{}<>    ()    {}[]<>        <>[]{}    ()    <>{}{}  {}()(){}[]()[][]()[]        {}[]
          []()<>{}()  <>  {}[]<>{}  <><><>{}    ()  {}  [][]      [][]  {}  ()    {}<><><>  {}<>[]{}  <>  (){}<>()[]
         <>[][][]  {}    []()    {}<>(){}{}{}  []{}{}{}{}  {}    {}  {}{}{}{}[]  {}{}{}()<>{}    ()[]    {}  [][][]<>
          (){}        <>  <>            {}<><>  <>  {}  {}{}      {}{}  {}  <>  <><>{}            <>  <>        {}()
                 ()    <>  <>          ()<>{}{}<>      {}{}        {}{}      <>{}{}<>()          <>  <>    ()
                  ()[]()<>  {}{}{}    <><>{}[]{}  ()      {}()()(){}      ()  {}[]{}<><>    {}{}{}  <>()[]()
               {}<>  ()    (){}{}    {}      ()[]    ()  <>[]    []<>  ()    []()      {}    {}{}()    ()  <>{}
              [][]          (){}      {}{}<>    {}[]    <>          <>    []{}    <>{}{}      {}()          [][]
               [][]{}()        <>    <>()[]()<>  []{}[]{}{}<>{}{}<>{}{}[]{}[]  <>()[]()<>    <>        (){}[][]
                      ()    <>  <>()[](){}[]  {}[]    ()[]{}<>{}<>{}[]()    []{}  []{}()[]()<>  <>    ()
                     {}  ()()<>  []{}{}  {}{}()  {}<>    {}<>{}{}<>{}    <>{}  (){}{}  {}{}[]  <>()()  {}
                    []    []  <>    []  {}[]    ()  ()<>  <>()  ()<>  <>()  ()    []{}  []    <>  []    []
                   [][]<>()      <>()(){}  {}{}  {}[][]{}  <>    <>  {}[][]{}  {}{}  {}()()<>      ()<>[][]
                    []{}  ()  {}  []          {}[]{}{}(){}{}      {}{}(){}{}[]{}          []  {}  ()  {}[]
                               ()[]  []()        {}  ()<>            <>()  {}        ()[]  []()
                            []{}()  <>(){}<>    {}  {}[]      {}      []{}  {}    <>{}()<>  (){}[]
                         {}[]<>[]()    []  {}()  ()[]{}()    {}{}    (){}[]()  (){}  []    ()[]<>[]{}
                        ()[]()    (){}[]{}[]()[]  ()  []<><>{}{}{}<><>[]  ()  []()[]{}[]{}()    ()[]()
                         <>[]    []      []  <>  []<>        ()()        <>[]  <>  []      []    []<>
                              (){}[][]    {}    []    <><><>      <><><>    []    {}    [][]{}()
                               {}<>[]  []  ()()()(){}    ()        ()    {}()()()()  []  []<>{}
                          {}  {}{}    [][][]  []{}      []()      ()[]      {}[]  [][][]    {}{}  {}
                         [][]{}{}      <>{}    <>[]  ()()    ()()    ()()  []<>    {}<>      {}{}[][]
                              []<>    {}{}()  ()[]      <>  {}  {}  <>      []()  (){}{}    <>[]
                                 {}<>{}{}    [][]{}    {}[][]    [][]{}    {}[][]    {}{}<>{}
                                {}  []{}      <>()      [][]      [][]      ()<>      {}[]  {}
                                       []{}                                        {}[]
                                        []                                          []

                  <><>
                 ()  ()
            <><>        <><>
         <>[]  <>      <>  []<>
        <>    ()[]    []()    <>
   <>()  <>()()          ()()<>  ()<>
  <>      []  ()<><><><>()  []      <>
   ()        <>          <>        ()
            <>    {}{}    <>
   <><>[]  <>  {}{}  {}{}  <>  []<><>
  <>  ()  <>  {}        {}  <>  ()  <>
   []  ()()    {}      {}    ()()  []
  <>  ()  <>  {}        {}  <>  ()  <>
   <><>[]  <>  {}{}  {}{}  <>  []<><>
            <>    {}{}    <>
   ()        <>          <>        ()
  <>      []  ()<><><><>()  []      <>
   <>()  <>()()          ()()<>  ()<>
        <>    ()[]    []()    <>
         <>[]  <>      <>  []<>
            <><>        <><>
                 ()  ()
                  <><>

                                  {}  {}
                                   {}{}
                                {}{}  {}{}
                             {}  ()    ()  {}

                             {}  <>    <>  {}
                                  <>  <>
                     <><>{}    <><>    <><>    {}<><>
                    <>    {}  {}          {}  {}    <>
           {}      {}    <>{}<><>{}    {}<><>{}<>    {}      {}
    {}  {}    {}    {}<><>{}{}  {}      {}  {}{}<><>{}    {}    {}  {}
     {}{}()          {}{}  <>  {}        {}  <>  {}{}          (){}{}
  {}{}      <>  <>{}<>{}<><>  {}          {}  <><>{}<>{}<>  <>      {}{}
     {}      <><>  <>        {}{}        {}{}        <>  <><>      {}
    {}()          {}{}{}{}{}{}  {}      {}  {}{}{}{}{}{}          (){}
         <><>            {}  {}    {}{}    {}  {}            <><>
    {}      <>            {}        {}        {}            <>      {}
       {}  <>  {}                                        {}  <>  {}
            {}<>{}        {}      {}{}{}      {}        {}<>{}
             <>  {}      {}{}  {}{}<><>{}{}  {}{}      {}  <>
        {}{}{}{}  {}{}{}      {}<>{}  {}<>{}      {}{}{}  {}{}{}{}
       <>  <>{}<>  {}        {}<>  <><>  <>{}        {}  <>{}<>  <>
      <>    <>  <>  {}{}      {}{}<>  <>{}{}      {}{}  <>  <>    <>
       <>  <>{}<>  {}        {}<>  <><>  <>{}        {}  <>{}<>  <>
        {}{}{}{}  {}{}{}      {}<>{}  {}<>{}      {}{}{}  {}{}{}{}
             <>  {}      {}{}  {}{}<><>{}{}  {}{}      {}  <>
            {}<>{}        {}      {}{}{}      {}        {}<>{}
       {}  <>  {}                                        {}  <>  {}
    {}      <>            {}        {}        {}            <>      {}
         <><>            {}  {}    {}{}    {}  {}            <><>
    {}()          {}{}{}{}{}{}  {}      {}  {}{}{}{}{}{}          (){}
     {}      <><>  <>        {}{}        {}{}        <>  <><>      {}
  {}{}      <>  <>{}<>{}<><>  {}          {}  <><>{}<>{}<>  <>      {}{}
     {}{}()          {}{}  <>  {}        {}  <>  {}{}          (){}{}
    {}  {}    {}    {}<><>{}{}  {}      {}  {}{}<><>{}    {}    {}  {}
           {}      {}    <>{}<><>{}    {}<><>{}<>    {}      {}
                    <>    {}  {}          {}  {}    <>
                     <><>{}    <><>    <><>    {}<><>
                                  <>  <>
                             {}  <>    <>  {}

                             {}  ()    ()  {}
                                {}{}  {}{}
                                   {}{}
                                  {}  {}

AI Usage Disclosure

ChatGPT was used lightly during development to help generate boilerplate code for parsing settings JSON, and to brainstorm possible spikiness metrics. All core logic, data structures, and algorithms were written manually.

Instructions for Running the Code

Clone the repository from GitHub.
Ensure you have a modern C++ compiler that supports C++23.
Build the project using CMake.
Run the program with:

ascii_snowflake.exe settings.json [optional seed]
Customize settings.json to adjust the number of generations, scoring weights, or snowflake complexity. There is a sample JSON file in the repo

Reflections and Challenges

The genetic algorithm right now actually does optimize the scores more quickly than, say, totally random generation plus testing would; however, the challenge is making the scores be meaningful, i.e. run the program and you can watch the mean score for snowflakes in the population go up across generations, but the hard part is making those number reflect cool looking snowflakes.

The main thing that I noticed is that random hexagons filled with six-fold symmetrical pixels do not look like snowflakes if they are dense. They look like hexagons. Snowflakes are full of empty space and are spiky and dendritic ... so I tried to find metrics that measure that.

Jun 22 at 3:30, edited Jun 24 at 17:26

0

Pranshu Chourasia

1

❄ ASCII Snowflake Generator

Approach

Snowflakes are naturally hexagonal and symmetrical — typically 6-fold radial symmetry. To simulate this in ASCII, we:

Use a random seed to ensure repeatable, unique snowflakes.
Generate a single branch pattern using characters like *, +, /, |, \, and o.
Mirror and rotate that branch across 6 directions (every 60 degrees).
Use a 2D grid (matrix) to plot ASCII characters based on coordinate transformations.

The symmetry and randomness ensure both uniqueness and a consistent snowflake shape.

Example Output

Here are 3 snowflakes generated using different seeds:

Seed: winter-2024

markdown

* +o+ *oo+++oo* *o+ +o* + + *o+ +o* *oo+++oo* +o+ *

Seed: ice-crystal

markdown

* *+* *+ooo+* *o+ +o* o o *o+ +o* *+ooo+* *+* *

Seed: flake-42

markdown

* o+o *oo+oo* o+ +o + + o+ +o *oo+oo* o+o *

Code (Python 3)

python

import random def generate_snowflake(seed: str, size: int = 5) -> list[str]: random.seed(seed) grid_size = size * 2 + 1 grid = [[' ' for _ in range(grid_size)] for _ in range(grid_size)] mid = size # Define the characters that can appear in a snowflake arm characters = ['*', '+', 'o'] # Generate arm pattern arm = [] for i in range(1, size + 1): char = random.choice(characters) arm.append((i, 0, char)) # Helper to rotate a point 60 degrees n times def rotate(x, y, times): for _ in range(times): x, y = -y, x + y return x, y # Place symmetric arms for dx, dy, ch in arm: for i in range(6): # 6-way symmetry rx, ry = rotate(dx, dy, i) gx, gy = mid + rx, mid + ry if 0 <= gx < grid_size and 0 <= gy < grid_size: grid[gy][gx] = ch # Place center grid[mid][mid] = '*' return [''.join(row) for row in grid] def print_snowflake(seed): lines = generate_snowflake(seed) for line in lines: print(line) # Example usage if __name__ == "__main__": seeds = ["winter-2024", "ice-crystal", "flake-42"] for s in seeds: print(f"\nSeed: {s}") print_snowflake(s)

How to Run

Save the code as ascii_snowflake.py.
Run it using Python 3:

bash

CopyEdit

python ascii_snowflake.py

You can change the seed string or the size parameter to generate different snowflakes.

AI Usage Disclosure

The core idea, coordinate rotation math, and formatting were implemented by me. I used AI (ChatGPT) to assist in refining symmetry logic and producing clean sample outputs. All code is original and written specifically for this challenge.

What I Learned

Handling symmetrical rotations with coordinate transformations can be elegant and efficient in ASCII art.
ASCII limitations push you to think about minimal expressive characters.
Randomization with a fixed seed is a great way to simulate uniqueness deterministically.

Jun 22 at 17:23

1

Prashant Choudhary

1
1

A Point-Based Recursive Snowflake Generator

Hello everyone, here is my entry for the ASCII art snowflake challenge. My approach focuses on creating a mathematical representation of the snowflake first, then rendering it to an ASCII grid.

1. Explanation of the Snowflake Creation Approach

This program generates snowflakes using a two-step process that separates the geometric creation from the visual rendering.

Geometric Generation (The Point Cloud): The core of the generator does not draw on a grid directly. Instead, it creates a set of 2D coordinates representing a single, 60-degree wedge of the snowflake. This is achieved through a recursive function (grow_branch) that simulates dendritic growth:
- It starts at the origin (0,0) and grows a main arm.
- At intervals along the arm, there is a seeded probability of spawning new sub-branches at +/- 60-degree angles.
- This process continues for a set number of levels, creating a complex, feathery structure for one-sixth of the snowflake. All the (x, y) coordinates of this "base arm" are stored in a set to avoid duplicates.
Symmetry and Rendering (The ASCII Grid): Once the base arm is complete, the six-fold symmetry is achieved mathematically:
- Every point in the base arm set is rotated five times (by 60, 120, 180, 240, and 300 degrees) using a standard 2D rotation matrix.
- The original points and all rotated points are collected into a final set, representing the full snowflake's geometry.
- Finally, these coordinates are mapped onto a 2D character grid, with the origin (0,0) placed at the center. Each coordinate is filled with a * character to produce the final ASCII art.

This point-based method ensures perfect rotational symmetry and provides a clean separation between the generation logic and the final output. The entire process is deterministic, with the initial seed dictating every random choice made during the growth phase.

2. The Code

The code is written in Python and uses only the standard math, random, and sys libraries.

import math
import random
import sys

def rotate_point(x, y, angle_deg):
    rad = math.radians(angle_deg)
    x2 = x * math.cos(rad) - y * math.sin(rad)
    y2 = x * math.sin(rad) + y * math.cos(rad)
    return (x2, y2)

class SnowflakeGenerator:
    def __init__(self, seed):
        self.seed = seed
        random.seed(seed)
        self.length_min = [5, 3, 1]
        self.length_max = [10, 5, 2]
        self.branch_prob = [0.4, 0.3, 0.1]
        self.max_level = 2
        self.base_arm = set()
    
    def grow_branch(self, start_x, start_y, angle, level):
        if level >= self.max_level:
            return
        
        L = random.randint(self.length_min[level], self.length_max[level])
        step_x = math.cos(math.radians(angle))
        step_y = math.sin(math.radians(angle))
        
        for i in range(1, L+1):
            nx = start_x + i * step_x
            ny = start_y + i * step_y
            self.base_arm.add((round(nx, 2), round(ny, 2)))
            
            if i < L and random.random() < self.branch_prob[level]:
                self.grow_branch(nx, ny, angle + 60, level + 1)
                self.grow_branch(nx, ny, angle - 60, level + 1)
    
    def generate_snowflake_points(self):
        self.base_arm.add((0,0))
        self.grow_branch(0, 0, 0, 0)
        
        full_snowflake = set()
        rotations = [0, 60, 120, 180, 240, 300]
        
        for point in self.base_arm:
            x, y = point
            for angle in rotations:
                x_rot, y_rot = rotate_point(x, y, angle)
                ix = int(round(x_rot))
                iy = int(round(y_rot))
                full_snowflake.add((ix, iy))
        
        return full_snowflake

def draw_ascii_snowflake(seed, grid_size=40):
    generator = SnowflakeGenerator(seed)
    points = generator.generate_snowflake_points()
    
    cx = grid_size // 2
    cy = grid_size // 2
    grid = [[' ' for _ in range(grid_size)] for _ in range(grid_size)]
    
    for (x, y) in points:
        ix = x + cx
        iy = y + cy
        if 0 <= ix < grid_size and 0 <= iy < grid_size:
            grid[iy][ix] = '*'
    
    return grid

def print_snowflake(grid):
    for row in grid:
        print(''.join(row))

if __name__ == "__main__":
    # The default seed in the provided script was 446.
    # It has been changed to 42 for a more classic example.
    seed = int(sys.argv[1]) if len(sys.argv) > 1 else 42
    grid = draw_ascii_snowflake(seed)
    print_snowflake(grid)

3. Example Snowflakes

Here are a few examples generated with different integer seeds, showcasing the variety of shapes the program can create.

Seed: 42

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

Seed: 1337

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

4. AI Usage Disclosure

The Python code for the snowflake generator was provided by the user. This submission text, including the explanation, examples, and analysis, was written with AI assistance to structure the content clearly and professionally based on the provided script.

5. Instructions For How To Run

Save the code above as a Python file (e.g., snowflake_points.py).
Open your terminal or command prompt.
Run the script using Python 3. You can provide an optional integer as a seed.

Syntax: python snowflake_points.py [seed]

Examples:

To generate a snowflake with the seed 123: python snowflake_points.py 123
To generate a default snowflake (using seed 42): python snowflake_points.py

6. Learnings & Interesting Challenges

Separation of Concerns: The most significant design lesson from this approach is the clean separation of the mathematical model (the set of points) from the visual representation (the ASCII grid). This makes the generation logic independent of the output format. You could easily adapt this to render the points in a graphics library like Pygame or Matplotlib without changing the SnowflakeGenerator class at all.
Point-Based Flexibility: Working with a cloud of points is very flexible. It neatly sidesteps many of the complexities of trying to draw lines directly on a discrete grid, such as dealing with Bresenham's line algorithm or anti-aliasing.
Challenge: Floating Point vs. Grid: A subtle but important challenge is converting the floating-point coordinates from the rotation calculations into integer grid coordinates. This script handles it by rounding each coordinate. This can cause some points to clump together or create tiny gaps, but this slight imprecision often adds to the organic feel of the final ASCII art, preventing it from looking too perfect.

Jun 23 at 13:14

0

Bhargav

4.7k
2
12
29

Tech Nostalgia Hook - Live Demo

I developed an interactive web-based ASCII snowflake generator that creates unique, mathematically symmetric snowflakes from any seed input. The approach focuses on:

Core Algorithm:

Seeded Random Generation: Uses a hash-based seeded random number generator to ensure the same seed always produces identical snowflakes
6-fold Rotational Symmetry: Generates one 60-degree segment, then applies it 6 times with mathematical rotation to create realistic snowflake symmetry
Branching Logic: Creates main branches along radial lines with probability-based side branches for natural variation
Pure ASCII Output: Uses only standard ASCII characters (*, +, -, |, #, @, etc.) for true compatibility

Try here - Live Demo

Code

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>ASCII Snowflake Generator</title>
    <style>
        body {
            font-family: 'Segoe UI', system-ui, sans-serif;
            max-width: 1000px;
            margin: 0 auto;
            padding: 20px;
            background: #1a1a2e;
            color: #eee;
        }

        .header {
            text-align: center;
            margin-bottom: 30px;
        }

        h1 {
            color: #64b5f6;
            margin-bottom: 10px;
        }

        .controls {
            display: grid;
            grid-template-columns: repeat(auto-fit, minmax(250px, 1fr));
            gap: 20px;
            margin-bottom: 30px;
            background: #16213e;
            padding: 20px;
            border-radius: 8px;
        }

        .control-group {
            display: flex;
            flex-direction: column;
            gap: 10px;
        }

        label {
            font-weight: 600;
            color: #64b5f6;
        }

        input, select, button {
            padding: 8px 12px;
            border: 1px solid #333;
            border-radius: 4px;
            background: #0f1419;
            color: #eee;
            font-size: 14px;
        }

        input:focus, select:focus {
            outline: none;
            border-color: #64b5f6;
        }

        button {
            background: #64b5f6;
            color: #000;
            font-weight: 600;
            cursor: pointer;
            transition: background 0.2s;
        }

        button:hover {
            background: #42a5f5;
        }

        .output {
            background: #000;
            border: 2px solid #333;
            border-radius: 8px;
            padding: 20px;
            margin: 20px 0;
        }

        .snowflake {
            font-family: 'Courier New', monospace;
            font-size: 14px;
            line-height: 1.2;
            color: #64b5f6;
            white-space: pre;
            text-align: center;
            letter-spacing: 1px;
        }

        .info {
            text-align: center;
            color: #888;
            margin-top: 10px;
            font-size: 12px;
        }

        .batch-grid {
            display: grid;
            grid-template-columns: repeat(auto-fit, minmax(300px, 1fr));
            gap: 20px;
        }

        .examples {
            margin-top: 30px;
            padding: 20px;
            background: #16213e;
            border-radius: 8px;
        }

        .examples h3 {
            color: #64b5f6;
            margin-bottom: 15px;
        }

        .example-item {
            margin: 15px 0;
            font-family: 'Courier New', monospace;
            font-size: 12px;
            color: #aaa;
        }
    </style>
</head>
<body>
    <div class="header">
        <div style="display: flex; align-items: center; justify-content: center; gap: 20px; margin-bottom: 20px;">
            <div style="font-family: 'Courier New', monospace; color: #f48024; font-size: 24px; font-weight: bold;">
                stack<span style="color: #64b5f6;">overflow</span>
            </div>
            <div style="color: #888; font-size: 18px;">×</div>
            <h1 style="margin: 0; color: #64b5f6;">❄️ ASCII Snowflake Generator</h1>
        </div>
        <p>Generate unique snowflakes using any seed - same seed = same snowflake</p>
        <div style="margin-top: 15px; padding: 10px; background: rgba(244, 128, 36, 0.1); border-left: 3px solid #f48024; border-radius: 4px;">
            <small style="color: #f48024;">🏆 Stack Overflow Code Challenge #3 Solution</small>
        </div>
    </div>

    <div class="controls">
        <div class="control-group">
            <label for="seed">Seed (any text/number):</label>
            <input type="text" id="seed" value="stackoverflow" placeholder="Enter seed...">
        </div>
        
        <div class="control-group">
            <label for="size">Size:</label>
            <select id="size">
                <option value="11">Small (11x11)</option>
                <option value="15" selected>Medium (15x15)</option>
                <option value="19">Large (19x19)</option>
                <option value="23">Extra Large (23x23)</option>
            </select>
        </div>

        <div class="control-group">
            <label for="style">Style:</label>
            <select id="style">
                <option value="classic">Classic (* + - | o)</option>
                <option value="dense">Dense (# @ % & $)</option>
                <option value="minimal">Minimal (. o * -)</option>
                <option value="mixed">Mixed (all ASCII)</option>
            </select>
        </div>

        <div class="control-group">
            <button onclick="generate()">Generate Single</button>
            <button onclick="generateBatch()">Generate 4 Variations</button>
            <button onclick="randomSeed()">Random Seed</button>
        </div>
    </div>

    <div id="output"></div>

    <div class="examples">
        <h3>How it works:</h3>
        <div class="example-item">• Each seed produces a unique, reproducible snowflake</div>
        <div class="example-item">• Try seeds like: "stackoverflow", "12345", "snow", "your-name"</div>
        <div class="example-item">• Same seed always generates the same pattern</div>
        <div class="example-item">• Uses only pure ASCII characters (no Unicode)</div>
    </div>

    <script>
        class SimpleSnowflakeGenerator {
            constructor() {
                this.chars = {
                    classic: ['*', '+', '-', '|', 'o', '.', 'x'],
                    unicode: ['❄', '❅', '❆', '✦', '✧', '✶', '*'],
                    minimal: ['.', 'o', '*', '°', '·'],
                    bold: ['#', '@', '%', '&', '$', '■', '▲']
                };
            }

            // Simple seeded random
            hash(str) {
                let hash = 0;
                for (let i = 0; i < str.length; i++) {
                    const char = str.charCodeAt(i);
                    hash = ((hash << 5) - hash) + char;
                    hash = hash & hash;
                }
                return Math.abs(hash);
            }

            seededRandom(seed) {
                let value = this.hash(seed.toString());
                return function() {
                    value = (value * 16807) % 2147483647;
                    return (value - 1) / 2147483646;
                };
            }

            generate(seed, size, style) {
                const rng = this.seededRandom(seed);
                const chars = this.chars[style];
                const grid = Array(size).fill().map(() => Array(size).fill(' '));
                const center = Math.floor(size / 2);
                
                // Generate one 60-degree segment
                const points = this.generateSegment(rng, center, chars);
                
                // Apply 6-fold symmetry
                for (let rotation = 0; rotation < 6; rotation++) {
                    const angle = rotation * Math.PI / 3;
                    points.forEach(point => {
                        const cos = Math.cos(angle);
                        const sin = Math.sin(angle);
                        const x = Math.round(point.x * cos - point.y * sin) + center;
                        const y = Math.round(point.x * sin + point.y * cos) + center;
                        
                        if (x >= 0 && x < size && y >= 0 && y < size) {
                            grid[y][x] = point.char;
                        }
                    });
                }
                
                // Center point
                grid[center][center] = chars[Math.floor(rng() * chars.length)];
                
                return grid.map(row => row.join('')).join('\n');
            }

            generateSegment(rng, maxRadius, chars) {
                const points = [];
                
                // Main branch along positive y-axis
                for (let y = 1; y <= maxRadius; y++) {
                    if (rng() > 0.3) { // 70% chance for main branch
                        points.push({
                            x: 0,
                            y: y,
                            char: chars[Math.floor(rng() * chars.length)]
                        });
                        
                        // Side branches
                        if (y > 2 && rng() > 0.6) { // 40% chance for side branch
                            const sideY = y - Math.floor(rng() * 2) - 1;
                            const sideX = rng() > 0.5 ? 1 : -1;
                            
                            if (Math.abs(sideX) + Math.abs(sideY) <= maxRadius) {
                                points.push({
                                    x: sideX,
                                    y: sideY,
                                    char: chars[Math.floor(rng() * chars.length)]
                                });
                            }
                        }
                    }
                }
                
                return points;
            }
        }

        const generator = new SimpleSnowflakeGenerator();

        function generate() {
            const seed = document.getElementById('seed').value || 'default';
            const size = parseInt(document.getElementById('size').value);
            const style = document.getElementById('style').value;
            
            const snowflake = generator.generate(seed, size, style);
            
            document.getElementById('output').innerHTML = `
                <div class="output">
                    <div class="snowflake">${snowflake}</div>
                    <div class="info">Seed: "${seed}" | Size: ${size}x${size} | Style: ${style}</div>
                </div>
            `;
        }

        function generateBatch() {
            const baseSeed = document.getElementById('seed').value || 'batch';
            const size = parseInt(document.getElementById('size').value);
            const style = document.getElementById('style').value;
            
            let html = '<div class="batch-grid">';
            
            for (let i = 1; i <= 4; i++) {
                const seed = `${baseSeed}-${i}`;
                const snowflake = generator.generate(seed, size, style);
                
                html += `
                    <div class="output">
                        <div class="snowflake">${snowflake}</div>
                        <div class="info">Seed: "${seed}"</div>
                    </div>
                `;
            }
            
            html += '</div>';
            document.getElementById('output').innerHTML = html;
        }

        function randomSeed() {
            const words = ['frost', 'ice', 'snow', 'winter', 'crystal', 'chill', 'arctic', 'frozen'];
            const num = Math.floor(Math.random() * 1000);
            const word = words[Math.floor(Math.random() * words.length)];
            
            document.getElementById('seed').value = `${word}${num}`;
            generate();
        }

        // Generate initial snowflake
        generate();
    </script>
</body>
</html>

Seed: "stackoverflow":

               
       o       
               
       o       
  o   .     o  
    o  . .o    
    .. **.     
      *·       
     .***..    
    o. .  o    
  o     .   o  
       o       
               
       o


Seed: Bhargav

       o       
       °       
               
       .     o 
 o°    ·    °  
    .  ·  .    
    ····*·     
      ···      
     ·*·*·     
    .  ·  .    
  °    ·    °  
 o     .     o 
               
       °       
       o

How to Run

Save the code as an HTML file ( snowflake-generator.html)
double click on file.
start interacting the application.
Enter any seed in the input field
Click "Generate Single" for one snowflake or "Generate 4 Variations" for a batch
Try different seeds to see unique patterns!

AI Usage Disclosure

Used AI assistance to polish the code. All core algorithms, mathematical approach, and solution design were my own original work.

What I Learned & Challenges

Key Learnings:

Mathematical Symmetry: Implementing true 6-fold rotational symmetry using trigonometry was more complex than expected
Reference used:
https://en.wikipedia.org/wiki/Rotational_symmetry
https://mathworld.wolfram.com/RotationMatrix.html
https://www.its.caltech.edu/~atomic/snowcrystals/science/science.htm
*https://chem.libretexts.org/Bookshelves/Inorganic_Chemistry/Inorganic_Coordination_Chemistry_(Landskron)/02%3A_Symmetry_and_Group_Theory/2.03%3A_Properties_and_Representations_of_Groups

https://www.geeksforgeeks.org/maths/rotational-symmetry/
https://www.sciencedirect.com/topics/mathematics/fold-symmetry%5C%5C%5C%5C\*
Seeded Randomness: Creating a reliable seeded random function that produces consistent cross-platform results required careful hash implementation
Seeding the random number generator in JavaScript
https://www.geeksforgeeks.org/system-design/consistent-hashing/
https://en.wikipedia.org/wiki/Linear_congruential_generator
https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/random
ASCII Aesthetics: Balancing character density and visual appeal while maintaining pure ASCII compatibility

https://en.wikipedia.org/wiki/ASCII_art

https://www.asciitable.com/

https://textfiles.com/art/

Jun 23 at 13:23, edited Jun 23 at 18:26

0

Steven

15.4k
7
49
79

❄️ ASCII Snowflake Generator – Stack Overflow Code Challenge #3

🧠 Approach

My approach was to simulate the radial symmetry of snowflakes using a square grid and ASCII characters. Here's how it works:

The snowflake is generated on a square grid with a central point.
Two branches are generated using random ASCII characters, and these are mirrored across vertical, horizontal, and diagonal axes to create symmetry.
The seed ensures that the same input always produces the same snowflake, while different seeds yield unique designs.
I used a small set of ASCII characters to represent the "arms" of the snowflake and applied simple mirroring logic to simulate symmetry.

🧊 Code

import random
import sys


def generate_snowflake(seed, branch_size=5):
    """
    Generates a symmetric ASCII snowflake from a random seed.

    Args:
        seed (int): Seed for the random generator.
        branch_size (int): Size of the grid (must be odd to ensure symmetry).

    Returns:
        str: ASCII representation of the snowflake.
    """
    random.seed(seed)
    size = branch_size * 2 + 1  # Grid size (must be odd)
    grid = [[" " for _ in range(size)] for _ in range(size)]

    # Some characters to draw the branches
    charset = [
        "!",
        "#",
        "$",
        "%",
        "&",
        "'",
        "(",
        ")",
        "*",
        "+",
        ",",
        "-",
        ".",
        "/",
        ":",
        ";",
        "<",
        "=",
        ">",
        "?",
        "@",
        "[",
        "\\",
        "]",
        "^",
        "_",
        "|",
    ]

    # Horizontal and vertical mirrors
    diag_mirror_map = {
        "╱": "╲",
        "╲": "╱",
        "(": ")",
        ")": "(",
        "[": "]",
        "]": "[",
        "{": "}",
        "}": "{",
        "<": ">",
        ">": "<",
    }

    vertical_mirror_map = {
        "-": "│",
        "│": "-",
    }

    branch_1 = random.choices(charset, k=branch_size)
    branch_2 = random.choices(charset, k=branch_size)

    for j, chars in enumerate(zip(branch_1, branch_2)):
        i = j + 1
        char1, char2 = chars

        grid[branch_size - i][branch_size] = char1
        grid[branch_size + i][branch_size] = char1
        grid[branch_size][branch_size - i] = vertical_mirror_map.get(char1, char1)
        grid[branch_size][branch_size + i] = vertical_mirror_map.get(char1, char1)

        grid[branch_size - i][branch_size - i] = char2
        grid[branch_size + i][branch_size - i] = char2
        grid[branch_size - i][branch_size + i] = diag_mirror_map.get(char2, char2)
        grid[branch_size + i][branch_size + i] = diag_mirror_map.get(char2, char2)

    grid[branch_size][branch_size] = random.choices(charset)[0]  # Center of the snowflake

    return "\n".join("".join(row) for row in grid)


# Example usage
if __name__ == "__main__":
    if len(sys.argv) > 1:
        try:
            seed = int(sys.argv[1])
        except ValueError:
            print(f"Invalid seed value: {sys.argv[1]}. Please provide an integer.")
            sys.exit(1)
    else:
        seed = 42

    print(generate_snowflake(seed))

❄️ Example Snowflakes

Here are a few examples generated with different seeds:

Seed: 42

!    ?    !
 -   (   - 
  $  )  $  
   ^ ! ^   
    >=<    
?()!='=!)(?
    >=<    
   ^ ! ^   
  $  )  $  
 -   (   - 
!    ?    !

Seed: 123

&    ^    &
 ]   $   [ 
  *  ,  *  
   : $ :   
    ###    
^$,$#+#$,$^
    ###    
   : $ :   
  *  ,  *  
 ]   $   [ 
&    ^    &

🛠️ How to Run

To run the script:

Save the code in a file, e.g., snowflake.py.
Run it from the command line with a seed:

python snowflake.py 42

If no seed is provided, it defaults to 42.

🤖 AI Usage Disclosure

I used AI assistance (ChatGPT) to help refine the structure of my submission and polish the explanation. However, the code itself was written entirely by me.

💡 What I Learned

To be honest, I didn’t learn a ton from a technical standpoint since the algorithm I used was fairly simple. However, the challenge was still a lot of fun! The most interesting (and frustrating) part was figuring out how ASCII characters would look when mirrored or rotated. ASCII just doesn’t offer a wide enough range of symbols to represent all the rotations I wanted, which limited the visual complexity I could achieve. Still, it was a creative exercise and a nice break from more serious coding tasks.

🙏 Conclusion

Thanks for taking the time to review my submission! I really appreciate the opportunity to participate in this challenge—it was a refreshing and playful way to explore symmetry and randomness. Looking forward to seeing the creative approaches others came up with!

Jun 23 at 14:15, edited Jun 23 at 14:24

2

Steven

15.4k
7
49
79

❄️ ASCII Snowflake Generator – Submission #2

👋 Introduction

This is my second entry for the Stack Overflow Code Challenge #3. In this version, I experimented with a different approach to snowflake generation—focusing on quadrant-based symmetry and a more organic, randomized structure.

🧠 Approach

This snowflake generator uses a quadrant mirroring technique:

A 2D grid is initialized with a size based on the size parameter.
The top-right quadrant is filled with characters based on a simple rule:
- If the point lies on an axis or diagonal, it gets an "X".
- Otherwise, it has a chance to become an "O" based on its distance from the center.
This quadrant is then mirrored across all four quadrants to create a symmetrical snowflake.
The result is a more abstract, radial snowflake with a softer, more randomized feel.

The seed ensures reproducibility, so the same seed always generates the same snowflake.

🧊 Code

import argparse
import random
from itertools import product


def snowflake(size=10):
    """
    Generate a snowflake pattern of a given size.

    Args:
        size (int): The size of the snowflake. Default is 10.

    Returns:
        str: A string representation of the snowflake pattern.
    """
    big_grid = [[" " for _ in range(2 * size + 1)] for _ in range(2 * size + 1)]

    for x, y in product(range(size + 1), range(size + 1)):
        if x * y == 0 or x == y:
            char = "X"

        else:
            char = random.choice([" "] * (x + y) + ["O"])

        big_grid[size + x][size + y] = char
        big_grid[size - x][size + y] = char
        big_grid[size - x][size - y] = char
        big_grid[size + x][size - y] = char

    return "\n".join("".join(row) for row in big_grid)


if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="Generate a snowflake pattern.")
    parser.add_argument(
        "--seed", type=int, default=42, help="Random seed (default: 42)"
    )
    parser.add_argument(
        "--size", type=int, default=10, help="Snowflake size (default: 10)"
    )
    args = parser.parse_args()

    seed = args.seed
    size = args.size

    random.seed(seed)  # Set the seed for reproducibility

    print(snowflake())

❄️ Example Output

Seed: 42

X         X         X
 XO       X       OX 
  X       X       X  
   X      X      X   
    X     X     X    
  O  X    X    X  O  
      X O X O X      
     O X OXO X O     
        X X X        
      O  XXX  O      
XXXXXXXXXXXXXXXXXXXXX
      O  XXX  O      
        X X X        
     O X OXO X O     
      X O X O X      
  O  X    X    X  O  
    X     X     X    
   X      X      X   
  X       X       X  
 XO       X       OX 
X         X         X

Seed: 123

X         X         X
 X        X        X 
  X   O   X   O   X  
 OOX      X      XOO 
   OX     X     XO   
     X   OXO   X     
      XO  X  OX      
       X  X  X       
      O X X X O      
     O   XXX   O     
XXXXXXXXXXXXXXXXXXXXX
     O   XXX   O     
      O X X X O      
       X  X  X       
      XO  X  OX      
     X   OXO   X     
   OX     X     XO   
 OOX      X      XOO 
  X   O   X   O   X  
 X        X        X 
X         X         X

🛠️ How to Run

To run the script:

Save the code in a file, e.g., snowflake.py.
Run it from the command line with optional arguments:

python snowflake.py --seed 123 --size 12

--seed: Controls the randomness (default is 42)
--size: Controls the size of the snowflake (default is 10)

🤖 AI Usage Disclosure

I used AI assistance (Copilot) to help write and polish the submission text. The code itself was written by me.

💡 What I Learned

This approach was more about experimenting with visual patterns than complex logic. It was fun to see how simple rules and symmetry can produce interesting results. The biggest challenge was balancing randomness with structure to keep the snowflake recognizable while still unique.

🙏 Conclusion

Thanks again for reviewing my submission! I enjoyed exploring a different style of snowflake generation and seeing how far I could push the visual design with just a few characters. Looking forward to seeing what others have created!

Jun 23 at 14:58

0

Mohammad Aman

1
4

Here is my a C++ program that generates ASCII snowflake art using a random seed. The program will create hexagonally symmetric snowflakes with varying patterns based on the seed.

#include <iostream>
#include <vector>
#include <string>
#include <random>
#include <cmath>
#include <algorithm>

class SnowflakeGenerator {
private:
    std::mt19937 rng;
    int size;
    std::vector<std::string> canvas;
    
    // ASCII characters for different snowflake elements
    const std::string CHARS = "*+xo.#-|/\\^v<>";
    
public:
    SnowflakeGenerator(unsigned int seed, int snowflake_size = 21) 
        : rng(seed), size(snowflake_size) {
        // Ensure odd size for proper center
        if (size % 2 == 0) size++;
        canvas.resize(size, std::string(size, ' '));
    }
    
    // Convert polar coordinates to cartesian
    std::pair<int, int> polarToCart(double r, double theta) {
        int center = size / 2;
        int x = center + static_cast<int>(r * cos(theta));
        int y = center + static_cast<int>(r * sin(theta));
        return {x, y};
    }
    
    // Check if coordinates are within canvas bounds
    bool inBounds(int x, int y) {
        return x >= 0 && x < size && y >= 0 && y < size;
    }
    
    // Set character at position if valid
    void setChar(int x, int y, char c) {
        if (inBounds(x, y)) {
            canvas[y][x] = c;
        }
    }
    
    // Generate a single arm of the snowflake
    void generateArm(double baseAngle) {
        std::uniform_real_distribution<double> lengthDist(0.3, 0.9);
        std::uniform_int_distribution<int> charDist(0, CHARS.length() - 1);
        std::uniform_real_distribution<double> branchDist(0.0, 1.0);
        std::uniform_real_distribution<double> angleDist(-0.3, 0.3);
        
        double maxRadius = size / 2.0 - 1;
        
        // Main arm
        for (double r = 1; r < maxRadius; r += 0.5) {
            double angle = baseAngle + angleDist(rng) * 0.1;
            auto [x, y] = polarToCart(r, angle);
            
            char c = CHARS[charDist(rng)];
            setChar(x, y, c);
            
            // Add branches with decreasing probability as we go outward
            if (branchDist(rng) < (1.0 - r / maxRadius) * 0.4) {
                // Left branch
                double branchAngle = angle - 0.5 - angleDist(rng) * 0.2;
                double branchLength = lengthDist(rng) * (maxRadius - r) * 0.6;
                
                for (double br = 1; br < branchLength; br += 0.8) {
                    auto [bx, by] = polarToCart(r + br * cos(branchAngle - angle), 
                                               angle + br * sin(branchAngle - angle) / r);
                    char bc = CHARS[charDist(rng)];
                    setChar(bx, by, bc);
                }
                
                // Right branch
                branchAngle = angle + 0.5 + angleDist(rng) * 0.2;
                for (double br = 1; br < branchLength; br += 0.8) {
                    auto [bx, by] = polarToCart(r + br * cos(branchAngle - angle), 
                                               angle + br * sin(branchAngle - angle) / r);
                    char bc = CHARS[charDist(rng)];
                    setChar(bx, by, bc);
                }
            }
        }
    }
    
    // Generate the complete snowflake with 6-fold symmetry
    void generateSnowflake() {
        // Clear canvas
        for (auto& row : canvas) {
            std::fill(row.begin(), row.end(), ' ');
        }
        
        // Set center
        int center = size / 2;
        canvas[center][center] = '*';
        
        // Create 6 arms with 60-degree spacing
        for (int i = 0; i < 6; i++) {
            double angle = i * M_PI / 3.0; // 60 degrees in radians
            generateArm(angle);
        }
        
        // Add some random ice crystals around the snowflake
        std::uniform_int_distribution<int> posDist(0, size - 1);
        std::uniform_real_distribution<double> probDist(0.0, 1.0);
        
        for (int i = 0; i < size * size / 20; i++) {
            if (probDist(rng) < 0.3) {
                int x = posDist(rng);
                int y = posDist(rng);
                
                // Only add if position is empty and not too close to center
                double distFromCenter = sqrt(pow(x - center, 2) + pow(y - center, 2));
                if (canvas[y][x] == ' ' && distFromCenter > size * 0.4) {
                    canvas[y][x] = '.';
                }
            }
        }
    }
    
    // Print the snowflake
    void printSnowflake() {
        for (const auto& row : canvas) {
            std::cout << row << std::endl;
        }
    }
    
    // Get seed information
    void printInfo(unsigned int seed) {
        std::cout << "Snowflake generated with seed: " << seed << std::endl;
        std::cout << "Size: " << size << "x" << size << std::endl;
        std::cout << std::string(size, '-') << std::endl;
    }
};

int main() {
    std::cout << "ASCII Snowflake Generator" << std::endl;
    std::cout << "=========================" << std::endl << std::endl;
    
    // Generate multiple snowflakes with different seeds
    std::vector<unsigned int> seeds = {12345, 98765, 55555, 77777, 13579};
    
    for (unsigned int seed : seeds) {
        SnowflakeGenerator generator(seed, 19);
        generator.printInfo(seed);
        generator.generateSnowflake();
        generator.printSnowflake();
        std::cout << std::endl;
    }
    
    // Interactive mode - let user input their own seed
    std::cout << "Enter your own seed (or 0 to exit): ";
    unsigned int userSeed;
    while (std::cin >> userSeed && userSeed != 0) {
        std::cout << std::endl;
        SnowflakeGenerator generator(userSeed, 21);
        generator.printInfo(userSeed);
        generator.generateSnowflake();
        generator.printSnowflake();
        std::cout << std::endl;
        std::cout << "Enter another seed (or 0 to exit): ";
    }
    
    std::cout << "Thanks for creating snowflakes!" << std::endl;
    return 0;
}

Output :



ASCII Snowflake Generator
=========================

Snowflake generated with seed: 12345
Size: 19x19
-------------------
                   
                   
                   
     .#     vo     
      -    /#      
       * o v       
       ^o +v       
       -- . <      
         v# v <    
  /x-.^>o|*.v<+\<  
      < -+o v -    
       >/..>/\     
       <-|##-      
  .    \ <>.       
      xx   \+      
     #.     *.     
                   
                   
                   

Snowflake generated with seed: 98765
Size: 19x19
-------------------
                   
                   
      \     .      
      #     .      
 .    *+ * /\      
.     *> o<v       
       ^*><.       
     /  +/\\+.     
      .  +#+ #     
  vvx#vv*.o\^#o-/  
      *-*/>  -     
      # \v/        
       #.#|^       
       #  </       
      .v   x-      
     <v     xx     
                   
                   
                   

Snowflake generated with seed: 55555
Size: 19x19
-------------------
                   
                   
                   
     o^     .      
      />   \v      
      v| # <       
       *...x       
       >o+.*\      
       > \v<       
  vv#vo#^<x.xo\#|. 
       o+/*        
      /*\*<        
       x< /x       
       *   o       
      /-    #      
     ^.     -x     
                   
                   
                   

Snowflake generated with seed: 77777
Size: 19x19
-------------------
                   
                   
      +            
      o     -      
      v#    x      
     ^o.*/ v       
       ov\#-       
     # ^+x^>^      
      |^o.v-       
  +/#v|>x#\/.*.o-  
      +^o+<        
     * +#x>        
      */*-^>       
       +^  ^       
      /     |      
      /     |x     
                   
                   
                   

Snowflake generated with seed: 13579
Size: 19x19

Jun 23 at 17:44

0

kay

51
7

Snowflake using ACII :)

Interesting challenge! I was working on something similar (latent symmetry analysis based on Noether's theorem).

My initial thought was to create a snowflake using a Koch triangle and the seed value could be the fractal dimension of the Koch Snowflake (https://mathworld.wolfram.com/KochSnowflake.html). Various overlays and inlays could be implemented as well to further develop this idea. However, that would be too easy considering this a STACKOVERFLOW (C) challenge. So fellow staff members and users allow me to present my solution:

There's is around 80 documented distinct ice-crystal shapes (https://en.wikipedia.org/wiki/Classifications_of_snow#Snow_crystal_classification). Each could be classified into the one of following 8 categories: - Needle (N) - Column (C) - Plate (P) - Column and Plate combination (CP) - Side plane (S) - Rime (R) - Irregular (I) - Germ (G)

Python implementation:

import string
import sys
import itertools

def is_printable_ascii(s: str) -> bool:
    # string.printable includes digits, ascii_letters, punctuation, whitespace
    return all(c in string.printable for c in s)

def get_category(name_sum: int) -> str:
    categories = ['Needle', 'Column', 'Plate', 'ColumnPlate',
                  'SidePlane', 'Rime', 'Irregular', 'Germ']

    #Uses modulo 8 to pick one of the eight categories (N, C, P, CP, S, R, I, G).
    return categories[name_sum % len(categories)]

def draw_snowflake(category: str, chars: str) -> None:
    # Define simple ASCII templates with '*' as placeholders
    templates = {
        'Needle': [
            "  *  ",
            "  *  ",
            "  *  ",
            "  *  ",
            "  *  ",
        ],
        'Column': [
            "*****",
        ],
        'Plate': [
            "  *  ",
            "*****",
            "  *  ",
        ],
        'ColumnPlate': [
            "  *  ",
            "*****",
            "  *  ",
            "  *  ",
            "*****",
        ],
        'SidePlane': [
            "    *",
            "   * ",
            "  *  ",
            " *   ",
            "*    ",
        ],
        'Rime': [
            "*   *",
            " * * ",
            "  *  ",
            " * * ",
            "*   *",
        ],
        'Irregular': [
            " ** ** ",
            "*  *  *",
            " ** ** ",
            "*  *  *",
            " ** ** ",
        ],
        'Germ': [
            "  *  ",
        ],
    }

    template = templates.get(category)
    if template is None:
        print(f"No template for category {category!r}")
        return

    # Cycle through the 4 input chars whenever we hit a '*'
    char_cycle = itertools.cycle(chars)

    for line in template:
        out = []
        for ch in line:
            if ch == '*':
                out.append(next(char_cycle))
            else:
                out.append(ch)
        print("".join(out))

def main():
    s = input("Enter a 4-character string: ")
    if len(s) != 4:
        print("Error: you must enter exactly 4 characters.")
        sys.exit(1)
    if not is_printable_ascii(s):
        print("Error: all characters must be printable ASCII.")
        sys.exit(1)

    name_sum = sum(ord(c) for c in s)
    category = get_category(name_sum)
    print(f"\n Drawing snowflake in category: {category}\n")
    draw_snowflake(category, s)

if __name__ == "__main__":
    main()

I wish I was wasn't preoccupied so that I could work more on this, very interesting like i said. Thanks for reading

Cheers, Krutarth Parmar https://kayparmar.com

Jun 23 at 22:52

0

Temitayo Oni

1

My design is actually based on symmetry around a center point, mimicking how actual snowflakes form

Center of the snowflake: *---- * ----*

This is honestly the first time I am creating ASCII snowflakes, but I have done ASCII umbrellas lots of times, cars and animal faces

I'm well versed in Python so for anyone who wants to run my code, Python code was used to display the snowflakes.

This challenge was quite easy and fun for me. Can't wit to get another.

       *       
     \ | /     
   *-- + --*   
     / | \     
*----  *  ----*
     \ | /     
   *-- + --*   
     / | \     
       *       

def print_ascii_snowflake():
    snowflake = [
        "       *       ",
        "     \\ | /     ",
        "   *-- + --*   ",
        "     / | \\     ",
        "*----  *  ----*",
        "     \\ | /     ",
        "   *-- + --*   ",
        "     / | \\     ",
        "       *       "
    ]
    
    for line in snowflake:
        print(line)

print_ascii_snowflake()

Jun 24 at 11:25

0

DeepThought42

238
1
11

Only issue is that it doesn’t so much ‘generate’ a snowflake, as print a hard-coded one…

Jun 29 at 4:22

1

FoxWise

83
1
8

Snowflake generator

Explanation

After analysing all possible different snowflakes from Microphysics of Clouds and Precipitation I figured only the planar type looks nice as a 2D ASCII art, so my focus is on those.

By looking at the snowflakes, I decided to parameterise each snowflake by the symmetry, length of primary branches, and length, period and angle of secondary (tertiary) branches that grow out of primary (secondary) branches. The lengths define the length of each branch. The period of a secondary (tertiary) branch defines the space between the two consecutive secondary (tertiary) branches along a primary (secondary) branch. The angle defines the angle between the secondary (tertiary) branch direction and the primary (secondary) branch direction on which it grows. So, in total, the snowflake is parametrised by:

Symmetry
Length of primary branches
Length of secondary branches
Period of secondary branches
Angle of secondary branches
Length of tertiary branches
Period of tertiary branches
Angle of tertiary branches
Background ASCII symbol
Snowflake ASCII symbol

The snowflakes are generated on a grid of background ASCII characters governed by the lengths and angles of all branches defined above.

The initially intended size of the grid is 120x60 (120 characters and 60 lines). This makes approximately 800x800 px and makes a nice resolution for the snowflakes.
However, after I discovered that the challenge entry does not allow screenshots and 120x60 is too big to be nicely formatted directly here, now this parameter is adjustable in the code...

For randomising these properties from a random seed, I used xorshift32amx pseudo-random number generator. The range of the properties was manually adjusted by looking what looks "nice".

The code

I used javascript, as it is the easiest to share with others and to practice my mediocre JS skills:

HTML code

<!-- index.html -->
<!DOCTYPE html>
<html>

<head>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <title>Snowflake Generator</title>
    <link type="text/css" rel="stylesheet" href="styles.css"
</head>

<body>
    <div style="display:flex;">
        <div class="menu">
            <div>
                <form id="generate-form">         
                    <h4>Customize:</h4>

                    <div class="menu-item">
                        <label for="symmetry" id="symmetry-label"> Symmetry: </label><br>
                        <input type="range" id="symmetry-input" name="symmetry" min="4" max="12" step="2" list="symmetry-steplist">
                        <datalist id="symmetry-steplist">
                            <option value="4" label="4"></option>
                            <option value="6" label="6"></option>
                            <option value="8" label="8"></option>
                            <option value="10" label="10"></option>
                            <option value="12" label="12"></option>
                        </datalist>
                    </div>

                    <div class="menu-item">
                        <label for="primary-branch-length" id="primary-branch-length-label"> Primary Branch Length: </label><br>
                        <input type="range" id="primary-branch-length-input" name="primary-branch-length" step="1" list="primary-branch-length-steplist">
                        <datalist id="primary-branch-length-steplist">
                        </datalist>
                    </div>

                    <div class="menu-item">
                        <label for="secondary-branch-length" id="secondary-branch-length-label"> Secondary Branch Length: </label><br>
                        <input type="range" id="secondary-branch-length-input" name="secondary-branch-length" step="1" list="secondary-branch-length-steplist">
                        <datalist id="secondary-branch-length-steplist">
                        </datalist>
                    </div>

                    <div class="menu-item">
                        <label for="secondary-branch-period" id="secondary-branch-period-label"> Secondary Branch Period: </label><br>
                        <input type="range" id="secondary-branch-period-input" name="secondary-branch-period" step="1" list="secondary-branch-period-steplist">
                        <datalist id="secondary-branch-period-steplist">
                        </datalist>
                    </div>

                    <div class="menu-item">
                        <label for="secondary-branch-angle" id="secondary-branch-angle-label"> Secondary Branch Angle: </label><br>
                        <input type="range" id="secondary-branch-angle-input" name="secondary-branch-angle" min="0" max="180" step="1" list="secondary-branch-angle-steplist">
                        <datalist id="secondary-branch-angle-steplist">
                            <option value="0" label="0"></option>
                            <option value="45" label="45"></option>
                            <option value="90" label="90"></option>
                            <option value="135" label="135"></option>
                            <option value="180" label="180"></option>
                        </datalist>
                    </div>

                    <div class="menu-item">
                        <label for="tertiary-branch-length" id="tertiary-branch-length-label"> Tertiary Branch Length: </label><br>
                        <input type="range" id="tertiary-branch-length-input" name="tertiary-branch-length" step="1" list="tertiary-branch-length-steplist">
                        <datalist id="tertiary-branch-length-steplist">
                        </datalist>
                    </div>

                    <div class="menu-item">
                        <label for="tertiary-branch-period" id="tertiary-branch-period-label"> Tertiary Branch Period: </label><br>
                        <input type="range" id="tertiary-branch-period-input" name="tertiary-branch-period" step="1" list="tertiary-branch-period-steplist">
                        <datalist id="tertiary-branch-period-steplist">
                        </datalist>
                    </div>

                    <div class="menu-item">
                        <label for="tertiary-branch-angle" id="tertiary-branch-angle-label"> Tertiary Branch Angle: </label><br>
                        <input type="range" id="tertiary-branch-angle-input" name="tertiary-branch-angle" min="0" max="180" step="1" list="tertiary-branch-angle-steplist">
                        <datalist id="tertiary-branch-angle-steplist">
                            <option value="0" label="0"></option>
                            <option value="45" label="45"></option>
                            <option value="90" label="90"></option>
                            <option value="135" label="135"></option>
                            <option value="180" label="180"></option>
                        </datalist>
                    </div>

                    <div class="menu-item">
                        <label for="background-symbol" id="background-symbol-label"> Background Symbol: </label><br>
                        <input type="text" id="background-symbol-input" name="background-symbol" value="-" maxlength="1">
                    </div>

                    <div class="menu-item">
                        <label for="snowflake-symbol" id="snowflake-symbol-label"> Snowflake Symbol: </label><br>
                        <input type="text" id="snowflake-symbol-input" name="snowflake-symbol" value="@" maxlength="1">
                    </div>
                    
                    <h4>Generate:</h4>
                    <div class="menu-item">
                        <label for="seed" id="seed-label"> Seed: </label><br>
                        <input type="text" id="seed-input" name="seed" value="12345">
                        <input type="button" id="generate-seed" value="Generate with Seed">
                    </div>

                    <div class="menu-item">
                        <input type="button" id="generate-random" value="I'm feeling Lucky">
                    </div>

                </form>
            </div>
        </div>
        

        <pre id="canvas" style="height: 1000px; width:1000px;"></pre>
    
    </div>
    
    <script type="text/javascript" src="main.js"></script>
    
</body>
</html>

CSS code

/* styles.css */
html, body{
    height:100%;
    margin:0;
    padding:0;
}

.menu{
    display:flex;
    justify-content: column;
    padding: 5px;
    width:250px;
}

datalist {
    display: flex;
    flex-direction: row;
    justify-content: space-between;
    writing-mode: horizontal-tb;
    width: 200px;
}

option {
  padding: 0;
}

input[type="range"] {
  width: 200px;
  margin: 0;
}

input[type="range"] {
  width: 200px;
  margin: 0;
}


.menu-item{
    display: flex;
    flex-direction: column;
    align-items: center;
    margin:12px 8px;
}

JS code

// main.js
const canvas = document.getElementById("canvas");
const size = 60 // adjustible number of lines in canvas to use for drawing
const halfSize = size/2;

function getSymmetry(rand){ return 4 + 2*Math.floor(5*rand); }
function getPrimaryBranchLength(rand){ return Math.round(halfSize*rand) }
function getSecondaryBranchLength(rand){ return Math.round(halfSize*rand) }
function getTertiaryBranchLength(rand){ return Math.round(halfSize/5*rand) }
function getSecondaryBranchPeriod(rand){ return Math.round(3 + halfSize/5*rand) }
function getTertiaryBranchPeriod(rand){ return Math.round(3 + halfSize/5*rand) }
function getAngle(rand){ return Math.PI*rand }


//make length-dependent controls relative to the size of the canvas:
document.getElementById('primary-branch-length-input').min = getPrimaryBranchLength(0);
document.getElementById('primary-branch-length-input').max = getPrimaryBranchLength(1);
for (let i = 0; i < 5; i++) {
    const option = document.createElement('option');
    option.value = getPrimaryBranchLength(i/4);
    option.label = `${i*25}`;
    document.getElementById('primary-branch-length-steplist').appendChild(option);
}

document.getElementById('secondary-branch-length-input').min = getSecondaryBranchLength(0);
document.getElementById('secondary-branch-length-input').max = getSecondaryBranchLength(1);
for (let i = 0; i < 5; i++) {
    const option = document.createElement('option');
    option.value = getSecondaryBranchLength(i/4);
    option.label = `${i*25}`;
    document.getElementById('secondary-branch-length-steplist').appendChild(option);
}

document.getElementById('tertiary-branch-length-input').min = getTertiaryBranchLength(0);
document.getElementById('tertiary-branch-length-input').max = getTertiaryBranchLength(1);
for (let i = 0; i < 5; i++) {
    const option = document.createElement('option');
    option.value = getTertiaryBranchLength(i/4);
    option.label = `${i*25}`;
    document.getElementById('tertiary-branch-length-steplist').appendChild(option);
}

document.getElementById('secondary-branch-period-input').min = getSecondaryBranchPeriod(0);
document.getElementById('secondary-branch-period-input').max = getSecondaryBranchPeriod(1);
const secondaryBranchPeriodOption0 = document.createElement('option');
secondaryBranchPeriodOption0.value = getSecondaryBranchPeriod(0);
secondaryBranchPeriodOption0.label = `Frequent`;
document.getElementById('secondary-branch-period-steplist').appendChild(secondaryBranchPeriodOption0);
const secondaryBranchPeriodOption100 = document.createElement('option');
secondaryBranchPeriodOption100.value = getSecondaryBranchPeriod(1);
secondaryBranchPeriodOption100.label = `Sparse`;
document.getElementById('secondary-branch-period-steplist').appendChild(secondaryBranchPeriodOption100);


document.getElementById('tertiary-branch-period-input').min = getTertiaryBranchPeriod(0);
document.getElementById('tertiary-branch-period-input').max = getTertiaryBranchPeriod(1);
const tertiaryBranchPeriodOption0 = document.createElement('option');
tertiaryBranchPeriodOption0.value = getTertiaryBranchPeriod(0);
tertiaryBranchPeriodOption0.label = `Frequent`;
document.getElementById('tertiary-branch-period-steplist').appendChild(tertiaryBranchPeriodOption0);
const tertiaryBranchPeriodOption100 = document.createElement('option');
tertiaryBranchPeriodOption100.value = getTertiaryBranchPeriod(1);
tertiaryBranchPeriodOption100.label = `Sparse`;
document.getElementById('tertiary-branch-period-steplist').appendChild(tertiaryBranchPeriodOption100);


function generateRandomSnowflakeProperties(seed){
    const getRand = xorshift32amx(seed);

    const symmetry = getSymmetry(getRand());
    const primaryBranchLength = getPrimaryBranchLength(getRand());
    const secondaryBranchLength = getSecondaryBranchLength(getRand());
    const tertiaryBranchLength = getTertiaryBranchLength(getRand());
    const secondaryBranchPeriod = getSecondaryBranchPeriod(getRand());
    const tertiaryBranchPeriod = getTertiaryBranchPeriod(getRand());
    const secondaryBranchAngle = getAngle(getRand());
    const tertiaryBranchAngle = getAngle(getRand());
    const properties = [symmetry, primaryBranchLength, secondaryBranchLength, secondaryBranchPeriod, secondaryBranchAngle, tertiaryBranchLength, tertiaryBranchPeriod, tertiaryBranchAngle];
    return properties;
}


//random generator from https://github.com/bryc/code/blob/master/jshash/PRNGs.md
function xorshift32amx(a) {
    return function() {
        var t = Math.imul(a, 1597334677);
        t = t>>>24 | t>>>8&65280 | t<<8&16711680 | t<<24; // reverse byte order
        a ^= a << 13; a ^= a >>> 17; a ^= a << 5;
        return (a + t >>> 0) / 4294967296;
    }
}



class Snowflake {
    constructor(symmetry, primaryBranchLength, secondaryBranchLength, secondaryBranchPeriod, secondaryBranchAngle, tertiaryBranchLength, tertiaryBranchPeriod, tertiaryBranchAngle){

        this.symmetry = symmetry;
        this.primaryBranchLength = primaryBranchLength;
        this.secondaryBranchLength = secondaryBranchLength;
        this.secondaryBranchPeriod = secondaryBranchPeriod;
        this.secondaryBranchAngle = secondaryBranchAngle;
        this.tertiaryBranchLength = tertiaryBranchLength;
        this.tertiaryBranchPeriod = tertiaryBranchPeriod;
        this.tertiaryBranchAngle = tertiaryBranchAngle;
        
        this.asciArt = "";
        this.snowflakeSymbol = "@";
        this.backgroundSymbol = "-";

        this.xmax = 2*size;
        this.ymax = size;
        this.xPrimaryCenter = Math.floor(this.xmax/2);
        this.yPrimaryCenter = Math.floor(this.ymax/2);
    }

    backgroundFillAsciText(){
        this.asciArt = "";
        for (let y = 0; y < this.ymax; y++) {
            for (let x = 0; x < this.xmax; x++) {
                this.asciArt += this.backgroundSymbol;
            }
            this.asciArt += '\n';
        }
    }


    getAsciTextPos(x, y){
        if (x < 0 || x >= this.xmax) return -1;
        if (y < 0 || y >= this.ymax) return -1;
        return x+1-1 + (y-1)*(this.xmax+1);
    }

    updateInputFields(){
        document.getElementById("symmetry-input").value = this.symmetry;
        document.getElementById("primary-branch-length-input").value = this.primaryBranchLength;
        document.getElementById("secondary-branch-length-input").value = this.secondaryBranchLength;
        document.getElementById("secondary-branch-period-input").value = this.secondaryBranchPeriod;
        document.getElementById("secondary-branch-angle-input").value = Math.round(this.secondaryBranchAngle*180/Math.PI);
        document.getElementById("tertiary-branch-length-input").value = this.tertiaryBranchLength;
        document.getElementById("tertiary-branch-period-input").value = this.tertiaryBranchPeriod;
        document.getElementById("tertiary-branch-angle-input").value = Math.round(this.tertiaryBranchAngle*180/Math.PI);
        document.getElementById("background-symbol-input").value = this.backgroundSymbol;
        document.getElementById("snowflake-symbol-input").value = this.snowflakeSymbol;
    }

    calculateAsciArtPositions(){
        this.asciArtPositions = [];
        for(let i=0; i < this.symmetry; i++){
            const xPrimaryDir = Math.cos(i*2*Math.PI/this.symmetry);
            const yPrimaryDir = Math.sin(i*2*Math.PI/this.symmetry);
            for(let i2=0; i2 < this.primaryBranchLength; i2++){
                const xToDraw = Math.floor(this.xPrimaryCenter + 2*i2*xPrimaryDir);
                const yToDraw = Math.floor(this.yPrimaryCenter + i2*yPrimaryDir);
                const globIdx = this.getAsciTextPos(xToDraw, yToDraw);
                if (globIdx != -1) this.asciArtPositions.push(globIdx);
            }

            const xSecondaryLeftDir = Math.cos(i*2*Math.PI/this.symmetry - this.secondaryBranchAngle);
            const ySecondaryLeftDir = Math.sin(i*2*Math.PI/this.symmetry - this.secondaryBranchAngle);
            const xSecondaryRightDir = Math.cos(i*2*Math.PI/this.symmetry + this.secondaryBranchAngle);
            const ySecondaryRightDir = Math.sin(i*2*Math.PI/this.symmetry + this.secondaryBranchAngle);

            for(let i2=this.secondaryBranchPeriod; i2 < this.primaryBranchLength; i2+=this.secondaryBranchPeriod){
                const xSecondaryCenter = this.xPrimaryCenter + 2*i2*xPrimaryDir;
                const ySecondaryCenter = this.yPrimaryCenter + i2*yPrimaryDir;

                for(let i3=0; i3 < this.secondaryBranchLength; i3++){
                    const xLeftToDraw = Math.floor(xSecondaryCenter + 2*i3*xSecondaryLeftDir);
                    const yLeftToDraw = Math.floor(ySecondaryCenter + i3*ySecondaryLeftDir);
                    const globIdxLeft = this.getAsciTextPos(xLeftToDraw, yLeftToDraw);
                    if (globIdxLeft != -1) this.asciArtPositions.push(globIdxLeft);

                    const xRightToDraw = Math.floor(xSecondaryCenter + 2*i3*xSecondaryRightDir);
                    const yRightToDraw = Math.floor(ySecondaryCenter + i3*ySecondaryRightDir);
                    const globIdxRight = this.getAsciTextPos(xRightToDraw, yRightToDraw);
                    if (globIdxRight != -1) this.asciArtPositions.push(globIdxRight);
                }
    
                const xTertiaryLLDir = Math.cos(i*2*Math.PI/this.symmetry - this.secondaryBranchAngle - this.tertiaryBranchAngle);
                const yTertiaryLLDir = Math.sin(i*2*Math.PI/this.symmetry - this.secondaryBranchAngle - this.tertiaryBranchAngle);
                const xTertiaryLRDir = Math.cos(i*2*Math.PI/this.symmetry - this.secondaryBranchAngle + this.tertiaryBranchAngle);
                const yTertiaryLRDir = Math.sin(i*2*Math.PI/this.symmetry - this.secondaryBranchAngle + this.tertiaryBranchAngle);
    
                const xTertiaryRLDir = Math.cos(i*2*Math.PI/this.symmetry + this.secondaryBranchAngle - this.tertiaryBranchAngle);
                const yTertiaryRLDir = Math.sin(i*2*Math.PI/this.symmetry + this.secondaryBranchAngle - this.tertiaryBranchAngle);
                const xTertiaryRRDir = Math.cos(i*2*Math.PI/this.symmetry + this.secondaryBranchAngle + this.tertiaryBranchAngle);
                const yTertiaryRRDir = Math.sin(i*2*Math.PI/this.symmetry + this.secondaryBranchAngle + this.tertiaryBranchAngle);
    
                for(let i3=this.tertiaryBranchPeriod; i3 < this.secondaryBranchLength; i3+=this.tertiaryBranchPeriod){
                    const xTertiaryCenterLeft = xSecondaryCenter + 2*i3*xSecondaryLeftDir;
                    const yTertiaryCenterLeft = ySecondaryCenter + i3*ySecondaryLeftDir;
                    const xTertiaryCenterRight = xSecondaryCenter + 2*i3*xSecondaryRightDir;
                    const yTertiaryCenterRight = ySecondaryCenter + i3*ySecondaryRightDir;

                    for(let i4=0; i4 < this.tertiaryBranchLength; i4++){
                        const xLLToDraw = Math.floor(xTertiaryCenterLeft + 2*i4*xTertiaryLLDir);
                        const yLLToDraw = Math.floor(yTertiaryCenterLeft + i4*yTertiaryLLDir);
                        const globIdxLL = this.getAsciTextPos(xLLToDraw, yLLToDraw);
                        if (globIdxLL != -1) this.asciArtPositions.push(globIdxLL);

                        const xLRToDraw = Math.floor(xTertiaryCenterLeft + 2*i4*xTertiaryLRDir);
                        const yLRToDraw = Math.floor(yTertiaryCenterLeft + i4*yTertiaryLRDir);
                        const globIdxLR = this.getAsciTextPos(xLRToDraw, yLRToDraw);
                        if (globIdxLR != -1) this.asciArtPositions.push(globIdxLR);

                        const xRLToDraw = Math.floor(xTertiaryCenterRight + 2*i4*xTertiaryRLDir);
                        const yRLToDraw = Math.floor(yTertiaryCenterRight + i4*yTertiaryRLDir);
                        const globIdxRL = this.getAsciTextPos(xRLToDraw, yRLToDraw);
                        if (globIdxRL != -1) this.asciArtPositions.push(globIdxRL);

                        const xRRToDraw = Math.floor(xTertiaryCenterRight + 2*i4*xTertiaryRRDir);
                        const yRRToDraw = Math.floor(yTertiaryCenterRight + i4*yTertiaryRRDir);
                        const globIdxRR = this.getAsciTextPos(xRRToDraw, yRRToDraw);
                        if (globIdxRR != -1) this.asciArtPositions.push(globIdxRR);
                    }
                }
            }
        }

    }

    renderAsci(){
        this.backgroundFillAsciText();
        let newAsciArt = "";
        for(let i=0; i < this.asciArt.length; i++){
            if ( this.asciArtPositions.includes(i) && this.asciArt[i] != '\n' ) newAsciArt += this.snowflakeSymbol;
            else newAsciArt += this.asciArt[i];
        }
        this.asciArt = newAsciArt;
        canvas.textContent = this.asciArt;
    }


    draw(canvas){
        this.updateInputFields();
        this.calculateAsciArtPositions();
        this.renderAsci(this.asciArtPositions, canvas);
    }

}

function createFromSeed(seed){
    const randomProperties = generateRandomSnowflakeProperties(seed);
    snowflake = new Snowflake(...randomProperties);
    snowflake.draw(canvas);
}


function generate(event){
    event.preventDefault();
    const seed = parseInt( document.getElementById("seed-input").value );
    createFromSeed(seed);
}

function generateRandom(event){
    event.preventDefault();
    const seed = Math.floor(Math.random()*100000);
    document.getElementById("seed-input").value = seed;
    createFromSeed(seed);
}


document.getElementById("generate-seed").addEventListener('click', generate);
document.getElementById("generate-random").addEventListener('click', generateRandom);


//Controls
document.getElementById("symmetry-input").oninput = function() {
    snowflake.symmetry = parseInt(this.value);
    snowflake.draw(canvas);
}
document.getElementById("primary-branch-length-input").oninput = function() {
    snowflake.primaryBranchLength = parseInt(this.value);
    snowflake.draw(canvas);
}
document.getElementById("secondary-branch-length-input").oninput = function() {
    snowflake.secondaryBranchLength = parseInt(this.value);
    snowflake.draw(canvas);
}
document.getElementById("secondary-branch-period-input").oninput = function() {
    snowflake.secondaryBranchPeriod = parseInt(this.value);
    snowflake.draw(canvas);
}
document.getElementById("secondary-branch-angle-input").oninput = function() {
    snowflake.secondaryBranchAngle = parseFloat(this.value*Math.PI/180.);
    snowflake.draw(canvas);
}
document.getElementById("tertiary-branch-length-input").oninput = function() {
    snowflake.tertiaryBranchLength = parseInt(this.value);
    snowflake.draw(canvas);
}
document.getElementById("tertiary-branch-period-input").oninput = function() {
    snowflake.tertiaryBranchPeriod = parseInt(this.value);
    snowflake.draw(canvas);
}
document.getElementById("tertiary-branch-angle-input").oninput = function() {
    snowflake.tertiaryBranchAngle = parseFloat(this.value*Math.PI/180.);
    snowflake.draw(canvas);
}
document.getElementById("background-symbol-input").oninput = function() {
    snowflake.backgroundSymbol = this.value;
    snowflake.draw(canvas);
}
document.getElementById("snowflake-symbol-input").oninput = function() {
    snowflake.snowflakeSymbol = this.value;
    snowflake.draw(canvas);
}
const defaultRandomProperties = generateRandomSnowflakeProperties(12345);
let snowflake = new Snowflake(...defaultRandomProperties);
snowflake.draw(canvas);

Examples

A few examples randomly generated with the size 20.

-------------------@@-------------------
------------------@--@------------------
-----------------@----@-----------------
----------------@--@---@----------------
---------------@---@----@---------------
---------------@@-@-@@-@@---------------
----------@-@-@-----@----@-@-@----------
-------@@----@------@-----@----@@-------
---@-@------@-------@------@------@-@---
---@-@--@-@-@-@-@-@-@-@-@-@@@-@-@-@-@---
-------@@----@------@-----@----@@-------
----------@-@-@-----@----@-@-@----------
---------------@@-@-@@-@@---------------
---------------@----@---@---------------
----------------@---@--@----------------
-----------------@--@-@-----------------
------------------@--@------------------
-------------------@@-------------------
----------------------------------------
----------------------------------------

------------@------@@------@------------
---------@@-@------@@------@-@@---------
-----------@@-@---@@-@---@-@@-----------
-----@------@@--@@@@-@@@--@@------@-----
----@@-----@-@@----@-----@@-@----@@@----
---@-@@@-@-@---@----@---@---@-@-@@@-@---
-------@-@-@----@---@--@--@-@---@-------
-@------@@---@@---@-@-@--@----@@------@-
---@@-@--@------@-@@@@-@------@--@-@@---
--@@@-@-@@@-@-@-@-@@@@@-@-@-@-@-@@@@@-@-
-@------@@----@-@-@-@-@@-@----@@------@-
-------@---@-@---@--@--@--@-@---@-------
---@-@@@-@-@----@---@---@---@-@-@@@-@---
----@@@----@-@-@----@----@@-@----@@@----
-----@------@-@-@@@-@@@@--@@------@-----
------------@@@---@-@@---@-@@-----------
---------@@@@------@@------@-@@---------
------------@------@@------@------------
-----------------@--@-@-----------------
----------------------------------------

----------@@--@-@-@@@@-@-@--@@----------
-------@--@------@-@@-@------@--@-------
@---@---@@-@------@@@@------@-@@---@---@
@-----@-@-@-@----@-@--@----@-@-@-@-----@
-@-@-@-@-@@@--@-@-@@-@-@-@--@@@-@-@-@-@-
-@-------@--@--@----@---@--@--@-------@-
-@@-------@-@-@@----@---@@-@-@-------@@-
--@-@----@@------@--@-@------@@----@-@--
@-@@-@@@---@------@-@@------@---@@@-@@-@
@-@@@@@@@-@@@-@-@-@-@@@-@-@-@-@-@@@-@@-@
--@-@----@@------@--@-@------@@----@-@--
-@@-------@-@-@@----@---@@-@-@-------@@-
-@-------@--@--@----@---@--@--@-------@-
-@-@-@-@-@@@--@-@-@-@@-@-@--@@@-@-@-@-@-
@-----@-@-@-@----@--@-@----@-@-@-@-----@
@---@---@@-@------@@@@------@-@@---@---@
-------@--@------@-@@-@------@--@-------
----------@@--@-@-@@@@-@-@--@@----------
------@-@-@-@--@--@--@--@--@-@-@-@------
----------------------------------------

The bigger the size of the canvas, the better the resolution, that allows for a more exquisite snowflakes that I unfortunately cannot share, because screenshots are fobidden and limited size kills the formatting. The default intended size that nicely fits on modern screens is 60 (vertical lines and 120 horizontal characters).

AI usage

AI has not been used entirely. Not for assistance, not for code generation.

How to run

Create index.html, styles.css, and main.js files and copy the code content in them.
Open index.html with your favourite browser. Tested with Firefox 128.11 only.

When the answers become public I probably will upload the code on Codepen and on Github, so it can be even more accesible.

Besides the canvas there is a menu with controls for customisation. And, as the challange requests a button to generate snowflakes randomly from a given seed.

EDIT: I see some people already posted their solutions on Codepen, so will I, here it is: https://codepen.io/Bohdan-Dudar/full/qEdLVNR

What I learned

It was a nice brain teaser and practice exercise to improve my js and math skills. I am eager to learn something new from other solutions :)

Jun 24 at 16:37, edited Jun 24 at 16:48

0

Yefry Ortiz

1
1

import random

def generate_snowflake(seed, size=15):
    random.seed(seed)
    grid = [[' ' for _ in range(size * 2)] for _ in range(size * 2)]
    center = size

    chars = ['*', '+', '.', 'x', 'o']

    def plot_symmetrical(x, y, char):
        points = []
        for i in range(6):
            angle = i * 60
            rad = angle * 3.14159 / 180
            xr = int(round(x * cos(rad) - y * sin(rad)))
            yr = int(round(x * sin(rad) + y * cos(rad)))
            points.append((xr, yr))
        for px, py in points:
            gx, gy = center + px, center + py
            if 0 <= gx < size * 2 and 0 <= gy < size * 2:
                grid[gy][gx] = char

    from math import sin, cos
    grid[center][center] = '*'

    for r in range(1, size):
        if random.random() < 0.8: 
            char = random.choice(chars)
            plot_symmetrical(r, 0, char)

        if random.random() < 0.4:  
            branch_char = random.choice(chars)
            plot_symmetrical(r, 1, branch_char)
            plot_symmetrical(r, -1, branch_char)

    result = "\n".join("".join(row) for row in grid)
    return result
seed_input = input("Enter a seed for your snowflake: ")
print(generate_snowflake(seed_input))

This is python code. As a senior python developer I am very interested for this challenge.

Jun 25 at 2:15

0

Volodymyr Petrovich

1
1

import random

def generate_wedge(size, seed):
    random.seed(seed)
    wedge = [[" " for _ in range(size)] for _ in range(size)]
    for i in range(size):
        for j in range(i + 1):
            wedge[i][j] = random.choice(["*", "+", ".", " "]) if random.random() < 0.3 else " "
    return wedge

def mirror_wedge(wedge):
    size = len(wedge)
    def rotate(matrix):  # 60-degree rotations approximated by transpose & reverse
        return list(zip(*matrix[::-1]))

    def reflect(matrix):
        return [row[::-1] for row in matrix]

    full = wedge
    for _ in range(5):
        wedge = rotate(wedge)
        full = [a + [" "] + b for a, b in zip(full, wedge)]
    return full

def render_snowflake(size=10, seed="frostbyte"):
    wedge = generate_wedge(size, seed)
    flake = mirror_wedge(wedge)
    return "\n".join("".join(row) for row in flake)

# Example
if __name__ == "__main__":
    print(render_snowflake(10, seed="hexacool"))

Jun 26 at 4:51

0

Ros Sokcheanith

11
3

using System;
using System.Collections.Generic;

namespace SnowflakeArt
{
    class Program
    {
        private const int GridSize = 41;
        private const int Center = GridSize / 2;

        private static readonly char[] DrawingChars = ['*', '+', 'x', '/', '\\', '|', '.'];

        static void Main(string[] args)
        {
            var seed = args.Length > 0 ? args[0] : "default";
            var snowflake = GenerateSnowflake(seed);
            PrintGrid(snowflake);
        }

        private static char[,] GenerateSnowflake(string seed)
        {
            var grid = new char[GridSize, GridSize];

            // Fill grid with spaces
            for (var y = 0; y < GridSize; y++)
                for (var x = 0; x < GridSize; x++)
                    grid[y, x] = ' ';

            var rand = new Random(seed.GetHashCode());

            // Generate random lines in one 60-degree wedge
            const int branches = 10;
            for (var i = 0; i < branches; i++)
            {
                var length = rand.Next(5, 15);
                var angle = rand.NextDouble() * Math.PI / 3; // 0 to 60 degrees

                var x1 = (int)Math.Round(length * Math.Cos(angle));
                var y1 = (int)Math.Round(length * Math.Sin(angle));
                var ch = DrawingChars[rand.Next(DrawingChars.Length)];

                // Draw the same line rotated 6 times
                for (var k = 0; k < 6; k++)
                {
                    var (rx0, ry0) = Rotate60(0, 0, k);
                    var (rx1, ry1) = Rotate60(x1, y1, k);
                    DrawLine(grid, rx0, ry0, rx1, ry1, ch);
                }
            }

            return grid;
        }

        private static (int x, int y) Rotate60(int x, int y, int times)
        {
            var angle = times * Math.PI / 3;
            var cos = Math.Cos(angle);
            var sin = Math.Sin(angle);
            var newX = (int)Math.Round(x * cos - y * sin);
            var newY = (int)Math.Round(x * sin + y * cos);
            return (newX, newY);
        }

        private static void DrawLine(char[,] grid, int x0, int y0, int x1, int y1, char ch)
        {
            var dx = Math.Abs(x1 - x0);
            var dy = -Math.Abs(y1 - y0);
            var sx = x0 < x1 ? 1 : -1;
            var sy = y0 < y1 ? 1 : -1;
            var err = dx + dy;

            while (true)
            {
                var px = Center + x0;
                var py = Center + y0;

                if (px is >= 0 and < GridSize && py is >= 0 and < GridSize)
                    grid[py, px] = ch;

                if (x0 == x1 && y0 == y1)
                    break;

                var e2 = 2 * err;
                if (e2 >= dy) { err += dy; x0 += sx; }

                if (e2 > dx)
                {
                    continue;
                }

                err += dx; y0 += sy;
            }
        }

        private static void PrintGrid(char[,] grid)
        {
            for (var y = 0; y < GridSize; y++)
            {
                for (var x = 0; x < GridSize; x++)
                    Console.Write(grid[y, x]);
                Console.WriteLine();
            }
        }
    }
}

How to Run

dotnet new console -n SnowflakeArt
cd SnowflakeArt
# Replace Program.cs with the above code
dotnet run -- frosty-day

Output

                     \     /                     
               \     *.*     /               
             +.*.*.   +   .*.*.+             
           .+.     /     \     .+.           
         ..       x       x       ..         
       ..         +       +         ..       
      .           *       *           .      
       ..         +       +         ..       
         ..       x       x       ..         
           .+.     \     /     .+.           
             +.*.*.   +   .*.*.+             
               /     *.*     \               
                     /     \

Jun 26 at 8:46

0

Shaily Shah

1

import random

def snow(seed_value):
    random.seed(seed_value)
    
    size = random.randint(5, 9)
    symbols = ['*', '+', 'x', 'o', '#']
    symbol = random.choice(symbols)

    flake = []
    
    # Build top half
    for i in range(size):
        spaces = abs(size // 2 - i)
        chars = size - spaces
        line = ' ' * spaces + (symbol + ' ') * chars
        flake.append(line.strip())
    
    # Mirror top to bottom
    snowflake = flake + flake[::-1][1:]
    
    return "\n".join(snowflake)

# Example: Use a seed
seed = input("Enter seed for your snowflake ❄: ")
print("\n Your Snowflake:\n")
print(snow(seed)).

Jun 26 at 10:27

0

Saravana Kumar

1
2

import random

def generate_snowflake(seed, size=11):
    random.seed(seed)
    
    canvas = [[' ' for _ in range(size)] for _ in range(size)]
    mid = size // 2

    def draw_branch():
        for i in range(1, mid + 1):
            char = random.choice(['*', '+', 'x', '#'])
            canvas[mid - i][mid] = char  # up
            canvas[mid + i][mid] = char  # down
            canvas[mid][mid - i] = char  # left
            canvas[mid][mid + i] = char  # right
            if mid - i >= 0 and mid - i < size:
                canvas[mid - i][mid - i] = char  # top-left
                canvas[mid - i][mid + i] = char  # top-right
                canvas[mid + i][mid - i] = char  # bottom-left
                canvas[mid + i][mid + i] = char  # bottom-right

    draw_branch()
    canvas[mid][mid] = 'O' 

    for row in canvas:
        print(''.join(row))


generate_snowflake("snowflake123")

Jun 26 at 12:12

0

Mathias Alonso

11
4

Sorry for posting none, i just want to lear how to do it with already done code!

Jun 26 at 12:46

0

Amaan Haider

1
1

  / \__
 (    @\___
 /         O
/   (_____/
/_____/ U

A DOG HAHA

Jun 26 at 13:34

0

Mahira

1
4

Overview / Approach

ASCII art is a fun way to create expressive visuals using just characters. In this challenge, I created an ASCII snowflake generator that takes a random seed to generate unique, symmetrical snowflake designs with varied symbols.

This project was a playful exercise in creativity, symmetry, and programming with constraints — using only text characters.

AI Usage Disclosure

No AI-generated code was used in writing the generator itself. I brainstormed design ideas with AI support and debugged layout logic manually.

My Approach

The code mirrors characters across vertical, horizontal, and diagonal axes.
The seed determines the symbol arrangement and pattern complexity.
Snowflakes are always symmetrical and visually unique.

What I Learned
- Even simple loops and character manipulation can yield beautiful results.
- Generating hexagonal symmetry in ASCII requires careful attention to coordinate logic.
- ASCII art is a great way to test visual thinking in code!

import random

def generate_snowflake(seed, size=5):
    random.seed(seed)
    symbols = ['*', '+', '.', '#', 'x', 'o']
    flake = [[' ' for _ in range(size*2+1)] for _ in range(size*2+1)]
    
    center = size
    for i in range(size):
        symbol = random.choice(symbols)
        flake[center - i][center] = symbol
        flake[center + i][center] = symbol
        flake[center][center - i] = symbol
        flake[center][center + i] = symbol
        flake[center - i][center - i] = symbol
        flake[center + i][center + i] = symbol
        flake[center - i][center + i] = symbol
        flake[center + i][center - i] = symbol

    return '\n'.join(''.join(row) for row in flake)

# Example usage
print(generate_snowflake("Mahira2025"))

Jun 26 at 13:34

0

Amaan Haider

1
1

def draw_dog_ascii():
    dog_ascii = r"""
  / \__
 (    @\___
 /         O
/   (_____/
/_____/ U
"""
    print(dog_ascii)

# Call the function
draw_dog_ascii()

Jun 26 at 13:36

1

SubtleSnack

15
4

Hallo everyone! My first approach to this challenge was me trying to display the snowflake line by line taking into consideration the variable number of empty spaces and stars needed in each line. But I decided in the end to just go with the x,y coordinates approach, even though I wanted at the end to give it a go with a recursive approach but due to time-constraints I decided to just submit the working version that I got so far:

import random

def step(sign=1):
    # generator for values [0.125, 0.25, 0.5, 1, 2] with a custom sign
    num = 0.125*sign
    for _ in range (0,5):
        yield num
        num += num

def print_ln(arg):
        print(arg, end='')

def flake_snow(seed):
    
    def toggle_symbol(i,j):
        if i%2==0 and j%2==0:
            return "*"
        elif j==0:
            return "|"
        elif i == -1*j:
            return "/"
        if i == j:
            return "\\"
        return "*"
        
    random.seed(seed)
    flake_n = random.randint(2,20)
    multipliers = [x for x in step()]+[x for x in step(-1)]
    for i in range (-1*flake_n*2, flake_n*2+1):
        for j in range (-1*flake_n*2, flake_n*2+1):
            current_symbol = toggle_symbol(i,j)
            if any([i==n*j for n in multipliers]):
                print_ln(current_symbol)
            elif i==0 or j==0:
                print_ln(current_symbol)
            else:
                print_ln(' ')
        print()

Here are some examples of the generated snowflakes with inputs 123, 22 respectively:

*  *  *  *  *
 \    |    / 
  * * * * *  
*  \  |  /  *
  * ***** *  
  * *\|/* *  
*************
  * */|\* *  
  * ***** *  
*  /  |  \  *
  * * * * *  
 /    |    \ 
*  *  *  *  *

*     *     *     *     *
 \          |          / 
  *    *    *    *    *  
   \        |        /   
    *   *   *   *   *    
     \      |      /     
*     *  *  *  *  *     *
  *    \    |    /    *  
    *   * * * * *   *    
*     *  \  |  /  *     *
    *   * ***** *   *    
    *   * *\|/* *   *    
*************************
    *   * */|\* *   *    
    *   * ***** *   *    
*     *  /  |  \  *     *
    *   * * * * *   *    
  *    /    |    \    *  
*     *  *  *  *  *     *
     /      |      \     
    *   *   *   *   *    
   /        |        \   
  *    *    *    *    *  
 /          |          \ 
*     *     *     *     *

I made sure not to use AI for this challenge, but I will admit I did use AI for one thing: I sent some of the generated snowflakes and asked it thinks this is, and the first guess was a snowflake, so I guess they are good!
To run the code, just call the function flake_snow() and pass any number to it then you should get a snowflake!
The top challenge was to keep the amount of if-statements to a minimum, this is why at some point I hoped I just locked-in to making a recursive approach in order to avoid the code-refactoring part and because that would be more challenging rather than tedious, so yeah the generator function step() helped me create an array of multipliers without manually typing it and combined with the magic of any() your code becomes much more concise, the one thing that I also wanted to make more concise was the toggle_symbol() function but that's maybe for later.

Jun 26 at 13:56

0

Sourik Das

16
1

import random

def init_grid(size):
    return [[' ' for _ in range(size)] for _ in range(size)]

def draw_line(grid, cx, cy, dx, dy, steps, char):
    for i in range(steps):
        x = cx + dx * i
        y = cy + dy * i
        if 0 <= x < len(grid) and 0 <= y < len(grid):
            grid[y][x] = char

def mirror_directions(base_dirs):
    return base_dirs + [(-x, -y) for x, y in base_dirs]

def generate_snowflake(seed, size=21):
    random.seed(seed)
    grid = init_grid(size)
    cx = cy = size // 2

    directions = mirror_directions([(1, 0), (0, 1), (1, 1), (-1, 1)])  # 8 directions
    chars = ['*', '+', 'x', 'o', '|', '/', '\\', '-']

    for _ in range(6):
        dir = random.choice(directions)
        steps = random.randint(4, size//2)
        char = random.choice(chars)
        draw_line(grid, cx, cy, dir[0], dir[1], steps, char)

    return grid

def print_grid(grid):
    for row in grid:
        print(''.join(row))

Jun 26 at 13:59

2

ufo

685
2
12
35

My simple solution (just a PoC, to be honest) is based on the fact that all snowflakes (or at least many of them) are symmetrical. So, my approach to creating these snowflakes is basically the following:

I define a grid of chars, with odd numbers of rows and columns;
I create a special middle row, which primarily features "horizontal" chars and an exclusive char for the center;
I create the top-left quadrant of the grid;
I create a special middle "half" column, which mostly uses "vertical" chars;
I then "mirror" the top-left quadrant to form the top-right quadrant;
I then again "mirror" the top-half of the snowflake to create the bottom-half
I obtain the complete snowflake by merging the top-half, the middle row and the bottom-half.

So said, the first challenge was finding ASCII chars suitable for horizontal positions (like _ , - , + , etc.), the vertical positions (like | , O, etc.), and those that appear symmetrical or at least give that impression. I've only found the pairs / \ and ° o. However, most of the snowflake's symmetry comes from the mirroring operations themselves.

I developed a simple console application in .NET 9. Since I only had to deal with chars, a more complex solution wasn't necessary! You can clone the repository from GitHub and test it yourself:
https://github.com/ufobm/snowflakes

Anyway, the significant piece of code is the following:

static void GenerateSnowflake(int seed)
{
    char[] ascii_chars = { '\\', '\\', '\\', '\\', '\\', '|', '|', 'o', 'O', '*', '+' };
    char[] ascii_central_chars = { '|', '|', '|', '|', '|', '|', 'o', '*', '+', '°' };
    char[] ascii_center_chars = { 'o', '0', '@', '+', '*', 'X' };
    char[] ascii_center_row_chars = { '-', '-', '-', '-', '-', '-', '*', '*', 'o', 'O', '+', ' ' };

    var random = new Random(seed);

    // We'll use a grid of 13x7 for the snowflakes.
    // ****************************
    // * Example:
    // *       o   
    // *    o  |  o 
    // *   . \ | / .
    // * X'-:-'O'-:-'X
    // *   . / | \ . 
    // *    o  |  o 
    // *       o  
    // ****************************

    // To make them more unique the size can vary +2.
    var increaseSize = random.Next(0, 2) == 1 ? 2 : 0;
    var columnNumber = 13 + increaseSize;
    var rowNumber = 7 + increaseSize;

    // We always have a center point in the grid and odd number of rows and columns.
    var upperRows = new List<string>();
    var lowerRows = new List<string>();
    var halfRowNumber = rowNumber / 2;
    var halfColumnNumber = columnNumber / 2;

    // Upper half of the snowflake.
    for (var i = 0; i < halfRowNumber; i++)
    {
        var row = string.Empty;

        // Left side of the snowflake.
        for (int j = 0; j < halfColumnNumber; j++)
        {
            // Outer rows are sparse, inner rows are denser.
            var hasChar = random.Next(0, 10) > 7 - i;

            // The first chars in outer rows are always empty.
            if (j < halfRowNumber - i)
                hasChar = false;

            if (hasChar)
                row += ascii_chars[random.Next(0, ascii_chars.Length)];
            else
                row += ' ';
        }

        // Center of the snowflake.
        row += ascii_central_chars[random.Next(0, ascii_central_chars.Length)];

        // Right side of the snowflake.
        for (var j = 0; j < halfColumnNumber; j++)
            row += ReplaceHorizontal(row[halfColumnNumber - j - 1]);

        upperRows.Add(row);
    }

    // Center row of the snowflake.
    var centerRow = string.Empty;
    for (var i = 0; i < halfColumnNumber; i++)
    {
        centerRow += ascii_center_row_chars[random.Next(0, ascii_center_row_chars.Length)];
    }
    centerRow += ascii_center_chars[random.Next(0, ascii_center_chars.Length)];
    for (var i = 0; i < halfColumnNumber; i++)
    {
        centerRow += ReplaceHorizontal(centerRow[halfColumnNumber - i - 1]);
    }

    // Lower half of the snowflake.
    for (var i = 0; i < halfRowNumber; i++)
        lowerRows.Add(ReplaceVertical(upperRows[halfRowNumber - i - 1]));

    Console.WriteLine();

    foreach (var row in upperRows)
        Console.WriteLine(row);
    Console.WriteLine(centerRow);
    foreach (var row in lowerRows)
        Console.WriteLine(row);

    Console.WriteLine();
}

Given a seed for a random number generator, I calculate the size of the grid of chars. Most of the effort goes into creating the upper-left-half of the snowflake. The center column of the snowflake is a random character chosen from an array, and the right-half is the mirroring of the left one. The center row is also quite simple to create, as it just use a different source array of chars and a special array for its central char. Finally, the lower-half of the snowflake is the mirroring of the upper one.

Some additional considerations: the character arrays have repeated entries to change the probability of each character's selection. While I could have adjusted the probabilities based on the index, this approach allows for more iterative adjustments. The results can vary significantly by changing this setup. I also decided to make the snowflake's outer rows sparser and the inner rows denser. This gives less "squared" shapes, which I believe appear more natural.

Feel free to clone the repository and experiment yourself! Keep in mind that not all seeds will generate aesthetically pleasing results. Change the code, the seed, the arrays, the characters, and anything else you wish to have fun finding the best setups!

Here are some "good" snowflakes generated by my solution:


Seed = 2

     \ | /
      \*/
    *o\o/o*
 \  oo | oo  /
--- *--@--* ---
 /  °° | °°  \
    *°/°\°*
      /*\
     / | \

Seed = 7

      °
   \ \+/ /
 \|   |   |/
 --oO-o-Oo--
 /|   |   |\
   / /+\ \
      o

Seed = 11

     +|+
      °
 +   ***   +
*-** -@- **-*
 +   ***   +
      o
     +|+

etc.

AI usage disclosure: I haven't used any AI assistance, only the autocomplete function of Visual Studio IDE.

Jun 26 at 15:27

2

Colton Sellner

1
2

My simple approach builds a Stellar Dendrite with random characters at the intersection of branches. It has an option to print information on how a snowflake is formed.

Code:

snowflake.cpp

#include <iostream>
#include <fstream>
#include <string>
#include <cstdlib>

/***************************************************************************************
* Title:        sleep()
* Author:       GManNickG, edited by ad absurdum
* Date:         2021-01-30
* Availability: https://stackoverflow.com/a/1658429
* Purpose:      Pause execution for a number of milliseconds
***************************************************************************************/
#ifdef _WIN32
    #include <windows.h>

    void sleep(unsigned milliseconds)
    {
        Sleep(milliseconds);
    }
#else
    #include <unistd.h>
    
    void sleep(unsigned milliseconds)
    {
        usleep(milliseconds * 1000); // takes microseconds
    }
#endif

using namespace std;

void Clear();

const int NUM_STAGES = 4;
const char centeredCharacters[] = {'#', '$', '%', '+', '0', '@', 'O'};

// information from https://www.its.caltech.edu/~atomic/snowcrystals/dendrites/dendrite.htm and snowcrystals.com
const string information[NUM_STAGES] = {
    "Snowflakes start as a piece of dust, on which water vapor converts to ice. This forms a small crystal.",
    "The crystal may grow dendrites, or tree-like structures.",
    "These dendrites may grow their own branches.",
    "A snowflake like this is called a Stellar Dendrite."
};

int main(int argc, char* argv[]) {
    if (argc == 1) {
        cout << "An integer must be provided for the first parameter.\n";
        cout << "Example: ./snowflake.out 12345\n";
        return -1;
    } else {
        string line; // line of text from file
        string filename = "snowflake.txt";
        ifstream inFile(filename);
        bool educational = (argc >= 3 && string(argv[2]) == "e"); // true if user entered 'e' as an argument
        string dummy; // for "Press ENTER to continue"

        // determine random characters for stages
        srand(atoi(argv[1]));
        char randCharArr[3];
        for (int i = 0; i < 3; i++) {
            randCharArr[i] = centeredCharacters[rand() % 7];
        }

        if (!inFile.is_open())
            cout << "failed to open " << filename << '\n';
        else {
            for (int i = 0; i < NUM_STAGES; i++) { // loop through each stage
                // first print the title of a snowflake stage (ex. Stage 1)
                Clear();
                getline(inFile, line);
                cout << line << endl << endl;

                // then print each line of the snowflake
                for (int j = 2; j <= 10; j++) {
                    getline(inFile, line);
                    for (int k = 0; k < line.size(); k++) {
                        if (line.at(k) == '0') {
                            line.replace(k, 1, 1, randCharArr[0]);
                        } else if (line.at(k) == '1') {
                            line.replace(k, 1, 1, randCharArr[1]);
                        } else if (line.at(k) == '2') {
                            line.replace(k, 1, 1, randCharArr[2]);
                        }
                    }
                    cout << line << endl;
                }

                // finally print informational message or wait one second
                if (educational) {
                    cout << information[i] << endl;
                    cout << "Press ENTER to continue";
                    getline(cin, dummy);
                } else { // user chose automatic
                    sleep(1000);
                }
            }
        }

        inFile.close();
        return 0;
    }
}

/***************************************************************************************
* Title:        Clear()
* Author:       Joma
* Date:         2020-11-17
* Availability: https://stackoverflow.com/a/52895729/30873954
* Purpose:      Clear the console on most Windows, Linux, and Apple machines
***************************************************************************************/
void Clear() {
    #if defined _WIN32
        system("cls");
    #elif defined (__LINUX__) || defined(__gnu_linux__) || defined(__linux__)
        system("clear");
    #elif defined (__APPLE__)
        system("clear");
    #endif
}

snowflake.txt

Stage 1




      0




Stage 2


    1   1
     \ /
   1--0--1
     / \
    1   1


Stage 3

   \ / \ /
  --1   1--
  \  \ /  /
 --1--0--1--
  /  / \  \
  --1   1--
   / \ / \

Stage 4
  2       2
   \ / \ /
  --1   1--
  \  \ /  /
2--1--0--1--2
  /  / \  \
  --1   1--
   / \ / \
  2       2

Here are a couple snowflakes the program created:

  #       #
   \ / \ /
  --@   @--
  \  \ /  /
#--@--+--@--#
  /  / \  \
  --@   @--
   / \ / \
  #       #

  O       O
   \ / \ /
  --@   @--
  \  \ /  /
O--@--+--@--O
  /  / \  \
  --@   @--
   / \ / \
  O       O

You can compile the code with g++ snowflake.cpp -o snowflake and run it with ./snowflake.exe 123 e or ./snowflake.out 123 e where '123' is your seed and 'e' is an optional parameter that interactively prints information about the formation of a snowflake.

Disclaimers

No AI was used for code generation or debugging. I do not have an Apple machine and cannot guarantee that it will run on one.

Jun 26 at 17:07

8

Emre

158
1
12

Approach

First of all, I aimed to create a hexagonal pattern to create a special snowflake. Most of snowflakes have hexagonal structure so all columns have 60 degree to next one.

CreateColumns is a function doing this job correctly. It has four parameters :

srcPoint: Starting point (most of time it is center of square array)

length: Distance from starting point to end point (px)

angle: Angle of column

ptrn: ASCII character

CreateNeedles is a function for doing little wings. It has four parameters :

distance: Distance from center point to starting point (px)

other parameters same as CreateColumns's

All parameters can be used to create a custom snowflake

Detailed description and improved version will be added on my github repo soon https://github.com/emrekz/snowflakes

Code

#include <stdio.h>
#include <math.h>

#define FONT_WIDTH_PX       8
#define FONT_HEIGHT_PX      17
#define SIZE                500

#define RATIO               (FONT_HEIGHT_PX/FONT_WIDTH_PX)

#define PI                  3.1415926

#define WIDTH_CHAR_COUNT    (SIZE/(FONT_WIDTH_PX*RATIO))
#define HEIGHT_CHAR_COUNT   (SIZE/FONT_HEIGHT_PX)

typedef struct {
  int x;
  int y;
} ORIGIN;

void CreateColumns(ORIGIN srcPoint, int length, int angle, char ptrn);
void CreateNeedles(int distance, int length, int angle, char ptrn);

char snowFlake[HEIGHT_CHAR_COUNT][WIDTH_CHAR_COUNT][RATIO] = {0};
ORIGIN origin = {WIDTH_CHAR_COUNT/2, HEIGHT_CHAR_COUNT/2};

const int hexagon[6] = {30, 90, 150, 210, 270, 330};

int main() {
  for(int h=0; h<HEIGHT_CHAR_COUNT; h++) {
    for(int w=0; w<WIDTH_CHAR_COUNT; w++) {
      for(int c=0; c<2; c++) {
        snowFlake[h][w][c] = ' ';
      }
    }
  } 

  CreateColumns(origin, 200, 30, '0');
  CreateColumns(origin, 200, 90, '0');
  CreateColumns(origin, 200, 150, '0');
  CreateColumns(origin, 200, 210, '0');
  CreateColumns(origin, 200, 270, '0');
  CreateColumns(origin, 200, 330, '0');
  
  CreateNeedles(50, 30, 35, '#');
  CreateNeedles(90, 50, 45, ':');
  CreateNeedles(150, 70, 55, '*');

  for(int h=0; h<HEIGHT_CHAR_COUNT; h++) {
    for(int w=0; w<WIDTH_CHAR_COUNT; w++) {
      for(int c=0; c<2; c++) {
        printf("%c", snowFlake[h][w][c]);
      }
    }
    printf("\n");
  }
  return 0;
}

void CreateColumns(ORIGIN srcPoint, int length, int angle, char ptrn) {
  ORIGIN desPoint;
  int tmp;
  for(int L=0; L<length; L++) {
    tmp = srcPoint.y + round((L * sin(angle*PI/180)) / FONT_HEIGHT_PX);
    if(tmp >= 0 && tmp <= HEIGHT_CHAR_COUNT) {
      desPoint.y = tmp;
    } else {
      desPoint.y = 0;
    }
    tmp = srcPoint.x + round((L * cos(angle*PI/180)) / (FONT_WIDTH_PX*RATIO));
    if(tmp >= 0 && tmp <= WIDTH_CHAR_COUNT) {
      desPoint.x = tmp;
    } else {
      desPoint.x = 0;
    }
    snowFlake[desPoint.y][desPoint.x][0] = ptrn;
    snowFlake[desPoint.y][desPoint.x][1] = ptrn;
  }
}

void CreateNeedles(int distance, int length, int angle, char ptrn) {
  ORIGIN desPoint;
  int tmp;
  for(int i=0; i<6; i++) {
    tmp = origin.y + round((distance * sin(hexagon[i]*PI/180)) / FONT_HEIGHT_PX);
    if(tmp >= 0 && tmp <= HEIGHT_CHAR_COUNT) {
      desPoint.y = tmp;
    } else {
      desPoint.y = 0;
    }
    tmp = origin.x + round((distance * cos(hexagon[i]*PI/180)) / (FONT_WIDTH_PX*RATIO));
    if(tmp >= 0 && tmp <= WIDTH_CHAR_COUNT) {
      desPoint.x = tmp;
    } else {
      desPoint.x = 0;
    }
    CreateColumns(desPoint, length, angle+hexagon[i], ptrn);
    CreateColumns(desPoint, length, -angle+hexagon[i], ptrn);
  }
}

Example

                              ..
                              ..
                          ****..****
                            ******
                              ..
              **          ::  ..  ::          **
        ....  **  ::      ::::..::::      ::  **  ....        
          ....**  ::::      ::::::      ::::  **....
            ****....::      ######      ::....****
          ****  ::::::##      ##      ##::::::  ****
              ::::  ..####    ..    ####..  ::::
                    ######..........######
                            ......
                    ######..........######
              ::::  ..####    ..    ####..  ::::
          ****  ::::::##      ##      ##::::::  ****
            ****....::      ######      ::....****
          ....**  ::::      ::::::      ::::  **....
        ....  **  ::      ::::..::::      ::  **  ....        
              **          ::  ..  ::          **
                              ..
                            ******
                          ****..****
                              ..
                              ..

                                          oo                                          
                                          oo
                                          oo
                              ++++        oo        ++++
                                ++++      oo      ++++
                    ++            ++++++  oo  ++++++            ++
                    ++                ++++oo++++                ++
                    ++++                ++++++                ++++
                      ++                  oo                  ++
          oo          ++                  oo                  ++          oo
          oooooo      ++        ****      oo      ****        ++      oooooo          
              oooooo  ++        ********  oo  ********        ++  oooooo
                  oo++++        **    ****oo****    **        ++++oo
                ++++++oooooo    **      ******      **    oooooo++++++
          ++++++++        oooooo**        oo        **oooooo        ++++++++
        ++++                  ****        oo        ****                  ++++
                          ******oooooo    oo    oooooo******
                        ****        oooooooooooooo        ****
                                        oooooo
                        ****        oooooooooooooo        ****
                          ******oooooo    oo    oooooo******
        ++++                  ****        oo        ****                  ++++
          ++++++++        oooooo**        oo        **oooooo        ++++++++
                ++++++oooooo    **      ******      **    oooooo++++++
                  oo++++        **    ****oo****    **        ++++oo
              oooooo  ++        ********  oo  ********        ++  oooooo
          oooooo      ++        ****      oo      ****        ++      oooooo
          oo          ++                  oo                  ++          oo
                      ++                  oo                  ++
                    ++++                ++++++                ++++
                    ++                ++++oo++++                ++
                    ++            ++++++  oo  ++++++            ++
                                ++++      oo      ++++
                              ++++        oo        ++++
                                          oo
                                          oo
                                          oo

AI Usage Disclosure

I haven't use AI services. They have not enough information about that

How It Runs

Just compile with a C compiler and run

Jun 26 at 18:32, edited Jun 28 at 21:07

0

The_spider

1.3k
1
9
21

How can I enter a seed in this snowflake generator?

Jun 30 at 15:32

0

Emre

158
1
12

@The_spider I guess you can implement it with help of some research about seed algorithms. Main thing is just change randomly of arguments of CreateColumns and CreateNeedles. I'm sorry I can't help more but you can follow my github repo for coming improvement, maybe I can add seed function in future.

Jul 1 at 16:44

6

elechris

557
4
24

snowflake

Plate snow flake generation using ascii art in python.

Explanation

Parameters for 1 segment are generated, the other 5 segments are copies that are rotated by 60 degree increments. The reason is that real snow flakes have nearly identical segments since they all form under the same conditions (temperature, pressure, humidity, airflow, etc.).

1 branch is max 60 degrees wide, so 30 degrees on each side.

A rectangular grid is used, both height and width are odd length so that there is an exact center.

The height in rows is lower than the width in columns since the character grid is not square. This is adjusted using font_height_to_width.

The center is marked with a ~

Coordinates are normalized to [-1,1].

Position and lengths of children are relative to parent. Length can never exceed length half of parent. Width can never exceed double the width of the parent. Minimum 1 and maximum 3 levels are used (including root) to simplify structure.

Crystal growth is not simulated, instead a tree with branch positions and dimensions is constructed using random parameters this tree is symmetrical and 6 identical copies are used to render the snowflake

Segments can stick through their parent segments, I haven't made a restriction for that. Should not be hard to do.

I used different ASCII characters for different growth directions.

Code

Code is written in python with standard python libraries.

snowflake.py:

from math import atan2, degrees, radians, sin, cos
import random  # random, choice, randint
import time
import sys # for sys.argv


# render preferences:
grid_width = 79 # has to be odd
font_height_to_width = 32/14 # set this to your font ratio. (in vscode I used 32/14, but on "https://www.online-python.com/" I used 20/7)
grid_height = int(((grid_width / font_height_to_width)//2)*2+1)
max_length_sq = 0.9**2
octant_array = "|/=\\|/=\\"
hex_array = "|//z=\\\\N|/7z=\\\\N"


# creates a tree with random branch posititions, angles and lengths, doesn't create mirrored branches
def create_half_tree(level, number_of_levels):
    node = {"connection": 0,                
    "l" : 0,
    "w": 0,
    "angle":0,
    "children":[]        
    }

    if level == 0:
        node["connection"] = 0
    else:
        node["connection"] = random.uniform(0.1,0.9)

    if level == 0:
        node["w"] = random.uniform(0.01,0.2)
    else:
        node["w"] = random.uniform(0.5,2)

    if level == 0:
        node["l"] = random.uniform(0.1,0.9)
    else:
        node["l"] = random.uniform(0.1,0.5)
    
    
    if level == 0:
        node["angle"] = 0        
    elif level == 1:
        node["angle"] = 30
    elif level >= 2:
        node["angle"] = random.choice([30,150])

    number_of_children = random.randint(0,3)

    if level < number_of_levels:
        for i in range(number_of_children):
            child = create_half_tree(level+1, number_of_levels)
            node["children"].append(child)

    return node


# mirrors a node since all branches are symmetrical
def mirror_node(node):
    copy = node.copy()
    copy["angle"] *= -1
    return copy


# mirrors all nodes in a tree, starting at leaf nodes
def mirror_tree(node):
    for child in node["children"]:
        mirror_tree(child)

    mirror_children = [mirror_node(child) for child in node["children"]]
    node["children"] += mirror_children


# extracts all individual nodes from a tree, converts relative dimensions into absoulte dimensions
def get_nodes(root, nodes=[],l=1,w=1, angle=0, origin=[0,0]):
    node = root.copy()
    node["children"] = []
    node["l"] *= l
    node["w"] *= w
    node["angle"] += angle

    nodes.append(node)

    x = origin[0] + sin(radians(angle)) * node["connection"] * l
    y = origin[1] - cos(radians(angle)) * node["connection"] * l
    node["origin"] = [x, y]
    
    for child in root["children"]:
        get_nodes(child,nodes, node["l"], node["w"], node["angle"], node["origin"])

    return nodes


# rotates a point around origin, used to see if a point intersects with a rotated square
def rotate(origin, point, angle):    
    ox, oy = origin
    px, py = point

    x2 = ox + cos(radians(angle)) * (px - ox) - sin(radians(angle)) * (py - oy)
    y2 = oy + sin(radians(angle)) * (px - ox) + cos(radians(angle)) * (py - oy)
    return [x2,y2]


# checks if a point intersects with a rotated square
def is_in_node(node, point):
    # rotate point around origin in opposite direction
    x,y = rotate(node["origin"],point,-node["angle"])

    # compare rotated point to rotated straightened rectangle
    return  x >= node["origin"][0] - node["w"] and x <= node["origin"][0] + node["w"] and \
            y <= node["origin"][1] and y >= node["origin"][1] - node["l"]


# create a full tree using a radom seed and returns all nodes
def create_tree_nodes(seed=None):
    random.seed(seed)
    tree = create_half_tree(0, random.randint(1,3))
    mirror_tree(tree)
    nodes = get_nodes(tree)
    return nodes


# renders the nodes in ascii, an svg function is under development
def render_flake_ascii(nodes):
    flake = ""
    for y in range(grid_height):
        line = list(" "*grid_width+"\n")
        for x in range(grid_width):
            # get coordinates relative to center:
            dx = (x - grid_width//2) / (grid_width//2)
            dy = (y - grid_height//2) / (grid_height//2)
            length_sq = dx**2 + dy**2 # length squared so no need to calculate square root

            angle_degrees = degrees(atan2(dy,dx)) + 90
            if angle_degrees > 180:
                angle_degrees -= 360

            if length_sq == 0:
                line[x] = '~'
            elif length_sq > max_length_sq:
                pass 
            else:
                segment_index = int(((angle_degrees + 30 + 360) %360)//60)
                # octant_index = round(((angle_degrees + 360) %360)/45)%8
                # char = octant_array[octant_index] 

                dx2,dy2 = rotate([0,0],[dx,dy],segment_index*-60)
                for node in nodes:                
                    in_node = is_in_node(node,[dx2,dy2])
                    if in_node:
                        # octant_index = round(((node["angle"]+segment_index*60 + 360) %360)/45)%8
                        # char = octant_array[octant_index]                        

                        hex_index = round(((node["angle"]+segment_index*60 + 360) %360)/22.5)%16                        
                        char = hex_array[hex_index]       

                        line[x] = char
                        break

        flake += ''.join(line)
    return flake


if __name__ == "__main__":
    seed = None
    if len(sys.argv) > 1:
        seed = int(sys.argv[1])
   
    if not seed:
        seed = int(time.time()*10)
    print(f"seed: {seed}")
    nodes = create_tree_nodes(seed)
    ascii_flake = render_flake_ascii(nodes)
    print(ascii_flake)

Example outputs

seed: 17511081380


                                  ||       ||
                               \\NNN||   ||///zz
                                \\NNN|||||///zz
                                  \NNN|||///z
                                  \\NN|||//zz
              ||                   N  |||  /                   ||
           \\NNN||              NNNNN\|||z/////              ||///zz
            \\NNN|||             |NNNN|||////|             |||///zz
              \NNNN|   NNN      ||NNzz|||////||      ///   |////z
       \ \\\\\\\\\\N  NNNN\\\\\   \zz||||//||   zzzzz////  /zzzzzzzzzz z
       ==========\\\\\\|NNNNN|\   ||z||||/|||   |\\////|zzzzzz==========
      zz zzzzzzzz   z\\\\\\NNN\\\\|||||||||||zzz\\\\zzzzzz\   \\\\\\\\ \\
                 =======|\\\\\\\\\    |||    zzzzzzzzz========
                 =======||\\\\\\\\\   |||   zzzzzz============
                    \\\\ z\\\\\ \\\\\\|||zzzzzz zzzzzz zzzz
                            \\      \\\~\\\      \\
                    zzzz zzzzzz zzzzzz|||\\\\\\ \\\\\z \\\\
                 ============zzzzzz   |||   \\\\\\\\\||=======
                 ========zzzzzzzzz    |||    \\\\\\\\\|=======
      \\ \\\\\\\\   \zzzzzz\\\\zzz|||||||||||\\\\NNN\\\\\\z   zzzzzzzz zz
       ==========zzzzzz|////\\|   |||/||||z||   \|NNNNN|\\\\\\==========
       z zzzzzzzzzz/  ////zzzzz   ||//||||zz\   \\\\\NNNN  N\\\\\\\\\\ \
              z////|   ///      ||////|||zzNN||      NNN   |NNNN\
            zz///|||             |////|||NNNN|             |||NNN\\
           zz///||              /////z|||\NNNNN              ||NNN\\
              ||                   /  |||  N                   ||
                                  zz//|||NN\\
                                  z///|||NNN\
                                zz///|||||NNN\\
                               zz///||   ||NNN\\
                                  ||       ||

seed: 17511082569


                                 //|||||||||NN
                                 //|||||||||NN
                          ||||||||||||||||||///||||||
                         ||||NNNNN||||||||||//////||||
                   \\ \\\||||NNNNN||||||||||z/////||||zzz zz
                 \\\ NN\\     NNNN\|||||||||z////     zz// zzz
           \\==\NNNNNNNN      \NN\\|||||||||zz//z      //////z/z==zz
          \\\\\\\NNNNNNNN||||\\\NNN|||||||||///zzz||||//////z/zzzzzzz
        \\\\\\\\\\\\\NNNNNN||| \  N|||||||||/  z |||//////zzzzzzzzzzzzz
       \\\\\\\\\\\\\\\\\\NNN       |||||||||       ///zzzzzzzzzzzzzzzzzz
       NNN\\\\\\\\\\\\\\\\\\\      |||||||||      zzzzzzzzzzzzzzzzzzz///
         \\\=\\\\\\\\\\\\\\\\\\\\  |||||||||  zzzzzzzzzzzzzzzzzzz====z
         \\======z\\\\\\\\\\\\\\\\\\|||||||zzzzzzzzzzzzzzzzzz\=======z
       \\ \=======zz==\\\\\\\\\\\\\\\|||||zzzzzzzzzzzzzzz==\\=======z zz
         \\\\   zzzzz     \\\\\\\\\\\\|||zzzzzzzzzzzz     \\\\\   zzzz
         \\\      zzz         \\\\\\\\\~\\\\\\\\\         zzz      \\\
         zzzz   \\\\\     zzzzzzzzzzzz|||\\\\\\\\\\\\     zzzzz   \\\\
       zz z=======\\==zzzzzzzzzzzzzzz|||||\\\\\\\\\\\\\\\==zz=======\ \\
         z=======\zzzzzzzzzzzzzzzzzz|||||||\\\\\\\\\\\\\\\\\\z======\\
         z====zzzzzzzzzzzzzzzzzzz  |||||||||  \\\\\\\\\\\\\\\\\\\\=\\\
       ///zzzzzzzzzzzzzzzzzzz      |||||||||      \\\\\\\\\\\\\\\\\\\NNN
       zzzzzzzzzzzzzzzzzz///       |||||||||       NNN\\\\\\\\\\\\\\\\\\
        zzzzzzzzzzzzz//////||| z  /|||||||||N  \ |||NNNNNN\\\\\\\\\\\\\
          zzzzzzz/z//////||||zzz///|||||||||NNN\\\||||NNNNNNNN\\\\\\\
           zz==z/z//////      z//zz|||||||||\\NN\      NNNNNNNN\==\\
                 zzz //zz     ////z|||||||||\NNNN     \\NN \\\
                   zz zzz||||/////z||||||||||NNNNN||||\\\ \\
                         ||||//////||||||||||NNNNN||||
                          ||||||///||||||||||||||||||
                                 NN|||||||||//
                                 NN|||||||||//

AI usage disclosure

No AI was used in code generation or assistance with writing code.

Instructions

python snowflake.py

add an optional seed:

python snowflake.py 17511081380

Or test it out here: https://www.online-python.com/a2dPrnBHDF

Lessons learned

for ascii art the height/width ratio of characters is not 1:1 and not constant and depends on font
This Veritasium video taught me how snow crystals grow https://www.youtube.com/watch?v=ao2Jfm35XeE

edit: an optional seed can now be passed to the script, prints the seeds for reproducibility. Added some comments.

Jun 26 at 20:33, edited Jun 30 at 12:03

5

TR4N51ST0R

1
2

1. Explanation of Snowflake Creation Approach

The snowflake creation is based on the Reiter Cellular Automaton Model, which simulates vapor diffusion and ice growth on a hexagonal grid. The model uses three main parameters:

α (Diffusion): Controls the rate of vapor diffusion across the grid.
β (Background Vapor): Represents the initial vapor concentration in the environment.
γ (Growth): Determines the rate at which ice crystals grow.

The simulation starts with a seed point at the center of the grid, and the snowflake grows outward as vapor condenses into ice. The growth stops when the snowflake reaches the edge of the grid or when the maximum number of steps is reached.

2. Code for Snowflake Creation

The code provided implements the Reiter Cellular Automaton Model and generates ASCII art snowflakes. It includes:

A hexagonal grid for simulating vapor diffusion and ice growth.
Adjustable parameters for diffusion, background vapor, and growth rate.
Edge detection to stop growth when the snowflake reaches the boundary.
ASCII art generation to visualize the snowflake.

<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>Reiter Cellular Automaton Snowflake Simulation</title>
    <style>
        body {
            margin: 0;
            display: flex;
            flex-direction: column;
            justify-content: center;
            align-items: center;
            min-height: 100vh;
            background: linear-gradient(to bottom, #0e1a40 0%, #1a3a6c 100%);
            font-family: monospace;
            color: white;
        }
        .controls {
            display: flex;
            gap: 10px;
            margin: 10px;
            flex-wrap: wrap;
        }
        button {
            padding: 8px 16px;
            background: rgba(255, 255, 255, 0.1);
            border: 1px solid rgba(255, 255, 255, 0.3);
            color: white;
            cursor: pointer;
            border-radius: 4px;
        }
        button:hover {
            background: rgba(255, 255, 255, 0.2);
        }
        .info {
            text-align: center;
            margin: 10px;
            font-size: 12px;
            opacity: 0.7;
        }
        .parameter-controls {
            display: flex;
            gap: 15px;
            margin: 10px;
            font-size: 12px;
        }
        .param-group {
            display: flex;
            flex-direction: column;
            align-items: center;
        }
        input[type="range"] {
            width: 80px;
        }
        .ascii-output {
            background: rgba(0, 0, 0, 0.8);
            border: 1px solid rgba(255, 255, 255, 0.3);
            border-radius: 4px;
            padding: 15px;
            margin: 10px;
            font-family: 'Courier New', monospace;
            font-size: 8px;
            line-height: 1;
            white-space: pre;
            overflow: auto;
            max-width: 90vw;
            min-width: 400px;
            min-height: 400px;
            color: #00FFFF;
        }
        .output-controls {
            display: flex;
            gap: 10px;
            margin: 10px;
            align-items: center;
        }
        #asciiSize {
            width: 60px;
        }
    </style>
</head>
<body>
    <div class="info">
        Reiter Cellular Automaton Snowflake Simulation<br>
        Vapor Diffusion and Ice Growth → ASCII Art
    </div>
    <div class="parameter-controls">
        <div class="param-group">
            <label>α (Diffusion): <span id="alphaValue">1.0</span></label>
            <input type="range" id="alphaSlider" min="0.1" max="2.0" step="0.1" value="1.0">
        </div>
        <div class="param-group">
            <label>β (Background Vapor): <span id="betaValue">0.4</span></label>
            <input type="range" id="betaSlider" min="0.1" max="1.0" step="0.1" value="0.4">
        </div>
        <div class="param-group">
            <label>γ (Growth): <span id="gammaValue">0.001</span></label>
            <input type="range" id="gammaSlider" min="0.0001" max="0.05" step="0.0001" value="0.001">
        </div>
    </div>
    <div class="controls">
        <button onclick="generateNewSnowflake()">Regenerate Snowflake</button>
    </div>
    <div class="info">
        Current Steps: <span id="stepCount">0</span> | 
        Water Range: <span id="waterRange">[0.40, 1.00]</span>
    </div>
    <div id="asciiOutput" class="ascii-output"></div>

    <script>
        const stepDisplay = document.getElementById('stepCount');
        const waterRangeDisplay = document.getElementById('waterRange');
        const asciiOutput = document.getElementById('asciiOutput');
        const asciiSizeSlider = document.getElementById('asciiSize');
        const asciiSizeValue = document.getElementById('asciiSizeValue');
        
        const alphaSlider = document.getElementById('alphaSlider');
        const betaSlider = document.getElementById('betaSlider');
        const gammaSlider = document.getElementById('gammaSlider');
        const alphaValue = document.getElementById('alphaValue');
        const betaValue = document.getElementById('betaValue');
        const gammaValue = document.getElementById('gammaValue');
        
        alphaSlider.addEventListener('input', (e) => {
            alpha = parseFloat(e.target.value);
            alphaValue.textContent = alpha.toFixed(1);
        });
        
        betaSlider.addEventListener('input', (e) => {
            beta = parseFloat(e.target.value);
            betaValue.textContent = beta.toFixed(1);
        });
        
        gammaSlider.addEventListener('input', (e) => {
            gamma = parseFloat(e.target.value);
            gammaValue.textContent = gamma.toFixed(4);
        });

        // Grid parameters
        const GRID_SIZE = 100;
        const HEX_SIZE = 3; // Hexagon side length
        let s = []; // Water grid (GRID_SIZE+2) x (GRID_SIZE+2)
        let step = 0;
        let asciiSize = GRID_SIZE;
        let maxRadius = 0;
        let growthStopped = false;
        
        // Reiter model parameters
        let alpha = 1.0;   // Diffusion coefficient
        let beta = 0.4;    // Background vapor
        let gamma = 0.005; // Growth rate
        
        // ASCII character set (bright to dark)
        const ASCII_CHARS = '@%#*+=-:. ';
        
        // Hex grid coordinate calculation
        function getHexagonCenter(r, c, L) {
            const x = c * 3/2 * L;
            const y = r * Math.sqrt(3) * L + (c % 2) * Math.sqrt(3)/2 * L;
            return { x: x, y: -y };
        }
                
        function getHexNeighbors(r, c) {
            const standardOffsets = [
                [0, -1], [0, 1],    // Left and right
                [-1, 0], [1, 0]     // Up and down
            ];

            if (c % 2 === 0) {
                standardOffsets.push([-1, -1], [-1, 1]); // Diagonal offsets for even columns
            } else {
                standardOffsets.push([1, -1], [1, 1]);   // Diagonal offsets for odd columns
            }
            
            return standardOffsets.map(([dr, dc]) => [r + dr, c + dc]);
        }
        
        // Get neighbor values
        function getNeighborValues(grid, r, c) {
            const neighbors = getHexNeighbors(r, c);
            const values = [];
            
            for (let [nr, nc] of neighbors) {
                if (nr >= 0 && nr < grid.length && nc >= 0 && nc < grid[0].length) {
                    values.push(grid[nr][nc]);
                } else {
                    values.push(beta);
                }
            }
            return values;
        }
        
        // Calculate the average value of neighbors
        function computeMean(grid) {
            const result = Array(GRID_SIZE).fill().map(() => Array(GRID_SIZE).fill(0));
            
            for (let r = 1; r <= GRID_SIZE; r++) {
                for (let c = 1; c <= GRID_SIZE; c++) {
                    const neighbors = getNeighborValues(grid, r, c);
                    result[r-1][c-1] = neighbors.reduce((sum, val) => sum + val, 0) / 6.0;
                }
            }
            return result;
        }
        
        // Determine if the cell is frozen
        function isFrozen(value) {
            return value >= 1.0;
        }
        
        // Check if there are frozen neighbors
        function hasFrozenNeighbors(r, c) {
            const neighbors = getNeighborValues(s, r, c);
            return neighbors.some(val => isFrozen(val));
        }
        
        // Determine if the cell is receptive (acceptable)
        function isReceptive(r, c) {
            return isFrozen(s[r][c]) || hasFrozenNeighbors(r, c);
        }
        
        // Reiter model update rules
        function updateReiter() {
            const newS = Array(GRID_SIZE + 2).fill().map(() => Array(GRID_SIZE + 2).fill(beta));
            
            // Set boundary conditions
            for (let i = 0; i < GRID_SIZE + 2; i++) {
                newS[0][i] = beta;
                newS[GRID_SIZE + 1][i] = beta;
                newS[i][0] = beta;
                newS[i][GRID_SIZE + 1] = beta;
            }
            
            // Process receptive cells
            const v = Array(GRID_SIZE + 2).fill().map(() => Array(GRID_SIZE + 2).fill(0));
            for (let r = 1; r <= GRID_SIZE; r++) {
                for (let c = 1; c <= GRID_SIZE; c++) {
                    if (isReceptive(r, c)) {
                        v[r][c] = s[r][c] + gamma;
                    }
                }
            }
            
            // Handle diffusion for non-receptive cells
            const u = Array(GRID_SIZE + 2).fill().map((_, r) => 
                Array(GRID_SIZE + 2).fill().map((_, c) => {
                    if (r === 0 || r === GRID_SIZE + 1 || c === 0 || c === GRID_SIZE + 1) {
                        return beta;
                    }
                    return !isReceptive(r, c) ? s[r][c] : 0;
                })
            );
            
            // Diffusion calculation
            const uMean = computeMean(u);
            for (let r = 1; r <= GRID_SIZE; r++) {
                for (let c = 1; c <= GRID_SIZE; c++) {
                    u[r][c] = u[r][c] + alpha * (uMean[r-1][c-1] - u[r][c]);
                    newS[r][c] = u[r][c] + v[r][c];
                }
            }
            
            s = newS;
        }
        
        function checkEdgeCollision() {
            const centerR = Math.floor((GRID_SIZE + 2) / 2);
            const centerC = Math.floor((GRID_SIZE + 2) / 2);
            maxRadius = 0;
            
            for (let r = 1; r <= GRID_SIZE; r++) {
                for (let c = 1; c <= GRID_SIZE; c++) {
                    if (s[r][c] > beta * 1.1) {
                        const distance = Math.sqrt((r - centerR) ** 2 + (c - centerC) ** 2);
                        maxRadius = Math.max(maxRadius, distance);
                        
                        const edgeDistance = Math.min(r - 1, GRID_SIZE - r, c - 1, GRID_SIZE - c);
                        if (edgeDistance < 15) {
                            return true;
                        }
                    }
                }
            }
            return false;
        }
                
        // Generate ASCII art
        function draw() {
            let minR = GRID_SIZE, maxR = 0, minC = GRID_SIZE, maxC = 0;
            for (let r = 1; r <= GRID_SIZE; r++) {
                for (let c = 1; c <= GRID_SIZE; c++) {
                    if (s[r][c] > beta * 1.1) {
                        minR = Math.min(minR, r);
                        maxR = Math.max(maxR, r);
                        minC = Math.min(minC, c);
                        maxC = Math.max(maxC, c);
                    }
                }
            }

            if (minR >= maxR || minC >= maxC) {
                asciiOutput.textContent = 'No snowflake growth detected, please run the simulation first!';
                asciiOutput.style.display = 'block';
                return;
            }

            const snowflakeWidth = maxC - minC + 1;
            const snowflakeHeight = maxR - minR + 1;
            const scaleX = asciiSize / snowflakeWidth;
            const scaleY = asciiSize / snowflakeHeight;
            const scale = Math.min(scaleX, scaleY);

            const outputWidth = Math.floor(snowflakeWidth * scale);
            const outputHeight = Math.floor(snowflakeHeight * scale);

            let ascii = '';
            for (let y = 0; y < outputHeight; y++) {
                for (let x = 0; x < outputWidth; x++) {
                    const origR = Math.floor(minR + y / scale);
                    const origC = Math.floor(minC + x / scale);

                    if (origR >= 1 && origR <= GRID_SIZE && origC >= 1 && origC <= GRID_SIZE) {
                        const value = s[origR][origC];
                        if (value > beta * 1.05) {
                            // Display snowflake pixels only
                            let intensity;
                            if (value < 1.0) {
                                intensity = Math.max(0, (value - beta) / (1.0 - beta) * 0.6);
                            } else {
                                intensity = Math.min(1.0, 0.6 + (value - 1.0) * 2);
                            }
                            const charIndex = Math.floor(intensity * (ASCII_CHARS.length - 1));
                            ascii += ASCII_CHARS[charIndex];
                            if (x % 2 === 1) {
                                ascii += ASCII_CHARS[charIndex]; // Double character width
                            }
                        } else {
                            // Do not print background characters
                            ascii += ' ';
                            if (x % 2 === 1) {
                                ascii += ' '; // Double character width
                            }
                        }
                    } else {
                        ascii += ' ';
                    }
                }
                ascii += '\n';
            }

            asciiOutput.textContent = ascii;
            asciiOutput.style.display = 'block';
        }
        
        // Update display information
        function updateDisplay() {
            stepDisplay.textContent = step;
            
            let min = Infinity, max = -Infinity;
            for (let r = 1; r <= GRID_SIZE; r++) {
                for (let c = 1; c <= GRID_SIZE; c++) {
                    min = Math.min(min, s[r][c]);
                    max = Math.max(max, s[r][c]);
                }
            }
            
            checkEdgeCollision();
            
            waterRangeDisplay.textContent = `[${min.toFixed(2)}, ${max.toFixed(2)}] | Radius: ${maxRadius.toFixed(1)}`;
            
            if (maxRadius > (GRID_SIZE / 2 - 20)) {
                waterRangeDisplay.style.color = '#ffaa00';
            } else {
                waterRangeDisplay.style.color = 'white';
            }
        }

        function initCanvas() {
            const maxX = Math.max(...Array.from({length: GRID_SIZE}, (_, r) => 
                Array.from({length: GRID_SIZE}, (_, c) => getHexagonCenter(r, c, HEX_SIZE).x)
            ).flat());
            const maxY = Math.max(...Array.from({length: GRID_SIZE}, (_, r) => 
                Array.from({length: GRID_SIZE}, (_, c) => Math.abs(getHexagonCenter(r, c, HEX_SIZE).y))
            ).flat());
                        
            // Initialize the water grid
            s = Array(GRID_SIZE + 2).fill().map(() => Array(GRID_SIZE + 2).fill(beta));
            
            // Set seed point
            const center = Math.floor((GRID_SIZE + 2) / 2);
            s[center][center] = 1.0;
            
            step = 0;
            maxRadius = 0;
            growthStopped = false;
            updateDisplay();
        }
        
        // Regenerate snowflake - One-click process
        function generateNewSnowflake() {
            console.log("Starting to generate a new snowflake...");
            beta = 0.1 + Math.random() * 0.8; // Random background vapor
            betaValue.textContent = beta.toFixed(1);
            gamma = 0.001 + Math.random() * (0.05 - 0.001); // Random growth rate
            gammaValue.textContent = gamma.toFixed(4);
            
            // Initialize
            initCanvas();
            
            // Automatically grow until edge detection stops
            const growthInterval = setInterval(() => {
                // Edge detection
                if (checkEdgeCollision()) {
                    growthStopped = true;
                    clearInterval(growthInterval);
                    console.log(`Snowflake stopped growing near the edge at step ${step}`);
                    console.log(`Maximum radius: ${maxRadius.toFixed(1)} units`);
                    
                    setTimeout(() => {
                        draw();
                        console.log("Snowflake generation completed!");
                    }, 500);
                    return;
                }
                
                // Normal growth
                for (let i = 0; i < 50; i++) {
                    updateReiter();
                }
                step += 50;
                updateDisplay();
                draw();
                
                // Maximum step protection
                if (step >= 800) {
                    clearInterval(growthInterval);
                    console.log("Reached maximum step limit");
                }
            }, 10);
        }
    </script>
</body>
</html>

3. Example Snowflakes

Here are some examples of ASCII snowflakes generated by the code:

                                    .  .                                   
                                  %%=::=%%                                 
                                 %  -::-  %                                
                                  ::-::-::                                 
                               %%:  -..-  :%%                              
                              %   ::-..-::   %                             
                               :::@@-..-@@:::                              
                            %%:   ::-..-::   :%%                           
                           @   :::%%:..:%%:::   @                          
                            --:   ..:..:..   :--                           
                           -   ...%%:  :%%...   -                          
#  %  %  %  %  %  @         :::   ..:  :..   :::         @  %  %  %  %   **
 ++=  :  :  :  :  -  -     -   ...##:  :##...   -     -  -  :  :  :  :  =  
 :::---  :  :  :  :  :  -   --:   ..:  :..   :--   -  :  :  :  :  :  ---:  
+==-::.---@@:  :  .  :  -      ...##.  .##...      -  :  .  :  :@@---.::-  
   :---...---%%.  .  .  :     :     .  .     :     :  .  .  .%%---...---:::
 %%   :---...:::%%.  .  .  :   ...##.  .##...   :  .  .  .%%:::...---:   ==
   %:: @@:--:.. :::##.  .  .        .  .        .  .  .##::: ..:--:@@ ::#  
      ::: %%.:::   :::##   .  @@@.##.  .##.@@@  .   ##:::   :::.%% :::     
    %%   ::: %%.:::   ...##   .     .  .     .   ##...   :::.%% :::   %%   
      %::   ... ##.::.   ...##    ++.  .++    ##...   .::.## ...   ::%     
         -::   ... ## ...   ...++:::    :::++...   ... ## ...   ::-        
       @@   :::   ... ## ...   ..   .  .   ..   ... ## ...   :::   @@      
          --   -::   ... ## ...   ..:  :..   ... ## ...   ::-   --         
             --    ::   @.. ++:  .        .  :++ ..@   ::    --            
                        @     :  .::    ::.  :     @                       
             ---   ::.   .. ++.     :  :     .++ ..   .::   ---            
          --:   ::.   .. ##...    ...  ...    ...## ..   .::   :--         
       @@-   ::.   .. ##...   ...:        :...   ...## ..   .::   -@@      
      %   ::.   ...##...   ... ++ ::.  .:: ++ ...   ...##...   .::   %     
       :::   ...##:::   ... ##.   ++.  .++   .## ...   :::##...   :::      
    %%:   ::.%%:::   :.. ##.  @  .  .  .  .  @  .## ..:   :::%%.::   :%%   
   %   :::%%:::   :::.##.  .   @@ ##.  .## @@   .  .##.:::   :::%%:::   #  
    :::@@---...:::.##.  .  :     .  .  .  .     :  .  .##.:::...---@@:::   
 %%:  ---...-::.%%.  .  :     :.. ##.  .## ..:     :  .  .%%.::-...---  :==
+  ---...---:%%:  .  :  -        .  .  .  .        -  :  .  :%%:---...---::
 ==:::---:@@:  :  :  :  -     :.. ##:  :## ..:     -  :  :  :  :@@:---:::  
 ::=--:  :  :  :  -  -     ---   ...:  :...   ---     -  -  :  :  :  :--=  
#++%  %  %  %  %  @           :.. ##:  :## ..:           @  %  %  %  %     
                           -::   ...:  :...   ::-                        **
                              :.. %%:  :%% ..:                             
                           @--   :..:..:..:   --@                          
                              ::: %%-..-%% :::                             
                            %%   :::-..-:::   %%                           
                              %:: @@-..-@@ ::%                             
                                 :::-..-:::                                
                               %%   -..-   %%                              
                                 %::-::-::%                                
                                    =::=                                   
                                  **    **

                                 %%%####%%%                                
                                 %%%####%%%                                
                                 %%%####%%%                                
                                 +++----+++                                
                                 +++----+++                                
                              %%%---    ---%%%                             
                              %%%---    ---%%%                             
                              ***          ***                             
                              ***          ***                             
                              ===          ===                             
                              ===          ===                             
####%%%+++%%%***              ===          ===              ***%%%+++%%%###
####%%%+++%%%***              ===          ===              ***%%%+++%%%###
####%%%+++%%%***              ===          ===              ***%%%+++%%%###
%%%%---   ---   ========      :::          :::      ========   ---   ---%%%
%%%%---   ---   ========      :::          :::      ========   ---   ---%%%
    +++---              :::------          ------:::              ---+++   
    +++---              :::------          ------:::              ---+++   
    %%%***                    ***          ***                    ***%%%   
    %%%***                    ***          ***                    ***%%%   
          ======                                            ======         
          ======                                            ======         
                :::::---                            ---:::::               
                :::::---                            ---:::::               
                     ---***                      ***---                    
                     ---***                      ***---                    
                     ---***                      ***---                    
             ===:::::                                  :::::===            
             ===:::::                                  :::::===            
       ***===                                                  ===***      
       ***===                                                  ===***      
    %%%---                 ---***          ***---                 ---%%%   
    %%%---                 ---***          ***---                 ---%%%   
%%%%+++              ===:::   ---          ---   :::===              +++%%%
%%%%+++              ===:::   ---          ---   :::===              +++%%%
####---+++---***=====         :::          :::         =====***---+++---###
####---+++---***=====         :::          :::         =====***---+++---###
    %%%   %%%                 ===          ===                 %%%   %%%   
    %%%   %%%                 ===          ===                 %%%   %%%   
    %%%   %%%                 ===          ===                 %%%   %%%   
                              ===          ===                             
                              ===          ===                             
                              ***---    ---***                             
                              ***---    ---***                             
                              %%%+++    +++%%%                             
                              %%%+++    +++%%%                             
                                 %%%----%%%                                
                                 %%%----%%%                                
                                    ####                                   
                                    ####

4. AI Usage Disclosure

AI assistance was used for debugging and optimizing the code structure.

5. Instructions to Run the Code

Copy the code into an HTML file (e.g., snowflake.html).
Open the file in a web browser.
Click the "Regenerate Snowflake" button to generate a new snowflake.
Observe the ASCII art snowflake in the output area.

6. Challenges and Learnings

Hexagonal Grid Implementation: Simulating vapor diffusion and ice growth on a hexagonal grid required careful handling of neighbor calculations.
Edge Detection: Ensuring the snowflake stops growing at the boundary was challenging but necessary for realistic results.
ASCII Art Generation: Mapping vapor intensity to ASCII characters was an interesting exercise in visual representation.

Jun 27 at 12:54

0

elechris

557
4
24

Impressive. What resources did you use to implement this algorithm?

Jun 27 at 13:28

1

TR4N51ST0R

1
2

Reference

A local cellular model for snow crystal growth by Clifford A. Reiter

Jun 27 at 14:39, edited Jun 27 at 14:40

0

Shubham B

1

A fun console-based Java program that creates unique, symmetrical snowflakes using random seed-based patterns. Each snowflake mimics nature’s diversity through randomized symbols and mirrored symmetry.

Key Features:

Seed-based uniqueness: Same seed = same snowflake.
Vertical symmetry using mirrored lines.
Randomized symbols for arms.

Dynamic sizing (7–13 lines).

import java.util.Random;
import java.util.Scanner;

public class ASCIISnowflakeGenerator {

    // Method to generate a symmetrical ASCII snowflake
    public static String generateSnowflake(String seed) {
        // Use the seed to create a deterministic Random generator
        Random random = new Random(seed.hashCode());

        // Adjust the size dynamically between 7 and 13 (inclusive)
        int size = 7 + random.nextInt(7); // [7, 13]
        StringBuilder snowflakeBuilder = new StringBuilder();

        // Generate the top half of the snowflake
        for (int i = 0; i < size; i++) {
            // Padding for center alignment
            String padding = " ".repeat(size - i);

            // Build one arm using random symbols
            StringBuilder arm = new StringBuilder();
            for (int j = 0; j < i; j++) {
                arm.append(getRandomSymbol(random));
            }

            // Create the full symmetrical line
            String line = padding + arm + "*" + arm.reverse().toString() + "\n";
            snowflakeBuilder.append(line);
        }

        // Mirror the top to generate the bottom half
        for (int i = size - 2; i >= 0; i--) {
            String line = snowflakeBuilder
                            .toString()
                            .split("\n")[i];
            snowflakeBuilder.append(line).append("\n");
        }

        return snowflakeBuilder.toString();
    }

    // Random symbol generator for snowflake arms
    private static char getRandomSymbol(Random random) {
        char[] symbols = {'*', '+', 'x', '|', '.', '-', '^', '~'};
        return symbols[random.nextInt(symbols.length)];
    }

    // Main method to run the program
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("Enter a snowflake seed: ");
        String seed = scanner.nextLine();

        System.out.println("\nHere's your unique ASCII snowflake:\n");
        System.out.println(generateSnowflake(seed));
    }
}

Jun 27 at 17:53

0

Stanley Hudson

1
1

import ascii_snow as ascii_snow_art_library

obj = ascii_snow_art_library.generate()

print(obj)

Jun 27 at 20:20

3

Michael Brown

1

I set up a python script that creates line segments in a hexagonal pattern with a random seeded size, and offset rotation. The ASCII symbol is determined by a distance to the line segment. It isn't the most efficient thing but its pretty neat. Technically it could render any lines in any orientation.

I also added the ability to have a spinning animation play on the snowflake.

import math
import random
import numpy as np
from numpy.linalg import norm
import time

def plot_point(angle, length, width, height, lines):
    x = width / 2
    y = height / 2
    endy = y + length * math.sin(math.radians(angle))
    endx = x + length * math.cos(math.radians(angle))
    line = [np.array((height/2, width/2)), np.array((endy, endx))]
    lines.append(line)


def main():
    seed = input("Seed: ")
    spin = input("Spin (y/n): ").lower() == 'y'
    # for seed in seeds.split(","):
    random.seed(seed)

    length = random.randrange(4, 10)
    width = 25
    height = 25
    arms = 6
    UP = f"\x1B[{height}A"
    CLR = "\x1B[0K"
    print("\n" * height)

    ###########################
    # Animation parameters
    seconds = 10
    framerate = 12
    animationIncrement = 45
    # End animation parameters
    ###########################

    totalFrames = seconds * framerate

    if not spin:
        totalFrames = 1
    for frame in range(totalFrames):
        start_time = time.time()
        offsetAngle = (frame * animationIncrement) % 360
        if not spin:
            offsetAngle = random.randrange(0, 360)
        lines = []
        for i in range(0, arms):
            angle = (i * (360/arms)) + offsetAngle
            plot_point(angle, length, width, height, lines)

        line = ""
        toPrint = f"{UP}"
        for x in range(height):
            for y in range(width):
                char = "  "
                min_d = float('inf')
                for lineSegment in lines:
                    p1, p2 = lineSegment
                    p3 = np.array((x, y))
                    u = p2 - p1
                    v = p3 - p1
                    l = (np.dot(u, v)/np.dot(u, u))
                    t = p1+(np.dot(u, v)/np.dot(u, u))*u
                    if l < 0 or l > 1:
                        continue
                    d = norm(t-p3)
                    if d < min_d:
                        min_d = d
                if min_d < .4:
                    char="@ "
                elif min_d < .8:
                    char="* "
                elif min_d < 1.5:
                    char=". "
                line += char
            toPrint += line + f"{CLR}" + "\n"
            line = ""
        print(f"{toPrint}", end="")
        elapsed = time.time() - start_time
        sleep_time = max(0, (1/framerate) - elapsed)
        time.sleep(sleep_time)

if __name__ == "__main__":
    main()

Seed: 50                                                  
                    @ .                           
                  . @ *                           
                  . * * .         . *             
                    * @ .       . * @ .           
                    . @ .     . * @ .             
                    . * *   . * @ .               
        * * . . .     * @ . * @ .                 
        * @ @ @ * * . . @ * @ .                   
        . . . * * @ @ @ @ @ * . . .               
                . . . * @ @ @ @ @ * * . . .       
                    . @ * @ . . * * @ @ @ *       
                  . @ * . @ *     . . . * *       
                . @ * .   * * .                   
              . @ * .     . @ .                   
            . @ * .       . @ *                   
              * .         . * * .                 
                            * @ .                 
                            . @                   
Seed: 100 
                                                 
                      . @ *                       
                      . @ *                       
                .     . @ *     . *               
                @ * . . @ * . * @ @ .             
              . * @ @ * * * * @ * .               
                  . * @ @ @ @ . .                 
                  . . @ @ @ @ * .                 
                . * @ * * * * @ @ * .             
              . @ @ * . * @ . . * @               
                * .     * @ .     .               
                        * @ .                     
                        * @ .                     

Seed: 5345                                                  
                                                  
                        . @ .                     
                    * . . @ . .                   
                  . @ @ * @ . * @                 
                    . * @ @ @ * .                 
                  . * @ @ @ * .                   
                  @ * . @ * @ @ .                 
                    . . @ . . *                   
                      . @ .

I really tried to stay away from AI on this one. I used it to debug a couple lines, but for the most part this was all my code.

It can run on any machine with python and numpy, but to get proper line resetting, a terminal that supports ANSI codes is needed. Mac and linux should work, along with the new windows terminal (probably). Here is a working playground: https://www.onlineide.pro/playground/share/a0720891-eb2d-45cd-98aa-13900628eda5 (Thanks @elechris for pointing this out).

I had another version running with Curses but thats even less portable.

This is the first time I've reset multiple lines on the terminal to play an animation. That was quite cool.

Jun 28 at 0:48, edited Jun 30 at 21:00

1

elechris

557
4
24

I like the spinning. Resetting the lines is not exactly portable so it doesn't always work correctly. I tested your code on https://www.online-python.com/. It does work, but there are some character artifacts on the end of each like. Tip: You can create a sharable link on there and add it to your post.

Jun 28 at 11:26

1

Michael Brown

1

I've updated the description to clarify how it can be ran. I've found a site that runs it in a terminal so it runs correctly. This method unfortunately needs a environment that supports ANSI codes to manipulate the output.

Jun 30 at 20:59

0

mostafa said

1

# ASCII Art Snowflake Generator — Challenge Submission

## Explanation of Snowflake Creation Approach

Snowflakes are famous for their **six-fold symmetry** and unique, intricate patterns. To mimic this in ASCII art, I chose to:

- Use a **square grid** where the center represents the hexagonal core of the snowflake.
- Generate a **single arm pattern** randomly, using a seed to ensure reproducibility and uniqueness.
- Create **symmetry by reflecting and swapping coordinates** to produce six arms of the snowflake.
- Use simple ASCII characters (e.g., `*`, `+`, `x`, `o`, `#`, `@`) to draw the snowflake.
- Introduce variability by randomly placing characters along the arm, controlled by the seed.
  
This approach balances uniqueness and symmetry, producing visually interesting snowflakes without overly complex geometry.

---

## Code to Create the Snowflake

```csharp
using System;

class SnowflakeGenerator
{
    static void Main(string[] args)
    {
        CreateSnowflake("seed1", 15);
        Console.WriteLine("\n---\n");
        CreateSnowflake("winter2025", 15);
    }

    static void CreateSnowflake(string seed, int size = 15)
    {
        var random = new Random(seed.GetHashCode());
        char[] armChars = { '*', '+', 'x', 'o', '#', '@' };
        char chosenChar = armChars[random.Next(armChars.Length)];

        char[,] grid = new char[size, size];

        // Fill grid with spaces
        for (int y = 0; y < size; y++)
            for (int x = 0; x < size; x++)
                grid[y, x] = ' ';

        int mid = size / 2;
        grid[mid, mid] = chosenChar; // Center

        int armLength = mid;
        bool[] armPattern = new bool[armLength];
        for (int i = 0; i < armLength; i++)
            armPattern[i] = random.NextDouble() > 0.3;

        // Set symmetric points helper
        void SetSymmetricPoints(int x, int y, char ch)
        {
            // 8-way symmetric points on grid (reflections)
            int[,] points = {
                { mid + x, mid + y },
                { mid - x, mid + y },
                { mid + x, mid - y },
                { mid - x, mid - y },
                { mid + y, mid + x },
                { mid - y, mid + x },
                { mid + y, mid - x },
                { mid - y, mid - x }
            };

            for (int i = 0; i < points.GetLength(0); i++)
            {
                int px = points[i, 0];
                int py = points[i, 1];
                if (px >= 0 && px < size && py >= 0 && py < size)
                    grid[py, px] = ch;
            }
        }

        for (int i = 0; i < armLength; i++)
        {
            if (armPattern[i])
            {
                SetSymmetricPoints(i + 1, 0, chosenChar);
                SetSymmetricPoints(i + 1, i + 1, chosenChar);
            }
        }

        // Print the snowflake
        for (int y = 0; y < size; y++)
        {
            for (int x = 0; x < size; x++)
                Console.Write(grid[y, x]);
            Console.WriteLine();
        }
    }
}
Example Output Snowflakes
Seed = "seed1":


       *       
      * *      
     *   *     
    *     *    
   *       *   
  *         *  
 *           * 
*             *
 *           * 
  *         *  
   *       *   
    *     *    
     *   *     
      * *      
       *       
Seed = "winter2025":

       +       
      + +      
     +   +     
    + + + +    
   +       +   
  +         +  
 +           + 
+             +
 +           + 
  +         +  
   +       +   
    + + + +    
     +   +     
      + +      
       +       
(Note: actual output may vary due to random variations seeded by input string.)

AI Usage Disclosure
This code was written entirely by myself. I used AI assistance only to help format the explanation and for minor debugging advice, but the snowflake generation logic and implementation are my original work.

Instructions to Run the Code
Copy the provided C# code into a file named SnowflakeGenerator.cs.

Compile the code with the .NET SDK or a C# compiler:

csc SnowflakeGenerator.cs
Run the executable:

SnowflakeGenerator.exe
The console will print ASCII snowflakes based on the hardcoded seeds ("seed1" and "winter2025"). To generate your own, modify the seeds in the Main method.

Learnings and Challenges
Implementing 6-way symmetry in a simple 2D ASCII grid was challenging; direct rotation is complex, so I approximated with reflections.

Choosing how to represent snowflake arms while maintaining uniqueness and aesthetic balance required tuning randomness and pattern placement.

ASCII art imposes constraints such as character size and spacing that limit detail, making it important to keep the design simple yet recognizable.

Using a string seed to drive the random generator allowed reproducible but varied snowflakes, capturing the idea of natural variation in real snowflakes.

Jun 28 at 3:55

0

elechris

557
4
24

You accidentally put your entire post in a code block. This makes it less readable.

Jun 28 at 11:38

5

user3297291

23.5k
4
33
49

Results

Create your own snowflakes here. Play around with the seed to see different results.

Examples

Seed	10	19	39	45	7
Image	10	19	39	45	7

For text output example, see bottom of post.

Approach

In short:

Construct a snowflake out of a fixed number of particles,
Draw those particles to a canvas,
Sample each 8x8 cell of that canvas for a brightness value,
For each cell, map its brighness value to an ASCII character

Inspiration:

The snowflake construction is inspired by this youtube video, which in turn is inspired by this post.
Transforming pixels to ASCII is inspired by this youtube video.

Particles (`createSnowflake`)

One by one, particles move along a somewhat random curved line towards the center of the canvas. A particle comes to a halt once it hits another particle or its x-coordinate goes below 0.

Random values and constants are combined to try and ensure the particles somewhat fill up a 1/12th slice of a circle.

Snowflake image (`renderSnowflake`)

The +- 100 generated particles are drawn to a canvas. Each particle is drawn 12 times:

First in its original location,
Then reflected across the y-axis,
Rotate around (0, 0) by 1/6th turn and repeat the two steps above 5 more times

Each particle is drawn black at a low opacity.

Snowflake ASCII art (`imageDataToAscii`)

The snowflake image is cut up in to 8x8 squares. For each square, the alpha value (0-255) of its pixels is averaged.

The average alpha is used to look up a corresponding character. The lookup table is made by experimenting until most flakes looked about right (see charForBrightness). A more precise approach where characters were also drawn to a canvas to find their average alpha value didn't yield better results.

Each cell's corresponding character is then joined in to a multi line string.

How to run it (and improve)

Go to the playground linked at the top of this post.
Play around with the seeds first to see the range of possibilities given the current constraints,
Then try and play around with the constants on top of the JS to see if you can improve more.
Try to use different characters and balances by modifying charForBrightness!
There are several to-do's in code. Biggest oversight is that the particles aren't neatly constrained to stay within the initial 1/12th circle slice.

AI Disclosure

I initially wanted to implement a WebGL Canvas shader similar to the one shown in the linked video. I was heavily relying on ChatGPT there to make progress, but ran in to a wall.

I figured I'd write my own naive CPU implementation first hoping that that might make clear to the AI what it is I was looking to do. I then had so much fun implementing it myself and was quite happy with the results, so decided to ship it instead...

Learnings

Create debug visualizations early in the process
Use live/animated features to get a feel for magic numbers / constants
I somehow get more fun out of a naive POC in tech that I understand than from a more fancy prototype that is mostly vibe coded...
Most fonts / default letter spacing does not make for square cells...

Text based example

_{.*.
*
?
..;*;..
... ...
.. ...
.. ..
. ;.
. .
. *..
. .. .. .o ;.o. .o ... .
** ** .* .... .... *. *c ;*
.c;** .. .... ...c ...***;.
. ... o.O*.. o*?.... .. .
..... o . o.;?** ;c*;.* c . ;. ..
.;..o .; o...*P**.*.*.O*...* .* ;..;.
...... .. .*OP.c**;?O*o ..c... ..
. . *c *****?* o* .
... oo*O*P*O?*o ...
... ..**?*O?PPP*?** . ...
.c.*..P*?*O*O?P*P;.*.o.
c**?*c***?OcO?*?cc****..
**?**OPOPOOOO@OOO?O?OO**P* c
. c***?.*??PP*P**?cc?***..
.*.*..Po?*O O*P*Pc;*.*.
..;...*?**OPO?O*??* ; .o.
.. .*.*O???O***. ..
c . * .*******..* ..;.
... .. ;*?O*****OO** .. ..
.*....o; c...*O**.*.*cO*...; .*....*.
...c.* . c ...?** o**o.* . . *....
. .. . c.P*c ;o*.;.. .c .
...**... .. . . .. ...c*;..
*o .oo .* .c. .c..*. c.. .*
. .; *. ....c.. .* .. .
* ; o
.c.
. .
.. ;.
. . ..
... ...
.;***..
*
?
.*.

seed: 42}

Jun 28 at 11:23

0

elechris

557
4
24

I love your brightness mapping. It looks amazing on the link your shared. Too bad it doesn't look as good when character height/width is not 1:1 such as in the snipped on stackoverflow. In my script this was solved by scaling the y-axis using a parameter. I would say your character mapping is the best I've seen. I'm giving you an upvote for this.

Jun 28 at 11:34

1

DeepThought42

238
1
11

I tried. (and sort of failed)

The idea was that size lines (made from -/|\) would be drawn and then more lines would propagate off the initial lines (and then perhaps continue doing that recursively). I decided to use integers to represent which way a line is going at any specific character in the grid, which appears to work quite well but perhaps it was my downfall. I didn’t get time to finish this so this is the best I got.

from random import Random
from sys import argv
def renderchar(i: int) -> str:
    chars = '|/-\\'
    return chars[i%len(chars)]
def renderchargrid(grid: list[list[str]]):
    print('\033[107;30m')
    for y, row in enumerate(grid):
        for x, char in enumerate(row):
            if isinstance(char, int):
                print(renderchar(char), end='')
            else: print(char, end='')
        print()
    print('\033[0m')
def propogate_spikes(x,y, chargrid, p, l):
    xside = x > len(chargrid[0])//2
    yside = y < len(chargrid)//2
    initial_direction = chargrid[y][x]
    if not isinstance(initial_direction, int): return
    #chargrid[y][x] = 'X'

    for i in range(l):
        if not yside: chargrid[y-l][x] = initial_direction-1
        if yside: chargrid[y+l][x] = initial_direction-1
        if not xside: chargrid[y][x-l] = initial_direction+1
        if xside: chargrid[y][x+l] = initial_direction+1

size = 23 # works best with odd numbers for whatever reason...
seed = 42

if len(argv) > 1: seed = int(argv[-1])

rng = Random(seed)

chargrid = [[' ' for _ in range(size)] for _ in range(size)]
#chargrid[size//2][size//2] = '*'

# uncomment for 8-sided snowflake
#for x in range(size):
#    chargrid[size//2][x] = 2

# vertical spike
for y in range(size):
    chargrid[y][size//2] = 0

n = 1
# diagonal spike(s)
for i in range(size):
    chargrid[i][i] = -1
    #i += 1
    chargrid[i][size-i-1] = 1
    n = rng.randint(n, size-2)
    n1= rng.randint(1, 6)
    try:
        propogate_spikes(i, i, chargrid, n, n1)
        propogate_spikes(i, size-i-1, chargrid, n, n1)
    except IndexError: pass

chargrid[size//2][size//2] = '*'

# display snowflake
renderchargrid(chargrid)

Resulting “snowflakes”

-\         |      |  /-
| \        |        /| 
 | \       |       /-  
  - \      |      /| | 
|  - \     |     /| -  
     |\    |    / -    
 -    |\   |-  /  -    
      |-\  |  - ||  \  
    |    \ | /-        
    |-  - \|/| | -     
         - *           
          /|\- - |     
         / | \|        
        /- |  / --  |  
       /   ||  \  |    
      /   -|    \ |    
     /     |     \- - -
    /      |      \-   
   /       |       \|  
  /        |        \- 
 /         |         \|

I did not use any AI or even autocomplete.

Jun 29 at 4:21, edited Jun 29 at 4:27

4

The_spider

1.3k
1
9
21

Snowflake creation approach

The snowflake consists of 6 main arms made out of double slashes or hyphens. The space between those main arms is symmetrically filled up with secondary arms, made out of single slashes and hyphens. These arms are generated using the seed as follows:

First, the places for the arms are decided, based on the seed. If there are too much/not enough arms on a place, arms are added/removed. Then the length of each arm is chosen based on the seed, within a minimum and maximum range dependent on the location of the arm.

Then, the arms are tweaked to make the snowflake more beautifull. Some arms are cut trough, to generate parts of the snowflake that stand more alone. Next, some arms are extended to intersect with ugly long segments of other arms. Finally, the ends of each arm are trimmed to make them not too long and symmetric

Next, some secondary arms are given decorations based on the seed.

Finally, one quarter of the snowflake is drawn and then rotated to generate a complete snowflake.

The code

The code is completely written in python and does not required any non-standard libraries. It also includes some general-use ASCII art manipulation functions. No AI has been used in writing this code. If you want to gain more insight in how it works, you can always try to uncomment some of the debugging print statements.

REVERSE_TABLE = str.maketrans(r"(){}\/<>´`[]", r")(}{/\><`´][")
UPSIDE_DOWN_TABLE = str.maketrans(r"/\v^',", r"\/^v,'")

HORIZONTAL_DECORATIONS = ["O", "*"]
VERTICAL_DECORATIONS = ["O", "*"]

MAX_NO_ARM = 3
ARM_CHANCE = (2, 3)  # should be interpreted as fraction
DECORATION_CHANCE = (1, 2)
MAX_END_STICK_OUT = 2
MAX_SEGMENT_LEN = 4
MIN_SEGMENT_REMOVE = 2

def pad(art: str, linelength: Optional[int] = None, numlines: Optional[int] = None):  # pads/trims the art such that al lines are of equal length (max length if not given)
    # and of a given number of lines (if given)
    lines = art.splitlines()

    if linelength is None:
        linelength = max([len(line) for line in lines])

    padded_lines = [line.ljust(linelength)[:linelength + 1] for line in lines]

    if numlines is not None and len(padded_lines) != numlines:
        if numlines < len(padded_lines):
            padded_lines = padded_lines[:numlines + 1]
        else:
            padded_lines.extend([" " * linelength] * (-len(padded_lines) + numlines))

    return "\n".join(padded_lines)


def reverseart(art: str):
    lines = pad(art).splitlines()
    reversed_lines = ["".join(reversed(line)).translate(REVERSE_TABLE) for line in lines]
    return "\n".join(reversed_lines)


def upsidedownart(art: str):
    lines = art.splitlines()
    reversed_lines = list(reversed(lines))
    upside_down_lines = [line.translate(UPSIDE_DOWN_TABLE) for line in reversed_lines]
    return "\n".join(upside_down_lines)


def removeleft(art, chars):  # removes chars number of characters from the left of the art
    lines = art.splitlines()
    trimmed_lines = [line[chars + 1:] for line in lines]
    return "\n".join(trimmed_lines)


def removeright(art, chars):  # removes chars number of characters from the right of the art
    if chars == 0:
        return art
    lines = pad(art).splitlines()
    trimmed_lines = [line[:-chars] for line in lines]
    return "\n".join(trimmed_lines)


def removetop(art, chars):  # removes chars number of characters from the top of the art
    lines = art.splitlines()
    trimmed_lines = lines[chars + 1:]
    return "\n".join(trimmed_lines)


def removebottom(art, chars):  # removes chars number of characters from the bottom of the art
    if chars == 0:
        return art
    lines = art.splitlines()
    trimmed_lines = lines[:-chars]
    return "\n".join(trimmed_lines)


def trim(art):  # removes empty lines/ cols before/after the art
    if set(art) == {"\n", " "}:
        return ""

    lines = pad(art).splitlines()
    is_empty = [set(line) != {" "} for line in lines]
    startidxy = is_empty.index(True) - 1
    if not is_empty[-1]:
        endidxy = list(reversed(is_empty)).index(True) - 1
    else:
        endidxy = 0

    startidxx = min([len(line) - len(line.lstrip()) for line in lines]) - 1
    endidxx = min([len(line) - len(line.rstrip()) for line in lines])

    return removebottom(removetop(removeleft(removeright(art, endidxx), startidxx), startidxy), endidxy)


def vstack(*arts: str):
    lines = [line for art in arts for line in art.splitlines()]
    return "\n".join(lines)


def hstack(*arts: str):
    maxlen = max([art.count("\n") + 1 for art in arts])
    artlines = [pad(art, numlines=maxlen).splitlines() for art in arts]
    lines = ["".join([lines[i] for lines in artlines]) for i in range(len(artlines[0]))]
    return "\n".join(lines)


def reduplicate(art: str, keepleft: bool = True, keepunder: bool = True):  # turns it into a complete snowflake
    normal = art
    upside_down = upsidedownart(art)
    reverse = reverseart(art)
    upside_down_reverse = reverseart(upside_down)

    if not keepleft:  # take out the last line of the reversed art, so it is not duplicated
        reverse = removeright(reverse, 1)
        upside_down_reverse = removeright(upside_down_reverse, 1)

    if not keepunder:  # take out the undermost line of the art so it isn't duplicated
        reverse = removebottom(reverse, 1)
        normal = removebottom(normal, 1)

    up_part = hstack(reverse, normal)
    down_part = hstack(upside_down_reverse, upside_down)
    return vstack(up_part, down_part)


def getsnowflake(lengths: List[Union[List[bool], int]], decorations: List[int], hdist=5, vdist=2):
    width = len(lengths) * hdist + 1  # represents the width and height of the main branches, *2 for other branches sticking out
    height = len(lengths) * vdist

    snowflake = [[" " for i in range(3 * width)] for j in range(3 * height)] + [["-"] * width + [" "] * 2 * width]

    for i, length in enumerate(lengths):  #prevent crashes in findintersections
        if isinstance(length, int):
            lengths[i] = [True] * length + [False] * (len(lengths) - length + 1)
        elif len(length) < len(lengths) + 1:
            lengths[i] += [False] * (len(lengths) - len(length) + 1)

    for n, branchestogenerate in enumerate(lengths):
        startoffsetx = 1 + (n + 1) * hdist
        startoffsety = (n + 1) * vdist
        #print("n", n, startoffsetx, startoffsety)

        prevdrawed = False

        for i, dodraw in enumerate(branchestogenerate):
            if dodraw:
                offsetx = vdist * i
                offsety = hdist * i
                #print("i", i, offsetx, offsety)

                for k in range(-1, hdist - 1):  # place vertical lines (one less to prevent ends sticking out)
                    idxx = 2 + startoffsety + offsety + k
                    idxy = startoffsety
                    #print("k", k, idxx, idxy)
                    if snowflake[3 * height - idxy][idxx] == " ":  # prevent overriding diagonals
                        snowflake[3 * height - idxy][idxx] = "-"
                    printsnowflakearray(snowflake)

                for j in range(vdist):  # place diagonal lines below main diagonal
                    idxx = startoffsetx + offsetx + j
                    idxy = offsetx + j
                    #print("j", j, idxx, idxy)
                    snowflake[3 * height - idxy][idxx] = "/"
                    printsnowflakearray(snowflake)

                for l in range(vdist):
                    idxx = startoffsety - 1 - offsetx - l
                    idxy = startoffsety + offsetx + l

                    #print("l", l, idxx, idxy)

                    if idxx >= 0:
                        snowflake[3 * height - idxy][idxx] = "\\"
                    else:
                        snowflake[3 * height - idxy][-1 - idxx] = "/"

                    printsnowflakearray(snowflake)
                    prevdrawed = True
            else:
                #print(prevdrawed, i, list(findintersections(n+1, lengths)))
                if prevdrawed and i in list(findintersections(n + 1, lengths)):
                    idxx = startoffsetx + offsetx + j + 1  # make diagonal lines close off angles
                    idxy = offsetx + j + 1

                    snowflake[3 * height - idxy][idxx] = "/"

                prevdrawed = False

        if decorations[n]:
            idxx = 2 + startoffsety + offsety + k + 1  # horizontal lines
            idxy = startoffsety
            if isinstance(HORIZONTAL_DECORATIONS[decorations[n] - 1], list):
                snowflake[3 * height - idxy][idxx] = HORIZONTAL_DECORATIONS[decorations[n] - 1][0]
                snowflake[3 * height - idxy + 1][idxx] = HORIZONTAL_DECORATIONS[decorations[n] - 1][1]
            else:
                snowflake[3 * height - idxy][idxx] = HORIZONTAL_DECORATIONS[decorations[n] - 1]

            idxx = startoffsetx + offsetx + j + 1  # diagonal lines below main diagonal
            idxy = offsetx + j + 1
            snowflake[3 * height - idxy][idxx] = VERTICAL_DECORATIONS[decorations[n] - 1]

            idxx = startoffsety - 1 - offsetx - l - 1  # diagonal lines above main diagonal
            idxy = startoffsety + offsetx + l + 1
            if idxx >= 0:
                snowflake[3 * height - idxy][idxx] = VERTICAL_DECORATIONS[decorations[n] - 1]
            else:
                snowflake[3 * height - idxy][-1 - idxx] = VERTICAL_DECORATIONS[decorations[n] - 1]

    for i in range(0, height):  # recreate main diagonal
        snowflake[3 * height - i][i] = "/"
        snowflake[3 * height - i][i + 1] = "/"

    snowflake[2 * height][height - 1:height + 3] = r"\==/"  # add decorations ath the end of the main arms
    snowflake[2 * height - 1][height - 1:height + 4] = "/==\\"

    snowflake[3 * height][width:width + 4] = "/==\\"

    quarter_snowflake = "\n".join(["".join(line) for line in snowflake])
    return trim(reduplicate(quarter_snowflake))


def snowflakemodularize(num):  # returns the maximum length of the snowflake and the remaining unused part of the number
    prevminnum = 0
    for length in itertools.count(1):
        minnum = ARM_CHANCE[1]**length * DECORATION_CHANCE[1]**length
        for i in range(length):
            minnum *= math.floor(math.sqrt(length**2 - i**2)) - math.floor(length / (i + 1) / 2)

        if minnum > num:
            return length - 1, num % prevminnum
        else:
            prevminnum = minnum


def numtosnowflakearray(num, length):
    generatearms = []

    for i in range(length):
        num, remainder = divmod(num, ARM_CHANCE[1])
        if remainder + 1 <= ARM_CHANCE[0]:  # ARM_CHANCE[0] / ARM_CHANCE[1] chance of an arm on each place
            generatearms.append(True)
        else:
            generatearms.append(False)

    #print("before", generatearms)

    for i in range(MAX_NO_ARM // 2, len(generatearms) - (math.ceil(MAX_NO_ARM / 2) - 1)):  # place/remove arms when there are too much/not enough
        #print(generatearms[i-MAX_NO_ARM // 2:math.ceil(MAX_NO_ARM / 2) + i])
        if all(generatearms[i - MAX_NO_ARM // 2:math.ceil(MAX_NO_ARM / 2) + i]):
            #print("changed to false")
            generatearms[i] = False
        if not any(generatearms[i - MAX_NO_ARM // 2:math.ceil(MAX_NO_ARM / 2) + i]):
            #print("changed to true")
            generatearms[i] = True

    #print("after", generatearms)

    arms = []
    for i, generatearm in enumerate(generatearms):
        if generatearm:
            maxarmlen = min(math.floor(math.sqrt(length**2 - i**2)), length - 1)  # create something circular-ish
            minarmlen = math.ceil(length / (i + 1) / 2)  # prevent too short arms
            num, armdiff = divmod(num, maxarmlen - minarmlen)
            armlen = minarmlen + armdiff
            #print(num, maxarmlen, minarmlen, armlen)
            arms.append([True] * armlen + [False] * (length - armlen + 1))
        else:
            arms.append([False] * (length + 1))

    #print(getsnowflake(arms, [0]*length))
    #print([len(arm) for arm in arms])

    tips = []

    for (armnum, arm) in reversed(list(enumerate(arms, 1))):  # find all tips to see wether we can isolate them by cutting through some connections (more beautiful)
        lastintersection = max(findintersections(armnum, arms))
        #print("arm", armnum, lastintersection)
        if lastintersection != 0:
            lastintersectionintersection = max(findintersections(lastintersection, arms))
            #print(lastintersectionintersection)
            if armnum == lastintersectionintersection:
                tips.append((lastintersection, armnum))

    #print("tips", tips)
    firsttipnums = [tip[0] for tip in tips]
    lasttipnums = [tip[1] for tip in tips]

    for i, tip in enumerate(tips):  # see how much we can cut through
        if tip[0] <= tip[1]:  # prevent cutting tips twice
            for intersection in reversed(list(findintersections(tip[1], arms))[:-1]):  # locate how much space there is before and after the tip
                if intersection in firsttipnums:
                    prevtipnum = intersection
                    break
            else:
                prevtipnum = 0

            for intersection in reversed(list(findintersections(tip[0], arms))[:-1]):  # locate how much space there is before and after the tip
                if intersection in lasttipnums:
                    nexttipnum = intersection
                    break
            else:
                nexttipnum = 0

            #print(tip, prevtipnum, nexttipnum)

            intersectbefore = [tip[0]]
            intersectafter = [tip[1]]

            for armnum in range(tip[0] - 1, prevtipnum, -1):  # find where the tip's arms are intersect and thus which segments can be removed
                lastintersection = max(findintersections(armnum, arms))
                if lastintersection == tip[1]:
                    intersectbefore.append(armnum)

            for armnum in range(tip[1] - 1, nexttipnum, -1):
                lastintersection = max(findintersections(armnum, arms))
                #print(armnum, lastintersection)
                if lastintersection == tip[0]:
                    intersectafter.append(armnum)

            intersectbefore.append(prevtipnum)
            intersectafter.append(nexttipnum)
            #print("before", intersectbefore)
            #print("after", intersectafter)

            for (previntersect1, nextintersect1), (previntersect2, nextintersect2) in zip(zip(intersectbefore[1:-1], intersectbefore[2:]), zip(intersectafter[1:-1], intersectafter[2:])):
                # cut trough segments if they meet minimum distance requirements (first one can't be cut)
                # print("intersect", (previntersect1, nextintersect1), (previntersect2, nextintersect2))
                intersectdist1 = previntersect1 - nextintersect1
                intersectdist2 = previntersect2 - nextintersect2
                #print(intersectdist1, intersectdist2)

                if intersectdist1 >= MIN_SEGMENT_REMOVE and intersectdist2 >= MIN_SEGMENT_REMOVE:
                    # just cut of the last end and leave the rest up to the other part of the algorithm
                    #print("cut")
                    arms[tip[1] - 1][previntersect1 - 1] = False
                    arms[tip[0] - 1][previntersect2 - 1] = False

    #print(getsnowflake(arms, [0] * length))
    #print("checking for too long ends")
    for armnum, arm in enumerate(arms, 1):
        #print("arm", armnum)
        intersections = list(findintersections(armnum, arms))
        for intersection1, intersection2 in zip(intersections[:-1], intersections[1:]):
            if intersection2 - intersection1 > MAX_SEGMENT_LEN:  # try adding intersections for too long segments
                #print("too long segment at", intersection1, intersection2)
                # first, see wether we can lengthen some other arms
                cooldown = 0  # for not adding needlessly much arms
                for otharmnum in range(intersection1 + 1, intersection2):
                    #print("checking for", otharmnum)
                    if cooldown == 0:
                        lastintersection = max(filter(armnum.__ge__, findintersections(otharmnum, arms)))
                        possibleintersections = [0, 0] + [othotharmnum for othotharmnum, othotharm in enumerate(arms[:armnum], 1) if othotharm[armnum] or othotharm[armnum - 1]]
                        lastpossibleintersection = max(possibleintersections)
                        possibleintersections.remove(lastpossibleintersection)
                        secondlastpossibleintersection = max(possibleintersections)
                        #print(lastintersection, lastpossibleintersection, secondlastpossibleintersection)

                        if lastintersection in [lastpossibleintersection, secondlastpossibleintersection]:  # arm can be lengthened
                            #print("lengthend arm", otharmnum)
                            arms[otharmnum - 1][lastintersection:armnum + 1] = [True] * (armnum + 1 - lastintersection)
                            cooldown = MAX_SEGMENT_LEN
                    else:
                        #print("in cooldown")
                        cooldown -= 1

    for armnum, arm in enumerate(arms, 1):
        #print("arm", armnum, arm)
        intersections = list(findintersections(armnum, arms))

        for segmentnum in findends(arm):
            lastintersection = max([intersection for intersection in intersections if intersection <= segmentnum])
            endstickingout = segmentnum - lastintersection

            # print("found last intersection", lastintersection)
            # print("last end", endstickingout)

            if endstickingout > MAX_END_STICK_OUT:  # remove ugly ends that are too long
                arm[lastintersection + MAX_END_STICK_OUT:segmentnum] = [False] * (segmentnum - (lastintersection + MAX_END_STICK_OUT))
                # print("cutting off end")

            if lastintersection != 0:  # make sure two end sticking out after they last intersected, are of the same length
                lastintersecter = arms[lastintersection - 1]
                #print("considering ends equalizing")
                for intersectersegmentnum in findends(lastintersecter):
                    #print("found intersecter end", intersectersegmentnum)
                    lastintersecterintersection = max(filter(intersectersegmentnum.__ge__, findintersections(lastintersection, arms)))
                    #print("last intersection of intersecter", lastintersecterintersection)
                    if lastintersecterintersection == armnum:
                        #print("found correct intersecter", lastintersection)
                        lastintersecterend = intersectersegmentnum - lastintersecterintersection
                        if lastintersecterend != endstickingout:  # set both to length of one, because it looks the best
                            #print("changed ends")
                            arm[lastintersection + 1:segmentnum] = [False] * (segmentnum - (lastintersection + 1))
                            arm[lastintersection] = True
                            lastintersecter[lastintersecterintersection + 1:intersectersegmentnum] = [False] * (intersectersegmentnum - (lastintersecterintersection + 1))
                            lastintersecter[lastintersecterintersection] = True

    #print(arms)
    arms.append([False] * (length + 1))  # no arms on the end
    #print("starting decoration")

    decorations = [0] * (length + 1)
    for armnum, arm in enumerate(arms[:-1], 1):
        lastintersection = max(findintersections(armnum, arms))
        lastend = max(findends(arm))
        if lastend != lastintersection:
            num, decorate = divmod(num, DECORATION_CHANCE[1])
            if decorate >= DECORATION_CHANCE[0]:
                num, decoration = divmod(num, len(HORIZONTAL_DECORATIONS))
                decorations[armnum - 1] = decoration + 1

    return arms, decorations


# some helper functions

def printsnowflakearray(snowflake):  # for debugging
    quarter_snowflake = "\n".join(["".join(line) for line in snowflake])
    #print(quarter_snowflake)


def findends(arm: List[bool]):
    if not arm[0]:
        yield 0
    for segmentnum, (before, after) in enumerate(zip(arm[:-1], arm[1:]), 1):
        if before and not after:
            yield segmentnum


def findintersections(armnum: int, arms: List[List[bool]]):  # find all arms intersecting arm
    yield 0  # intersection with main arm is garanteed, but not in the list
    arm = arms[armnum - 1]
    for otharmnum, otharm in enumerate(arms, 1):
        if (otharm[armnum] or otharm[armnum - 1]) and (arm[otharmnum] or arm[otharmnum - 1]):
            yield otharmnum


if __name__ == "__main__":
    while True:
        num = input("Please enter a number for the snowflake: ")
        while not num.isdigit():
            num = input("Please enter a valid number: ")

        num = 17 * int(num )  # multiply by some prime to make following snowflakes not too similar
        length, remainder = snowflakemodularize(num)  # remainder has no use probably
        # print("size", length, remainder)
        snowflakearray, decorations = numtosnowflakearray(num, length)
        # print(snowflakearray)
        snowflake = getsnowflake(snowflakearray, decorations)
        print(snowflake)

How to run

The code should run in any python environment and does not need any non-standard libraries. When run, it should prompt for a seed and print the snowflake once you give one. Too low seeds don't seem to work, if you get a ZeroDivisionError, try a bigger seed.

Some snowflakes

The bigger snowflakes can be better viewed by copy-pasting them into a site like ASCIIflow.

seed = 123456789
                       /==\                          /==\
                       \==/                          \==/
                         \\                          //
                          \\        *      *        //
                           \\      /   /\   \      //
                            \\    /   /  \   \    //
                             \\  /   /    \   \  //
                    *---------\\/   /      \   \//---------*
                               \\  /\      /\  //
                 \---------\----\\/  \    /  \//----/---------/
                  \         \    \\   \  /   //    /         /
              *    \         \    \\   \/   //    /         /    *
               \    \         \    \\  /\  //    /         /    /
                \    \---------\----\\/  \//----/---------/    /
                 \    \         \    \\  //    /         /    /
/==\--------------\----\---------\----\\//----/---------/----/--------------/==\
\==/--------------/----/---------/----//\\----\---------\----\--------------\==/
                 /    /         /    //  \\    \         \    \
                /    /---------/----//\  /\\----\---------\    \
               /    /         /    //  \/  \\    \         \    \
              *    /         /    //   /\   \\    \         \    *
                  /         /    //   /  \   \\    \         \
                 /---------/----//\  /    \  /\\----\---------\
                               //  \/      \/  \\
                    *---------//\   \      /   /\\---------*
                             //  \   \    /   /  \\
                            //    \   \  /   /    \\
                           //      \   \/   /      \\
                          //        *      *        \\
                         //                          \\
                       /==\                          /==\
                       \==/                          \==/

seed = 123456789123456789
                                   /==\    /                                \    /==\
                                   \==/   /              *    *              \   \==/
                                     \\  /                \  /                \  //
                             ---------\\/          O       \/       O          \//---------
                                       \\           \      /\      /           //
                                        \\   O       \    /  \    /       O   //
                                         \\   \  /    \  /    \  /    \  /   //
                                     O    \\   \/      \/      \/      \/   //    O
                                      \    \\  /\       \      /       /\  //    /
                             O     ----\----\\/  \       \    /       /  \//----/----     O
                              \         \    \\   \  /    \  /    \  /   //    /         /
                     *         \         \    \\   \/      \/      \/   //    /         /         *
                      \         \         \    \\  /\      /\      /\  //    /         /         /
                  *----\---------\     ----\----\\/  \    /  \    /  \//----/----     /---------/----*
                        \         \         \    \\   \  /    \  /   //    /         /         /
                         \         \         \    \\   \/      \/   //    /         /         /
                          \         \         \    \\  /\      /\  //    /         /         /
                 O---------\---------\---------\----\\/  \    /  \//----/---------/---------/---------O
                                      \         \    \\   \  /   //    /         /
                                       \         \    \\   \/   //    /         /
     \              \         \         \         \    \\  /\  //    /         /         /         /              /
      \         O----\---------\---------\---------\----\\/  \//----/---------/---------/---------/----O         /
       \              \         \         \         \    \\  //    /         /         /         /              /
/==\----\--------------\---------\---------\---------\----\\//----/---------/---------/---------/--------------/----/==\
\==/----/--------------/---------/---------/---------/----//\\----\---------\---------\---------\--------------\----\==/
       /              /         /         /         /    //  \\    \         \         \         \              \
      /         O----/---------/---------/---------/----//\  /\\----\---------\---------\---------\----O         \
     /              /         /         /         /    //  \/  \\    \         \         \         \              \
                                       /         /    //   /\   \\    \         \
                                      /         /    //   /  \   \\    \         \
                 O---------/---------/---------/----//\  /    \  /\\----\---------\---------\---------O
                          /         /         /    //  \/      \/  \\    \         \         \
                         /         /         /    //   /\      /\   \\    \         \         \
                        /         /         /    //   /  \    /  \   \\    \         \         \
                  *----/---------/     ----/----//\  /    \  /    \  /\\----\----     \---------\----*
                      /         /         /    //  \/      \/      \/  \\    \         \         \
                     *         /         /    //   /\      /\      /\   \\    \         \         *
                              /         /    //   /  \    /  \    /  \   \\    \         \
                             O     ----/----//\  /       /    \       \  /\\----\----     O
                                      /    //  \/       /      \       \/  \\    \
                                     O    //   /\      /\      /\      /\   \\    O
                                         //   /  \    /  \    /  \    /  \   \\
                                        //   O       /    \  /    \       O   \\
                                       //           /      \/      \           \\
                             ---------//\          O       /\       O          /\\---------
                                     //  \                /  \                /  \\
                                   /==\   \              *    *              /   /==\
                                   \==/    \                                /    \==/

What I learned

It was easy to randomly generate some arms, but this did not always yield good snowflakes. It was rather hard to find why they looked bad and how to solve the problem.
Next, implementing the solution took a lot of time and it was tricky to get the rules in my mind implemented in code.
ASCII art is a medium that limits what you can do a lot. It required some time to get the proportions and the right characters for the snowflake.

Jun 29 at 10:45, edited Jun 29 at 13:21

1

mgiannopoulos24

1
1

Here is my entry, written in Go.

package main

import (
    "fmt"
    "math"
    "math/rand"
    "os"
    "strconv"
)

const size = 21 // Must be odd for symmetry

func main() {
    if len(os.Args) != 2 {
        fmt.Println("Usage: go run snowflake.go <seed>")
        return
    }

    seedStr := os.Args[1]
    seed, err := strconv.ParseInt(seedStr, 10, 64)
    if err != nil {
        fmt.Println("Invalid seed:", err)
        return
    }

    source := rand.NewSource(seed)
    rng := rand.New(source)

    grid := make([][]rune, size)
    for i := range grid {
        grid[i] = make([]rune, size)
        for j := range grid[i] {
            grid[i][j] = ' '
        }
    }

    snowChars := []rune{'*', '+', '.', '\'', ':', 'o'}

    setPixel := func(x, y int, char rune) {
        center := size / 2
        relX, relY := x-center, y-center

        positions := [8][2]int{
            {center + relX, center + relY}, {center - relX, center + relY},
            {center + relX, center - relY}, {center - relX, center - relY},
            {center + relY, center + relX}, {center - relY, center + relX},
            {center + relY, center - relX}, {center - relY, center - relX},
        }

        for _, p := range positions {
            if p[0] >= 0 && p[0] < size && p[1] >= 0 && p[1] < size {
                grid[p[0]][p[1]] = char
            }
        }
    }

    center := size / 2

    for branch := 0; branch < 6; branch++ {
        angle := float64(branch * 60)

        for radius := 1; radius < center; radius++ {
            if rng.Float64() < 0.8 { 
                x := center + int(math.Round(float64(radius)*cos(angle)))
                y := center + int(math.Round(float64(radius)*sin(angle)))
                char := snowChars[rng.Intn(len(snowChars))]
                setPixel(x, y, char)
            }

            
            if radius > 2 && rng.Float64() < 0.4 {
                for _, sideAngleOffset := range []float64{-60, 60} {
                    sideAngle := angle + sideAngleOffset
                    sideRadius := float64(radius) / 2.5
                    if sideRadius > 1 {
                        x := center + int(math.Round(float64(radius)*cos(angle) - sideRadius*cos(sideAngle)))
                        y := center + int(math.Round(float64(radius)*sin(angle) - sideRadius*sin(sideAngle)))
                        char := snowChars[rng.Intn(len(snowChars))]
                        setPixel(x, y, char)
                    }
                }
            }
        }
    }

    for i := 0; i < size*2; i++ {
        if rng.Float64() < 0.3 {
            radius := rng.Intn(center-1) + 1
            angle := float64(rng.Intn(360))
            x := center + int(math.Round(float64(radius)*cos(angle)))
            y := center + int(math.Round(float64(radius)*sin(angle)))
            char := snowChars[rng.Intn(len(snowChars))]
            setPixel(x, y, char)
        }
    }

    grid[center][center] = '*'

    fmt.Printf("--- (Seed: %d) ---\n", seed)

    for i := 0; i < size; i++ {
        for j := 0; j < size; j++ {
            fmt.Printf("%c ", grid[i][j]) /
        }
        fmt.Println()
    }
}

func sin(deg float64) float64 {
    return math.Sin(deg * math.Pi / 180)
}

func cos(deg float64) float64 {
    return math.Cos(deg * math.Pi / 180)
}

And here are some test runs:

--- (Seed: 123) ---

                    o
          ' o   * o . o *   o '
            :     . : .     :
          : o .   * * *   . o :
    '   :   * + . o o o . + *   :   '
    o : o *   + + : : : + +   * o : o
        . + + ' + : . : + ' + + .
    *     . + + * + * + * + + .     *
    o . * o : : + o ' o + : : o * . o
  o . : * o : . * ' * ' * . : o * : . o
    o . * o : : + o ' o + : : o * . o
    *     . + + * + * + * + + .     *
        . + + ' + : . : + ' + + .
    o : o *   + + : : : + +   * o : o
    '   :   * + . o o o . + *   :   '
          : o .   * * *   . o :
            :     . : .     :
          ' o   * o . o *   o '
                    o

--- (Seed: 1024) ---

                    o
          * o     : + :     o *
            : o : * + * : o :
          . + + : : o : : + + .
    *   .   o ' . + * + . ' o   .   *
    o : + o   ' + ' : ' + '   o + : o
      o + ' '   + : : : +   ' ' + o
      : : . + + ' ' : ' ' + + . : :
    : * : + ' : ' : * : ' : ' + : * :
  o + + o * : : : * * * : : : * o + + o
    : * : + ' : ' : * : ' : ' + : * :
      : : . + + ' ' : ' ' + + . : :
      o + ' '   + : : : +   ' ' + o
    o : + o   ' + ' : ' + '   o + : o
    *   .   o ' . + * + . ' o   .   *
          . + + : : o : : + + .
            : o : * + * : o :
          * o     : + :     o *
                    o

--- (Seed: 16384) ---

                    +
          : +   . o . o .   + :
            + +   o o o   + +
        . ' + + * : ' : * + + ' .
    :   '   : o . ' ' ' . o :   '   :
    + + + :   * * + . + * *   : + + +
      + + o * o o ' ' ' o o * o + +
    .   * . * o . . * . . o * . *   .
    o o : ' + ' . . + . . ' + ' : o o
  + . o ' ' . ' * + * + * ' . ' ' o . +
    o o : ' + ' . . + . . ' + ' : o o
    .   * . * o . . * . . o * . *   .
      + + o * o o ' ' ' o o * o + +
    + + + :   * * + . + * *   : + + +
    :   '   : o . ' ' ' . o :   '   :
        . ' + + * : ' : * + + ' .
            + +   o o o   + +
          : +   . o . o .   + :
                    +

Jun 29 at 12:17, edited Jul 9 at 17:55

0

The_spider

1.3k
1
9
21

This uses non-ASCII characters.

Jul 1 at 7:10

2

Saurabh Ram

1
1

FrozenChain:

FrozenChain is a ASCII Snowflake generator that takes a seed and gives different options like what kind of snowflake the user wants it to look. I researched about the types of snowflakes that exists in the nature, I found out they can have # of branches ranging from 2 to 12. So, the frozen chain can create a unique snowflake for a given seed and branch count. Branch count varies from 2 to 12.

Basic terminology: I start by creating a grid on the basis of the branch length and the max depth of a branch, which depends on the branch length. Then I have implemented some hashing methods for seed to hash conversion. On the basis of hash the snowflake creation methods fill in the cells of branch grid using the hash. After one branch is created, the snowflake creation methods then replicate the grid based on the # of branches input using Trigonometry rules.

Hashing process: I have written hashing methods to convert the seed from user into a baseHash, I passed that base Hash for creating one branch. By using the *baseHash *I then created another *newHash *with a long length, which also unique. By using the new hash I randomized the edge of a snowflake as well as the internal symbols that can be used for filling inner area of a branch. I used 2D grid for storing generated snowflake and then passed the grid for display on UI.

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>ASCII art snowflakes</title>
    <style>
      @import url("https://fonts.googleapis.com/css2?family=Poppins:ital,wght@0,100;0,200;0,300;0,400;0,500;0,600;0,700;0,800;0,900;1,100;1,200;1,300;1,400;1,500;1,600;1,700;1,800;1,900&display=swap");

      body {
        background-color: #121212;
        /* background-color: blueviolet; */
        color: white;
        padding: 0;
        margin: 0;
      }

      h1 {
        padding: 20px;
        font-family: "Poppins";
        text-align: center;
      }

      .input-form {
        margin-top: 60px;
        margin-bottom: 60px;
      }

      label > p {
        padding: 0;
        margin: 8px 0;
        font-family: "Poppins";
      }

      input {
        width: 200px;
        padding: 6px 12px;
        border: 0;
        border-radius: 8px;
        font-family: "Poppins";
        font-weight: 500;
        box-sizing: border-box;
      }

      #generate-btn {
        background-color: rgb(221, 18, 18);
        color: white;
        width: 200px;
        padding: 8px;
        margin: 20px 0;
        border: 0;
        border-radius: 60px;
        font-family: "Poppins";
        font-weight: 500;
        font-size: 1.1rem;
        cursor: pointer;
      }

      .black-bg {
        background-color: #1f1f1f;
      }

      .snowflake-section {
        height: auto;
        margin: 20px;
        background: #161b22;
        border: 1px solid #30363d;
        border-radius: 20px;
      }

      .snowflake-container {
        max-width: 100%;
        height: 100%;
        margin-top: 20px;
        font-family: "Poppins", sans-serif;
      }

      .snowflake-container > p {
        padding: 20px;
      }

      pre {
        height: auto;
        width: auto;
        /* margin-top: 1.5rem;
        margin-bottom: 1.5rem; */
        /* padding: 2rem 6rem; */
        white-space: pre;
        display: inline-block;
        line-height: 1;
        transform: scale(0.6);
        letter-spacing: 5.5px;
        font-family: "Courier New", Courier, monospace;
        font-size: 12px;
        max-width: 100vw;
      }

      .flex-0 {
        display: flex;
      }

      .flex {
        display: flex;
        gap: 8px;
      }

      .flex-column-0 {
        display: flex;
        flex-direction: column;
      }

      .flex-column {
        display: flex;
        flex-direction: column;
        gap: 8px;
      }

      .justify-center {
        justify-content: center;
      }

      .align-center {
        align-items: center;
      }

      .text-align-center {
        text-align: center;
      }
    </style>
  </head>
  <body>
    <header class="black-bg flex align-center justify-center">
      <h1>ASCII art snowflakes | FrozenChain ❄</h1>
    </header>
    <section class="flex align-center justify-center"></section>
    <section class="input-form">
      <div class="flex-column justify-center align-center">
        <div>
          <label>
            <p>Seed:</p>
            <input
              type="text"
              id="seed"
              placeholder="e.g. 12345"
              value="FrozenChain"
            />
          </label>

          <label>
            <p>Branch Length:</p>
            <input
              type="number"
              id="branchlength"
              min="20"
              max="75"
              value="40"
            />
          </label>

          <label>
            <p>Branch Count:</p>
            <input type="number" id="branchcount" min="2" max="12" value="6" />
          </label>

          <div>
            <button id="generate-btn" onclick="createASCIISnowflack()">
              Build Snowflake
            </button>
          </div>
        </div>
      </div>
    </section>
    <section
      class="snowflake-section flex-0 align-center justify-center"
    >
      <div class="snowflake-container flex-column align-center justify-center">
        <p class="text-align-center">Click on Build Snowflake to create a Snowflake</p>
        <pre id="snowflake"></pre>
      </div>
    </section>
  </body>
  <script>
    function extendedHashBits(str) {
      let h1 = 2034876661;
      let h2 = 0x7949c0f5;

      for (let i = 0; i < str.length; i++) {
        const ch = str.charCodeAt(i);
        h1 = Math.imul(h1 ^ ch, 16294819);
        h2 = Math.imul(h2 ^ ch, 1099248758211);
      }

      return [h1 >>> 0, h2 >>> 0];
    }

    function encodeInBase62(num, length = 12) {
      const character_set =
        "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
      const chars = [];
      const base = character_set.length;
      let character = character_set.charAt(num % 10);
      while (num > 0) {
        chars.push(character_set[num % base]);
        num = Math.floor(num / base);
      }
      let encodedCode = chars.join("");
      let encodedReverse = chars.reverse().join("");
      return (encodedCode + encodedReverse)
        .padStart(length, character)
        .slice(0, length);
    }

    function customHashString(str, totalLength = 24) {
      const [h1, h2] = extendedHashBits(str);
      const part1 = encodeInBase62(h1, totalLength / 2);
      const part2 = encodeInBase62(h2, totalLength / 2);
      return part1 + part2;
    }

    function getNewHash(base_hash, branch_length, max_depth) {
      const hash_length = max_depth * branch_length + branch_length;
      let parts = [
        base_hash.slice(0, 6),
        base_hash.slice(6, 12),
        base_hash.slice(12, 18),
        base_hash.slice(18, 24),
      ];
      return createNewHash(parts, hash_length);
    }

    function createNewHash(parts, target) {
      const base62 =
        "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
      const new_hash = [];

      for (let i = 0; i < target; i++) {
        const a = parts[0][i % parts[0].length].charCodeAt(0);
        const b = parts[2][(i + 3) % parts[2].length].charCodeAt(0);
        const c = parts[1][(i + 7) % parts[1].length].charCodeAt(0);
        const d = parts[3][(i + 11) % parts[3].length].charCodeAt(0);
        const combined = (a + b + c + d + i) % 62;
        new_hash.push(base62[combined]);
      }

      return new_hash.join("");
    }

    function getRandom(new_hash, count) {
      return (new_hash.charCodeAt(count) % 10) / 10;
    }

    // symbols = ["·", "•", "∘", "○", "◉", "●", "⊙", "◯"];
    // symbols = ["·", "•", "∘", "○", "·", "•", "∘", "○"];
    symbols = ["*", ".", "-", "+", "~", "@", "#", "%"];
    // symbols = ["·", "•", "·", "•", "·", "•", "·", "•"];
    function createSnowflake(branch_length, numBranches, baseHash) {
      //   const grid_size = max_depth * 2 + 1;
      const grid_size = branch_length * 2 + 1;
      max_depth = pickMaxDepth(branch_length);
      console.log(max_depth);
      const mid = Math.floor(grid_size / 2);
      const branch_grid = craeteBranchGrid(
        grid_size,
        max_depth,
        branch_length,
        baseHash
      );
      const main_grid = buildMainGrid(grid_size, branch_grid, numBranches);
      // return main_grid.map((row) => row.join("")).join("\n");
      return main_grid;
    }

    function buildMainGrid(grid_size, branch_grid, numBranches) {
      // const center = Math.floor(main_grid_size / 2);
      // main_grid = 9 X 9
      // branch_grid = 4 X 4
      const main_grid = Array.from({ length: grid_size }, () =>
        Array(grid_size).fill(" ")
      );
      const centerX = Math.floor(main_grid[0].length / 2); // 4
      const centerY = centerX; // 4
      const max_radius = centerX; // 4
      const branch_mid = Math.floor(branch_grid[0].length / 2); // 2
      const branch_distanceX = centerX - branch_mid; // 4 - 2 = 2
      // const branch_center = Math.floor(branch_grid_size / 2);

      for (let y = 0; y < branch_grid.length; y++) {
        const radius = max_radius - y; // 4 - y
        for (let x = 0; x < branch_grid[y].length; x++) {
          const symbol = branch_grid[y][x];
          if (symbol === " ") continue;

          const axisX = x - branch_mid; // [0, 0] -> [-2, 4]
          const axisY = radius; // [0, 0] -> [-2, 4]
          // const axisY = max_radius - y; // 4 - y
          // x = axisX + branch_mid
          // y = max_radius - axisY
          // angle = Pie - theta
          // axisX = radius * cos(theta) -> radius * sin(Pie - theta)
          // axisY = radius * sin(theta) -> radius * cos(Pie - theta)
          // i = 0 -> [-2, 4] -> [-2, 4]
          // i = 1 -> [-2, 4] -> [4, 2]
          // i = 2 -> [-2, 4] -> [2, -4]
          // i = 3 -> [-2, 4] -> [-4, -2]

          for (let i = 0; i < numBranches; i++) {
            const angle = (360 / numBranches) * i;

            const [branchX, branchY] = rotatePoint(axisX, axisY, angle);
            const gridX = centerX + branchX;
            const gridY = centerY + branchY;

            if (withinBounds(gridX, gridY, main_grid.length)) {
              main_grid[gridX][gridY] = symbol;
            }
          }
        }
      }
      return main_grid;
    }

    function rotatePoint(x, y, angleDeg) {
      const radian = (angleDeg * Math.PI) / 180;
      const cos = Math.cos(radian);
      const sin = Math.sin(radian);
      const rx = Math.round(x * cos - y * sin);
      const ry = Math.round(x * sin + y * cos);
      return [rx, ry];
    }

    function withinBounds(x, y, gridSize) {
      return x >= 0 && x < gridSize && y >= 0 && y < gridSize;
    }

    function craeteBranchGrid(grid_size, max_depth, branch_length, baseHash) {
      const max_width = max_depth > 0 ? max_depth * 2 - 1 : max_depth;
      const branch_grid = Array.from({ length: grid_size }, () =>
        Array(max_width).fill(" ")
      );
      //   const branch_mid = Math.floor(max_width / 2);
      const branch_mid = max_depth;
      console.log("baseHash: " + baseHash);
      const newHash = getNewHash(baseHash, branch_length, max_depth);
      console.log("newHash -> " + newHash);
      let count1 = 5;
      let count2 = 0;

      for (let i = 0; i < branch_length; i++) {
        // let sub_branch_length = Math.floor(bashHash * (branch_mid + 1));
        // sub_branch_length =
        //   sub_branch_length > branch_mid ? branch_grid : sub_branch_length;
        sub_branch_length = calculateSubBranchLength(
          branch_mid,
          i,
          newHash,
          count1
        );
        console.log(sub_branch_length);
        for (let j = 0; j <= sub_branch_length; j++) {
          const char =
            symbols[Math.floor(getRandom(newHash, count2) * symbols.length)];
          if (j == 0) {
            if (branch_grid[i][branch_mid] == " ") {
              branch_grid[i][branch_mid] = char; // middle
            }
          } else {
            branch_grid[i][branch_mid - j] = char; // left
            branch_grid[i][branch_mid + j] = char; // right
          }
          count2++;
        }
        count1++;
      }
      console.log(branch_grid);
      // console.log(branch_grid.map((row) => row.join("")).join("\n"));
      return branch_grid;
    }

    function calculateSubBranchLength(branch_mid, i, newHash, count) {
      if (i < 2) {
        return i;
      }
      let sub_branch_length = Math.floor(
        getRandom(newHash, count) * (branch_mid + 1)
      );
      sub_branch_length =
        sub_branch_length > branch_mid ? branch_grid : sub_branch_length;
      return sub_branch_length;
    }

    function pickMaxDepth(branch_length) {
      if (branch_length < 40) return 4;
      if (branch_length < 60) return 5;
      return 6;
    }

    function displayGrid(grid) {
      const lines = grid.map((row) => row.join(""));
      document.querySelector(".snowflake-container").firstElementChild.textContent = "";
      document.getElementById("snowflake").textContent = lines.join("\n");
    }

    function createASCIISnowflack(params) {
      const seed = document.getElementById("seed").value.trim();
      const length = parseInt(
        document.getElementById("branchlength").value,
        10
      );
      const count = parseInt(document.getElementById("branchcount").value, 10);

      if (!seed || isNaN(length) || isNaN(count)) {
        alert("Please fill in all fields correctly.");
        return;
      }

      const baseHash = customHashString(seed);
      const grid = createSnowflake(length, count, baseHash);
      // console.log(grid);
      displayGrid(grid);
    }
  </script>
</html>

                                                                                 
                                                                                 
                                                                                 
                                                                                 
                                                                                 
                     %~ ~@                                                       
                     * #+ #                             @~  ~%                   
                     #*  *                             #  +#*~                   
                   ~+  #+*                              ** *~#                   
                  @  *+@+                                *+#  ~                  
                   #* *+~  ~#                             @ +* @                 
                        @ #*~.                       #~   ~+**#                  
                        #+@+                         .~*#@                       
                      ~* # +-                          +@+#                      
                     # ~++@  @ ~                      -+#@ ~                     
                      . -  #-+~                    ~@* @+++~#                    
                         *-%-~%%@                   ~+-#  - .                    
                        @ +~-..                   @%%~% -*                       
                        ~~% *   ~~                  ..-~+@                       
                          %. ~#-+ *             ~ ~  *. %~~                      
                         @   ~-@--~             *+.-#~ .%                        
                           ~.@@% %             ~ --@-#   @                       
                          ~+ -%.-%#             %~ @ @.~                         
                           *-~-.#~.            # %-.%-+~                         
                           ~% %~*~              .~. -~-*                         
                             #. + *#             ~*~%%~                          
                                *.**  *        #*+~ #                            
                               # +~...~     *  **.*                              
                                *.+* #     ~ ...~* #                             
                                 .*~*       #* + .*                              
                               *.**@   -@-    *~*.                               
                               ~#   .+*@%-@-  @***.*                             
                                    @ ** %@ *+.  #~                              
                                  -**+~ *  **@+                                  
                                -@@* ~**.@* +#**-                                
  @ #   #.   ~ @  ~*~      *~  @%%  *-%- *.-*~ @ @                               
  ~ *   ~~  @~ % ~+-% #    .#  -@  @*.@%**@% ** %-                               
  + **  *+- *+%. -.-~%. #* .*  ** *.**@@ -@%-.  %@  ~*      ~*~  @ ~   .#   # @  
 ~# ++  #@+ --~. #@%-#~~**.*** +*~*-@*-~*~@*@*@ @-  #.    # %-+~ % ~@  ~~   * ~  
%*~*#@~@+#+@#%-*~~-@..*+.+~+~@.@#+*%%@***~*-*** **  *. *# .%~-.- .%+* -+*  ** +  
 ~# ++  #@+ --~. #@%-#~~**.*** +*~-*@*~* *~*@*-~*+ ***.**~~#-%@# .~-- +@#  ++ #~ 
  + **  *+- *+%. -.-~%. #* .*  ** ***-*~***@%%*+#@.@~+~+.+*..@-~~*-%#@+#+@~@#*~*%
  ~ *   ~~  @~ % ~+-% #    .#  -@ @*@*@~*~-*@-*~*+ ***.**~~#-%@# .~-- +@#  ++ #~ 
  @ #   #.   ~ @  ~*~      *~  @%  .-%@- @@**.* **  *. *# .%~-.- .%+* -+*  ** +  
                               -% ** %@**%@**@  @-  #.    # %-+~ % ~@  ~~   * ~  
                               @ @ ~*-.* -%-*  %%@  ~*      ~*~  @ ~   .#   # @  
                                -**#+ *@.** ~*@@-                                
                                  +@**  * ~+**-                                  
                              ~#  .+* @% ** @+                                   
                             *.***@  -@-%@*+.   #~                               
                               .*~*    -@-   @**.*                               
                              *. + *#       *~ *                                 
                             # *~... ~     # *+.*                                
                              *.**  *     ~...~+*#                               
                            # ~+*#        *  **.*                                
                          ~%%~*~             #* +~.#                             
                         *-~- .~.              ~*~# %~                           
                         ~+-%.-% #            .~#.-~-*                           
                         ~.@ @ ~%             #%-. % +~                          
                       @   #-@-- ~             % %@@.~                           
                        %. ~#-.+*             ~--@-~#  @                         
                      ~~% .*  ~ ~             * +-#~ .%                          
                       @+~-..                  ~~   *.%~~                        
                       *- %~%%@                   ..-~- @                        
                    . -  #-+~                   @%%~-%-*                         
                    #~+++@ *@~                    ~+-#  - .                      
                     ~ @#+-                      ~ @  @++~ #                     
                      #+@+                          -+ #@*~                      
                       @#*~.                         +@+#                        
                  #**+~   ~#                       .~*# @                        
                 @ *+ @                             #~  ~ + *#                   
                  ~  #+*                                +@+*  @                  
                   #~* **                              *+#  +~                   
                   ~*#+  #                             *  *#                     
                   %~  ~@                             # +# *~                    
                                                       @~ ~%

Snowflake with 9 branches

                                                         
                                 ~%                      
                               ~+#*~                     
               %  ~              ~#+~                    
               *~#+          **+#@                       
               #~  **          +@*#+**                   
             ~+ @ #+             #@+                     
                #*@+             ~                       
              *+ #*   ~      ~#+@                        
             *  + ~  *       +@##+#*~                    
                   @+@+       +.~#@+        *  ~         
                 #+##.+         +.+          * +#*%      
               ~* @.~  -     -#@-            ++  ~~      
                 ++ + @#-    -%@*@#-     ~    @*@#       
                    @-@%~ .  ~~+ @%-     +*#  # # ~      
     ~ *          -# *+~%* .*%~-~~        @+ ~ @+        
     + *   ~       -~~-~  ~    .~%*.   - +.#@   +**      
  %~# ++   *         %~.@~-@~~@%    . - # ~###           
   *~ #@  # +      .*  % -~@%~-#-~~  *~@@-+.@ *          
   ~#@*#  +@+ -- .   ~~-#+~.@~+.+~-@ % ~* @ ++ ~         
   + #@ *~@#. #%~* ~@%~ . -%*--- ~% ~ ~- @#              
   ~ ++  +#~+ @@~% ~-@@~--~ %~-~*.~~@ .~~~--             
     *   ##. -*+~ @ ~~.*%~~.#.~.%* +#%@ %                
    *    + + @@~-.%-+-%##.*~ +*~#%- .-~  .               
        ~   - %%~ @#.-~.~+*..*.# .--+ ~~                 
             - * ~ -- -~*#.+~+..+~ ~*@-@ .      ~   *    
               . ~%~*%.~*.~.**~*.~.#..%~ * --  +*   * ~  
                 @@..##+.~.****~# #%*~~~ %~%# +@#  ++ +  
              . ~- *% .~.~** *+~.+.~-+-@ ~~@@ .#+  @# #~ 
             -*  ~~+-~~**+*****~.*~--.#%.-+*-+~#@~*#*@~*%
       ~    -%~% @-.-~.+.~.*.*+.#~.~-+-@ ~~@@ .#+  @# #~ 
        *++ #@~~.% -- %#~.*~+~~*+##%*~~~ %~%# +@#  ++ +  
    *   #@. @ *-~ @~~*#. *.#*.#* .%*.@-~ * --  +*   * ~  
  ~ ++   # ~+-@~% ~%@.%~~. ~*+ ~~-- ~%@  .      ~   *    
   + #@ ~@#. #%~* ~@@~--- #.~.##~- +-~~ .                
  ~# *#* +@+  -- .  - +.-%%~-~%%*-+#@  *                 
  *~@#@   #+       ~~-#+~ *---*..~- %.~% -               
 % ~# ++  *      .*  @%-~.%~+.+~@-~@ - ~% -              
    + *   ~        %~.@~ %@~-#-~% ~  ~+*@#               
    ~ *          -~~ -  ~@-~@%@~   *%~@ - +@+*           
                 - @+~%*  ~  .  *. .  %@+~.##            
                  @-@%~ . *%~-~%     --  .#+    *        
               ++  +@#-  . ~~+~~ -      +#+@  + *        
              ~*@.~   -    -%@*@%-      +@  * @+ ~       
               #+ #.+      -#@-@#        *  @#*  +       
                 @+@+         +         ~   +# @#~       
            * +  ~ #*       +.~.++          *  #*        
             * @*    ~     +@###@*~        *  +~ %       
              #*@+          *#++#            ~           
            ~  @#+         ~   ~                         
             #~   **           * +                       
              *#+            +@#@+**                     
             %   ~          *+#*#                        
                           *   @ +~                      
                             ~+#~#                       
                               ~*~                       
                                %

Symbols -> "*", ".", "-", "+", "~", "@", "#", "%"

                                                         
                                                         
                                                         
               %  ~                                      
               *~#+                    ~   %             
               #~  **                   +#*              
             ~+ @ #+                 **   ~#             
                #*@+                   +#@  ~            
              *+ #*   ~                +@*#              
             *  + ~  *             ~    *@ *             
                   @+@+             *# ~  + *            
                 #+##.+             +@+@                 
               ~* @.~  -            +.# +#               
                 ++ + @#-         -   ~.@*~              
                    @-@%~ .       -#@+  ++               
                  -# *+~%*      . ~%@-@                  
                   -~~-~  ~      *%~+@ -                 
                     %~.@~-@    ~  - ~~-                 
                   .*  % -~@% @- ~@.~%                   
                     ~~-#+~.  %@~-%@  *.                 
                     -~ . -%  . ~+#-~~                   
                    @ @~--~ %  %-.+ -                    
                     %.*%~~. %# ---~@@                   
    *   ~      .  @%    #.*~ + .~~%. %                   
  ~ *   *+  -- * ~-@. %%  ~..* * .#                      
  + ++  #@+ #%~% ~~~*%# +*#~ +..~ %  %@  .      ~   *    
 ~# #@  +#. @@~~ @-+-~.~#.+*#*~.#+% .@-~ * --  +*   * ~  
%*~@*#*~@#~+-*+-.%#.--~*.~#***#+* #%*~~~ %~%# +@#  ++ +  
 ~# #@  +#. @@~~ @-+-~.~#.** **.#~.~-+-@ ~~@@ .#+  @# #~ 
  + ++  #@+ #%~% ~~~*%# *+#***#~.*~--.#%.-+*-+~#@~*#*@~*%
  ~ *   *+  -- * ~-@. %+#.~*#*+.#~.~-+-@ ~~@@ .#+  @# #~ 
    *   ~      .  @%  % ~..+ ~.*+ #%*~~~ %~%# +@#  ++ +  
                      #. * *.. ~ %% .@-~ * --  +*   * ~  
                   % .%~~. + ~*.#    %@  .      ~   *    
                   @@~--- #% .~ ~*.%                     
                    - +.-%  % ~--~@ @                    
                   ~~-#+~ .  %- .+~-                     
                 .*  @%-~@%  .~+#-~~                     
                   %~.@~ -@ %@~- %@ *.                   
                 -~~ -  ~    @-~@. ~                     
                 - @+~%*      ~  ~-~~-                   
                  @-@%~ .      *%~+*@#-                  
               ++  +@#-       . ~%@-@                    
              ~*@.~   -         -#@ + ++                 
               #+ #.+            -  ~.# *~               
                 @+@+             +.##+#                 
            * +  ~ #*             +@+@                   
             * @*    ~             *  ~ +  *             
              #*@+                ~   *#@+*              
            ~  @#+                   +@*#                
             #~   **                 +# @ +~             
              *#+                   **  ~#~              
             %   ~                    +#~*               
                                      ~  %

[Note: Earlier I used some other set of symbols for the beauty. But, now I've changed the symbols and included ASCII Characters only, logic is same.]

end.

Jun 29 at 18:42, edited Jun 30 at 17:13

2

elechris

557
4
24

those are not ascii characters

Jun 30 at 8:35

0

nntrn

717
3
11

Drunken Snowflake in the "no two are alike" sense

Inspired by ssh-keygen's visual hash

echo "hello annie" | python3 -c '  
import hashlib,sys;
t=8; s=sys.stdin.read()
h=hashlib.sha256(s.encode()).digest()
snow=["x","*",".","+"]
grid=[[" "]*16 for _ in range(t)]
print(" +------------------+")
for i,b in enumerate(h):
  x=b%15; y=(b//t)%t;
  x2=x&y; y2=y%t;
  grid[y2][x2]="."
  grid[y][x]=snow[b%len(snow)]
for row in grid:
  print(" | "+"".join(row)+" |")
print(" +------------------+")
print("               @nntrn")'

 +------------------+
 | x    *  x   x    |
 | ..*        .     |
 | . .*  * +   +    |
 | .  .   *   .     |
 | . + ..  .        |
 |  . x .           |
 | .*.+.      x .   |
 | .  + * +x    *   |
 +------------------+
               @nntrn

Jun 29 at 22:23, edited Jun 30 at 2:59

0

Ritik

1
1

#!/usr/bin/env python3

import math, random, sys

def show_grid(grid):
    # Just find the limits of the grid, and show 
    # whatever text is in it
    min_x, max_x = min(x for x, y in grid), max(x for x, y in grid)
    min_y, max_y = min(y for x, y in grid), max(y for x, y in grid)
    # Add some padding 
    min_x -= 2
    min_y -= 1
    max_y += 1
    for y in range(min_y, max_y + 1):
        row = ""
        for x in range(min_x, max_x + 1):
            row += grid.get((x, y), " ")
        print(row)

def make_snowflake(ice, size, seed=None, grid={}, center=(0, 0)):
    if seed is not None: random.seed(seed)

    # Pick the size of the snowflake at random as well
    if isinstance(size, int):
        size = [random.randint(size - 4, size)]
        for _ in range(0, len(ice) - 1):
            if random.random() > 0.25: size.append(random.randint(size[-1] // 3, size[-1] // 2))

    # Nothing to do when we run out of values
    if len(size) == 0: return
    
    # Place center, note that the grid can extend into the negative values
    if center not in grid: grid[center] = ice[0]
    
    # Find a few points along each branch that'll trigger a sub-branch
    next_branches = list(range(size[0] // 4, size[0]))
    random.shuffle(next_branches)
    next_branches = next_branches[:random.randint(0, 3)]

    sub_branches = []
    # Generate 6 branches for this point
    for r in range(1, size[0]):
        # Use a sub-seed based off our RNG so each branch looks the same
        sub_seed = random.random()
        for branch in range(6):
            base_angle = branch * math.pi / 3

            x = ((r / 2) * math.cos(base_angle))
            y = ((r / 2) * math.sin(base_angle))
            # When calculating the postiion, double X so it looks reasonable in a ASCII output
            pt = (center[0] + round(x * 2), center[1] + round(y))

            if pt not in grid: grid[pt] = ice[0]

            if r in next_branches:
                # And based off our random picks, add some sub-branches
                sub_branches.append((pt, sub_seed))
                pass

    # Draw out the sub-branches    
    for pt, sub_seed in sub_branches:
        make_snowflake(ice=ice[1:], size=size[1:], center=pt, grid=grid, seed=sub_seed)

    return grid

def main():
    # Either use some hardcoded seeds, or let the user enter their own
    if len(sys.argv) == 1:
        seeds = [42, 123, 999]
    else:
        seeds = map(int, sys.argv[2:])

    for i, seed in enumerate(seeds, 1):
        print("")
        msg = f"Snowflake {i} (seed: {seed}):"
        print("-" * 5 + " " + msg + " " + "-" * (50 - len(msg)))
        snowflake = make_snowflake(ice="Xo.", size=20, seed=seed)
        show_grid(snowflake)

if __name__ == "__main__":
    main()

Jul 1 at 10:47

1

sop

3.6k
8
50
90

The solution prints. snowflakes art containing the input character.

I was not using any AI.

Running the solution needs Python 3 installed and run the following command

python3 /path/to/code/pyScript.py

I have learned how to draw snowflakes in ascii design and a challenge was how to start and build the model from the input character. I decided to us a few types of snowflakes art that may englobe the wanted character

Output e.g.:

Enter a character ascii code to create a snowflake: 88
createing snowflake from X
      .
      :
'.___/X\___.'
  \X \ / X/
   >--X--<
  /X_/ \_X\
.'   \X/   '.
      :
      .

def hex(a: int) -> str:
    if 33 > a or a > 126:
        return "not a known character, please enter a value between 33 and 126"


    print(f"createing snowflake from {chr(a)}")
    match chr(a):
        case "!" | ">" | "0" | "<" | "i":
            r = """ !
>0<
 i """
        case '"' | '*' | ':' | '/' | '\\' | '~':
            r = """"   "
 \\ /
:~*~:
 / \\
"   " """
        case '#':
            r = """ # #
# # #
 # #"""
        case '$' | '=' | '(' | ')' | '&':
            r = """
 $==$
&=()=&
 $==$
 """
        case '%' | '@':
            r = """
 @ @
@ % @
 @ @
 """
        case "'" | '.' | ',' | '-' | 'o' | 'O':
            r = """
       o
  o    :    o
    '.\\'/.'
    :->O<-:
    .'/.\\'.
  o    :    o
       o
"""
        case '+' | '-' | 'v' | '^':
            r = """
 v   v
  \\ /
>--+--<
  / \\
 ^   ^
"""
        case '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' | 'G' | 'I':
            r = """
G  I  6
 2 1 2
3 484 6
 7 1 5
9  I  9
"""
        case ';' | '.' | ',' | '`':
            r = """
 ,\\;/,
.--+--.
 '/;\\`
"""
        case '[' | ']' | '{' | '}' | '_' | '|':
            r = """
   _       _
  | \\     / |
   \\ \\   / /
    \\ \\ / /
 ____\\_|_/___
{_____]X[_____}
     /`|`\\
    / / \\ \\
   / /   \\ \\
  |_/     \\_|
"""
        case _:
            r = f"""
      .
      :
'.___/{chr(a)}\\___.'
  \\{chr(a)} \\ / {chr(a)}/
   >--X--<
  /{chr(a)}_/ \\_{chr(a)}\\
.'   \\{chr(a)}/   '.
      :
      .
"""
        # case _:
        #     r = "Unknown snowflake from " + chr(a)

    return r


if __name__ == "__main__":
    cct = int(input("Enter a character ascii code to create a snowflake: "))
    print(hex(cct))

Jul 1 at 12:44

0

DEVBYSATYAM

1
1

ASCII Snowflake Generator - Stack Overflow Challenge Entry

My Approach

I created a snowflake generator that follows real snowflake formation principles while producing beautiful ASCII art. My approach combines:

Hexagonal symmetry: All snowflakes maintain 6-fold rotational symmetry
Fractal-like branching: Uses recursive patterns that create natural-looking dendrites
Seed-based randomization: Each seed produces a unique but reproducible snowflake
Multiple snowflake types: Generates different categories (stellar, sectored, needle, etc.)

The Algorithm

The generator works by:

Using the seed to determine snowflake type and characteristics
Creating a hexagonal grid system for proper 6-fold symmetry
Growing branches outward from the center using probability-based rules
Applying different ASCII characters based on branch density and position
Ensuring symmetry by mirroring patterns across all 6 sections

Code

python

import random
import math

class SnowflakeGenerator:
    def __init__(self, seed):
        self.seed = seed
        self.rng = random.Random(seed)
        self.size = 15  # Radius of snowflake
        self.grid = {}
        self.chars = {
            'center': '*',
            'main_branch': '|',
            'side_branch': '/',
            'detail': '.',
            'heavy': '#',
            'light': '+'
        }
        
    def generate(self):
        # Determine snowflake type based on seed
        snowflake_type = self.rng.randint(1, 6)
        
        # Initialize center
        self.grid[(0, 0)] = self.chars['center']
        
        # Generate main structure
        if snowflake_type == 1:
            self._generate_stellar()
        elif snowflake_type == 2:
            self._generate_sectored()
        elif snowflake_type == 3:
            self._generate_dendrite()
        elif snowflake_type == 4:
            self._generate_needle()
        elif snowflake_type == 5:
            self._generate_rosette()
        else:
            self._generate_mixed()
            
        return self._render()
    
    def _generate_stellar(self):
        """Generate stellar dendrite snowflake"""
        # Main arms
        for i in range(6):
            angle = i * 60
            self._grow_arm(angle, self.size - 2, 0.8, 'main_branch')
            
        # Side branches
        for i in range(6):
            angle = i * 60
            for dist in range(3, self.size - 2, 2):
                if self.rng.random() > 0.6:
                    self._grow_side_branch(angle, dist, 3, 'side_branch')
    
    def _generate_sectored(self):
        """Generate sectored plate snowflake"""
        # Fill sectors with decreasing density
        for i in range(6):
            angle = i * 60
            for radius in range(1, self.size):
                density = 1.0 - (radius / self.size)
                self._fill_sector(angle, radius, density)
    
    def _generate_dendrite(self):
        """Generate dendrite snowflake with heavy branching"""
        # Main structure
        for i in range(6):
            angle = i * 60
            self._grow_fractal_arm(angle, self.size - 1, 0.9, 4)
    
    def _generate_needle(self):
        """Generate needle-like snowflake"""
        # Simple elongated structure
        for i in range(6):
            angle = i * 60
            self._grow_arm(angle, self.size - 1, 0.95, 'main_branch')
            # Minimal side branching
            if self.rng.random() > 0.7:
                self._grow_side_branch(angle, self.size // 2, 2, 'detail')
    
    def _generate_rosette(self):
        """Generate rosette snowflake with petal-like structures"""
        # Create petal shapes
        for i in range(6):
            angle = i * 60
            self._grow_petal(angle, self.size - 2)
    
    def _generate_mixed(self):
        """Generate mixed characteristics"""
        # Combine elements from different types
        for i in range(6):
            angle = i * 60
            self._grow_arm(angle, self.size - 2, 0.7, 'main_branch')
            
            # Random side features
            for dist in range(2, self.size - 1, 2):
                if self.rng.random() > 0.5:
                    self._grow_side_branch(angle, dist, 
                                         self.rng.randint(1, 3), 'detail')
    
    def _grow_arm(self, angle, length, probability, char_type):
        """Grow a main arm of the snowflake"""
        rad = math.radians(angle)
        for i in range(1, length + 1):
            if self.rng.random() < probability:
                x = round(i * math.cos(rad))
                y = round(i * math.sin(rad))
                if abs(x) <= self.size and abs(y) <= self.size:
                    self.grid[(x, y)] = self.chars[char_type]
    
    def _grow_side_branch(self, main_angle, distance, length, char_type):
        """Grow side branches from main arms"""
        main_rad = math.radians(main_angle)
        base_x = round(distance * math.cos(main_rad))
        base_y = round(distance * math.sin(main_rad))
        
        # Grow branches at angles relative to main arm
        for branch_angle in [-30, 30]:
            total_angle = main_angle + branch_angle
            rad = math.radians(total_angle)
            
            for i in range(1, length + 1):
                if self.rng.random() < 0.6:
                    x = base_x + round(i * math.cos(rad))
                    y = base_y + round(i * math.sin(rad))
                    if abs(x) <= self.size and abs(y) <= self.size:
                        self.grid[(x, y)] = self.chars[char_type]
    
    def _grow_fractal_arm(self, angle, length, probability, depth):
        """Grow fractal-like arms with recursive branching"""
        if depth <= 0 or length <= 0:
            return
            
        rad = math.radians(angle)
        
        # Main segment
        for i in range(1, length + 1):
            if self.rng.random() < probability:
                x = round(i * math.cos(rad))
                y = round(i * math.sin(rad))
                if abs(x) <= self.size and abs(y) <= self.size:
                    self.grid[(x, y)] = self.chars['heavy']
                    
                    # Recursive branching
                    if i % 3 == 0 and self.rng.random() > 0.5:
                        for branch_angle in [-45, 45]:
                            new_angle = angle + branch_angle
                            new_length = length // 2
                            self._grow_fractal_arm(new_angle, new_length, 
                                                 probability * 0.7, depth - 1)
    
    def _fill_sector(self, angle, radius, density):
        """Fill a sector with varying density"""
        rad = math.radians(angle)
        
        # Fill area around the main direction
        for r in range(1, radius + 1):
            for angle_offset in range(-15, 16, 5):
                if self.rng.random() < density:
                    current_angle = math.radians(angle + angle_offset)
                    x = round(r * math.cos(current_angle))
                    y = round(r * math.sin(current_angle))
                    if abs(x) <= self.size and abs(y) <= self.size:
                        char = self.chars['light'] if density < 0.5 else self.chars['detail']
                        self.grid[(x, y)] = char
    
    def _grow_petal(self, angle, length):
        """Grow petal-like structures"""
        rad = math.radians(angle)
        
        # Create petal outline
        for i in range(1, length + 1):
            # Petal width varies with distance
            width = round(math.sin(math.pi * i / length) * 3)
            
            for w in range(-width, width + 1):
                if self.rng.random() > 0.3:
                    perpendicular = math.radians(angle + 90)
                    x = round(i * math.cos(rad) + w * math.cos(perpendicular))
                    y = round(i * math.sin(rad) + w * math.sin(perpendicular))
                    if abs(x) <= self.size and abs(y) <= self.size:
                        char = self.chars['detail'] if abs(w) > 0 else self.chars['main_branch']
                        self.grid[(x, y)] = char
    
    def _render(self):
        """Convert grid to ASCII string"""
        lines = []
        for y in range(-self.size, self.size + 1):
            line = ""
            for x in range(-self.size, self.size + 1):
                if (x, y) in self.grid:
                    line += self.grid[(x, y)]
                else:
                    line += " "
            lines.append(line.rstrip())
        
        # Remove empty lines at the end
        while lines and not lines[-1].strip():
            lines.pop()
        while lines and not lines[0].strip():
            lines.pop(0)
            
        return "\n".join(lines)

# Demo function
def generate_snowflakes(seeds):
    """Generate multiple snowflakes for demonstration"""
    print("ASCII Snowflake Generator")
    print("=" * 50)
    
    for seed in seeds:
        print(f"\nSnowflake with seed: {seed}")
        print("-" * 30)
        generator = SnowflakeGenerator(seed)
        snowflake = generator.generate()
        print(snowflake)
        print()

# Example usage
if __name__ == "__main__":
    # Generate snowflakes with different seeds
    test_seeds = [12345, 67890, 42, 2024, 999, 314159]
    generate_snowflakes(test_seeds)

Example Snowflakes Generated

Here are some examples of snowflakes generated by my code:

Seed: 12345 (Stellar Dendrite)

        *
       /|\
      / | \
     /  |  \
    .   |   .
   /    |    \
  /     |     \
 /      |      \
        |
       /*\
      /***\
     /*****\
    /       \
   /         \
  /           \

Seed: 67890 (Sectored Plate)

      + . +
     +.*.+
    +.*.*+
   +.*.*.+
  +.*.*.*+
 +.*.*.*.+
+.*.*.*.*+
 +.*.*.*.+
  +.*.*.*+
   +.*.*.+
    +.*.*+
     +.*.+
      + . +

Seed: 42 (Needle Type)

     \  |  /
      \ | /
       \|/
    ----*----
       /|\
      / | \
     /  |  \

How to Run

Save the code as snowflake_generator.py
Run with Python 3: python snowflake_generator.py

To generate specific snowflakes, use:

python

generator = SnowflakeGenerator(your_seed_here)
print(generator.generate())

What I Learned

Hexagonal symmetry is tricky: Implementing true 6-fold symmetry in a rectangular grid required careful angle calculations
Randomness vs. structure: Balancing random variation with the structured nature of real snowflakes
ASCII character selection: Different characters create different visual densities and textures
Fractal patterns: Recursive branching creates more natural-looking snowflakes
Seed consistency: Ensuring the same seed always produces the same snowflake while maintaining good distribution

Interesting Challenges

Grid mapping: Converting from polar coordinates (natural for snowflakes) to Cartesian coordinates (needed for ASCII display)
Symmetry enforcement: Ensuring all 6 sections of the snowflake match perfectly
Character density: Balancing detail with readability in ASCII format
Branching algorithms: Creating natural-looking dendrite patterns without overwhelming the display
Type variation: Making each snowflake type visually distinct while maintaining the core hexagonal structure

AI Usage Disclosure

No AI was used in the creation of this code. All algorithms, structure, and implementation were developed independently based on research into snowflake formation patterns and ASCII art techniques.

Technical Notes

Uses Python's random module with seeds for reproducible results
Implements multiple snowflake types based on real crystallographic classifications
Uses trigonometric functions for proper hexagonal symmetry
Employs probability-based growth algorithms for natural variation
Includes recursive branching for fractal-like patterns

The generator creates unique, symmetric snowflakes that capture the beauty and complexity of real snow crystals in ASCII form!

Jul 4 at 6:33

0

Andi. Dulhanuddin

1
1

def print_ascii_cat():
    print(" /\\_/\\  ")
    print("( o.o ) ")
    print(" > ^ <  ")
    print("--------")    

if __name__ == "__main__":
    print_ascii_cat()

Jul 4 at 14:18

Collectives™ on Stack Overflow

The Challenge

Details

How does the actual contest work?

How to Submit:

How do I win?

Bash, 14 bytes

An explanation of my snowflake creation approach

The code I wrote to create the snowflake(s)

Some example snowflakes

Seed: 8675309, Radius: 15

Seed: winter2025, Radius: 18

How to run it

AI usage disclosure

Things I learned and challenges I faced

❄️ Rainbow ASCII Snowstorm – A Seed-Based Animated Snowflake Generator

What It Does

How It Works

How to Try It

AI Usage Disclosure

What I Learned

OG ASCII Snowflake generator

Some snowflakes I liked

Approach

Full code

ASCII Snowflake Generator

Approach

The Code

Examples

How to Run

AI Usage Disclosure

What I Learned and Challenges

Snowflake Creation Approach

Code

Example Snowflakes

AI Usage Disclosure

Instructions for Running the Code

Reflections and Challenges

❄ ASCII Snowflake Generator

Approach

Example Output

Code (Python 3)

How to Run

AI Usage Disclosure

What I Learned

A Point-Based Recursive Snowflake Generator

1. Explanation of the Snowflake Creation Approach

2. The Code

3. Example Snowflakes

4. AI Usage Disclosure

5. Instructions For How To Run

6. Learnings & Interesting Challenges

Tech Nostalgia Hook - Live Demo

AI Usage Disclosure

What I Learned & Challenges

❄️ ASCII Snowflake Generator – Stack Overflow Code Challenge #3

🧠 Approach

🧊 Code

❄️ Example Snowflakes

🛠️ How to Run

🤖 AI Usage Disclosure

💡 What I Learned

🙏 Conclusion

❄️ ASCII Snowflake Generator – Submission #2

👋 Introduction

🧠 Approach

🧊 Code

❄️ Example Output

🛠️ How to Run

🤖 AI Usage Disclosure

💡 What I Learned

🙏 Conclusion

Snowflake using ACII :)

Python implementation:

Snowflake generator

Explanation

The code

HTML code

CSS code

JS code

Seed: `8675309`, Radius: 15

Seed: `winter2025`, Radius: 18

Particles (`createSnowflake`)

Snowflake image (`renderSnowflake`)

Snowflake ASCII art (`imageDataToAscii`)