Take the 2-minute tour ×
Programming Puzzles & Code Golf Stack Exchange is a question and answer site for programming puzzle enthusiasts and code golfers. It's 100% free, no registration required.

The trees we are growing have some rules that define how they grow:

Growth Rules:

  1. Trees consist only of branches.
  2. Branches are made up of a combination of the following symbols: _, \, |, /, & _
  3. A tree starts as a single vertical branch/trunk (|) on the ground (_):


  4. The food for branch growth comes from light.

    • Light starts at an intensity of 2 at each point in the sky and travels straight down.
    • Each branch is able to eat half the light available to it and the rest passes through to lower branches.
    • Thus, a branch with no other branches above it will get 1 unit of light-food each season, a branch with 1 branch above it will get .5 units of food each season, and in general a branch with n branches over it will get 1/(2^n) units of food each season.
  5. At the end of each season, the food is totaled starting with the trunk and moving up and converted into new branches and fruit (apply the following rules until the branch turns into fruit or has less than 1 unit of food remaining):
    • If a branch has less than 1 unit of food at the end of a season, all the food for that branch is stored in that branch until the next season.
    • If a branch has greater than or equal to 1 unit of food and has room to grow, it randomly grows a new branch using the available growth patterns (see below) and stores the remaining food for the next season.
    • If a branch has >= 1 unit of food, nowhere to grow, and has offshoot branches, it evenly distributes the food to its offshoot branches
    • If a branch has >= 1 unit of food, nowhere to grow, and no offshoot branches, it becomes fruit (represented by O)
  6. Here are the possible growth configurations

Growth Configurations:

_    \     |     /   _      _   \   |    /   \    |   /   _ 
 |    |    |    |   |        \   \   \   \   /   /   /   /     __   \_   |_   _|  _/  __
--- Vertical Branches ---      --- Diagonal Branches ---      --- Horizontal Branches ---

Example potential tree:

                /   /
              \/O  |___//
            \_/  \//O\_/ 


Your program should be able to take as input a list of which snapshots of the tree you would like to see. For example [10,20,50] would mean you'd like to see the tree after 10 seasons, 20 seasons, and 50 seasons.


For each input season, your program should output the season and then a picture of the tree in that season. If it helps, you can define a maximum age for the tree, such as 60, so that the maximum height for a tree would be 61, and the maximum width would be 121, and then always show the tree on that scale. Otherwise, feel free to scale your image to any sized tree. For example, if the input was [0,1,2,3], your output might be:

Season 0:

Season 1:

Season 2:

Season 3:

 |_/ _


Each solution must post the output of the coder's favorite run of their program with input of [10,40], along with their source code. Also, ALL the above criteria must be met in order to qualify.

The winner will be the qualifier with the highest number of votes.

Good luck and merry planting!!!

share|improve this question
"Room to grow" doesn't seem to be defined. –  Peter Taylor Sep 20 '11 at 22:32
I think the tags "code-challenge" and "code-golf" do not fit together ("objective criterion other than code size" vs. "fewest bytes of source code"). –  Howard Sep 21 '11 at 12:03
@Peter Taylor: To see if there is room to grow, you must first check the growth configurations for that branch type (e.g. vertical branches can go up-left, up, and up-right), and then see if any of those spaces are empty. If so, there is room for growth. –  Briguy37 Sep 21 '11 at 13:09
@Howard: Yeah, I was thinking the same thing, but wasn't sure. I think this is definitely more challenging than most problems I've seen on here, so I definitely wanted "code-challenge". However, if there are multiple solutions, I wanted a way to determine a clear winner. The scoring calculation above favors voting over atomic-code-golf scoring, so the atomic-code-golf score is really mainly a tie-breaker. I'll leave it up to the people: The golf requirements will be waved if Howard's comment gets more up-votes than this one. –  Briguy37 Sep 21 '11 at 13:21
With the present scoring mechanism, it isn't a code-golf. It's not really a atomic-code-golf either. –  Peter Taylor Sep 21 '11 at 14:28
show 9 more comments

2 Answers 2


I took a little liberty with this:

  1. I allow multiple trees
  2. Fruit is preceded by flower -- once a flower has 1 food, it turns into a fruit.
  3. Fruit turns ripe when it has 3 food. It then falls off of the tree, and turns back into a flower.
  4. If fruit falls at least 4 places from any given trunk, it buds into a new tree. Since it doesn't get much light, I seed it with as much food as was in the fruit.

Sample Output, 2 trees

     \/\_ |  /             |  
 _  _/\|\|_\/             /|/ 
  |/ \/|/|O/              \|/ 
   \_/O|@|/               /|_ 
     \_|_|                \|  

                       _      \                                   
                _/ _ \/\___/\|/                  \                
             /|\|\O@|/\/|__\/ \__/_\|/\\|  _ |/| _||/\\ /         
             \|_|@|\|@/O|@@/O_/@O|@/ \//\   \|\||@||@///          
           \_ \_|\|/@\\O|@||/OO//O\\O/ \@|@\||/@|\/\/|/   | / _   
        ___/    |/|/O//O|O||\\/|/O// \_O\|__| \O|/\/O|   _/\\|    
         / \_O@@_\/\O\\@|/O|/O\@\O\\@/OO/|O_@O/O|\/\/     \//|/__ 
     _|/|_|  \\|O\\/O/O||_@|\O|\/O//|O|@\|/O_O\@|/O/\_@O__//_||   
    | \\|____// |O|\O\O|/\@|/ |/O/ \|O|OO|\/@_/O|_O\/O//O_//O/    
    |_O\\@O\/\\OO\|/|/\O\O\|__@\|O@/|/O|O|/\OO\/|_O/  \\|OO\/     
   /  \\||_|\|||_O|\|@/OO\//OOO/|/@\|OO|\|\@|O \|\|O@O//  \/\     
 _/\_/@\|\@|/  \_||/ \\@|/\\\||/ \//O|O|/|/@|\@/|/O/OO\\__/  \||/ 
  \||/  |_|O\__@ |O\O/O||\///@|O_//|/OO|@|OO|/O\|O/OO|// /|\|/\|  
   ||___O@|_/  |__\/||_||/|\\/OO/|@|O|/ \|_O||_/O/O/O|/_|\/\|_/   
       /|//|\|O|_|O\O\O\/|O\/|@|/_|\OO@\/ \/|O/_|O//@|@/\_|       
       \O\\|/|_OO|OO\O|/\|@@\|O|/ @//|_@\_/\|//O_/|O/  \/         
        \O\|O_/|/ \|O|O\/|/OO|O|O_/ \|    \/|/|/@ |/\__/          
         |O|_O\|\O/|_|O/\|\//|/   \_/     /\@\| \_/\/             
          \OO\O|/ \ _|@\/O||@|\___/       \/|/    \/              
           |__|O\__|OO\/\@||/\/            \|O____/               
              |____|/@/\|\|O\/            _/|/O                   
                   |/ \/|/|@/              \|/                    
                    \_/O|@|/              |/|__                   
            \|/       \_|_|  \|_      \|/  \|    \|/  _|_         


from random import choice, shuffle
format = '_\|/_@O'
directions = [(-1,0),(-1,1),(0,1),(1,1),(1,0)]
placement = [[[],[0,1,2],[]],[[],[0,1,2],[3]],[[0,1],[2],[3,4]],[[1],[2,3,4],[]],[[],[2,3,4],[]]]

def shine():
    for x in ymax:
        light = 2.
        for y in range(ymax[x],-1,-1):
            if (x,y) in tree:
                tree[x,y][1] += light/2
                light        /= 2

def grow((x,y)=(0,0),flow=0):
    type,store,children = tree[x,y]
    food = store + flow
    if type == 5:
        if food > 1:
           tree[x,y][0] = 6
           tree[x,y][1] = food-1
    elif type == 6:
        if food > 3:
            if min(abs(x-xi) for xi in roots) > 4:
                tree[x,0] = [2,food,[]]

    if food < 1:
        for c in children:

    sites = []
    x0 = x+directions[type][0]-1
    y0 = y+directions[type][1]
    for i,t in enumerate(placement[type]):
        if t and (x0+i,y0) not in tree:

    if sites:
        t,x1,y1 = choice(sites)
        t1 = choice(t)
        tree[x1,y1]= [t1,0,[]]
        ymax[x1] = max(ymax.get(x1,0),y1)
    elif children:
        for c in children:

def output():
    X = range(min(ymax.keys())-1,max(ymax.keys())+2)
    for y in range(max(ymax.values()),-1,-1):
        s = ''
        for x in X:
            s += format[tree[x,y][0]] if (x,y) in tree else '_ '[y>0]
        print s

roots = [0,20]
seasons = [10,40]
tree = {}
ymax = {}
for r in roots:
    tree[r,0] = [2,0,[]]

for season in range(max(seasons)):
    for r in roots:
    if season+1 in seasons:

I'm curious to see a golfed solution.

share|improve this answer
I like the flowers turning into fruits and seeds idea! One suggestion: add a space rule to keep trees separate. For example, maybe branches cannot sprout on any space adjacent to a branch from another tree. –  Briguy37 Sep 21 '11 at 21:48
add comment

Python, 673 chars

Here's a golfed version:

import random
for s in range(61):
 if s in S:
  for y in range(60,0,-1):print''.join(Z[T[x+y*1j]]if x+y*1j in T else' 'for x in range(121))
 for p in T:F[p]+=.5**sum(q.real==p.real and q.imag>p.imag and T[q]<4for q in T)
 for p in[q for q in T if F[q]>=1]:
  D=[p+d,c for d,c in B[T[p]]if p+d not in T]
  if D:q,c=random.choice(D);F[p]-=1;T[q]=c;F[q]=0;C[q]=[];C[p]+=[q]
  elif C[p]:
   for q in C[p]:F[q]+=F[p]/len(C[p])

sample @10 (truncated to the interesting part):

           |  |_   
       |_|/\_\ \|  
 |   \\/\|\/__|/   
 |/   \\O|O\__|    

sample @40:

             _  _        \_ _ / _|                        
        // _|/\|_\||_\___/ \_|_|/|/|_ |  _    //          
/     _|\\|_/\/|\/_/\/O|O\OO\|\|OO\|  \\/  |/|/|_/|       
\/\|OOO|//OO\O\|//OO/O_|O||\O|/|/|/OOO/ \OOO\/\| \||_|  | 
 \_|/|_O\\|\O\/|/O/O\_O|/  \\|O|O|/OO\\_/\O\|\/OO/\|O_|\| 
   |_|OO/O|/O/\|\/\O|O||_OOO|\\|/ \/O_|O\/OO|/O_|\/|OO|/  
     |/|\O|\|\/OO\O\|_|OO\|||// \OO\_O|O/  |||/_O/O|__|   
      \|O\O\|/\O\/\O|O|O\/O||/O_/|OO/\| \OO/\|/  \_|      
       |_/ O|\/O/\/\O\|\|\O|/\/OO|/ \/OO/\O\O\\__/        
         \_/O/\||/\O|\|O|O\\\/O_| \O/|/ \/O/_//     
           \O\/  \O\|_|O/\// \/OOOO|\|OO/|/|_|   
            |/\OO/O/  |O\/|\O/\O\|\O\|_|\|_|     
              \|OOO\|O \\\|O|/|OO|OO\|          
               |/ \O|\_O\\|O|\|OO|O|/       
                  \_|OO \\O\|\/O_|/    
                    |/   \\O|O\__|    
share|improve this answer
Interesting... your tree looks very flat on top, whereas mine look rounded. I wonder if one of us has a bug, or it's that I shuffle children to randomize what order they spawn grandchildren in. Also, I notice that your fruit doesn't capture light... I wasn't sure if I should do that or not. –  boothby Sep 23 '11 at 6:45
add comment

Your Answer


By posting your answer, you agree to the privacy policy and terms of service.

Not the answer you're looking for? Browse other questions tagged or ask your own question.