popularity contest - Make a scalable Christmas Tree - Programming Puzzles & Code Golf Stack Exchange
to customize your list.
Programming Puzzles & Code Golf Stack Exchange is a question and answer site for programming puzzle enthusiasts and code golfers. J it only takes a minute:
Here's how it works:
Anybody can ask a question
Anybody can answer
The best answers are voted up and rise to the top
Your challenge: Make a Christmas tree. The size must be choosable by some input method, but doesn't have to be directly related to
however, larger inputs should produce a larger tree.
How can you make it? You can make the tree any way you like, other than by printing the , such as ouputting an image, ascii art, with other aspects, etc. Whatever you do, remember that this is a , so be creative.
The answer with the most upvotes by the end of December wins, but I'll accept another if it gets higher
15.6k84499
closed as too broad by , , , ,
There are either too many possible answers, or good answers would be too long for this format.
Please add details to narrow the answer set or to isolate an issue that can be answered in a few paragraphs.If this question can be reworded to fit the rules in the , please .
A fractal Christmas tree using the turtle package:
n = input()*1.
from turtle import *
speed("fastest")
forward(3*n)
color("orange", "yellow")
begin_fill()
for i in range(5):
forward(n/5)
right(144)
forward(n/5)
end_fill()
right(126)
color("dark green")
backward(n*4.8)
def tree(d, s):
if d &= 0: return
forward(s)
tree(d-1, s*.8)
right(120)
tree(d-3, s*.5)
right(120)
tree(d-3, s*.5)
right(120)
backward(s)
tree(15, n)
backward(n/2)
import time
time.sleep(60)
n is the size parameter, the shown tree is for n=50.
Takes a minute or two to draw.
16.4k13092
JavaScript
Show the animated tree .
var size = 400;
var canvas = document.createElement('canvas');
canvas.width =
canvas.height =
document.body.appendChild(canvas);
var ctx = canvas.getContext('2d');
var p3d = [];
var p = [Math.random(), Math.random(), Math.random(), 0];
for (var i = 0; i & 100000; i++) {
p3d.push([p[0],p[1],p[2],p[3]]);
var t = Math.random();
if (t&0.4) {
_y = 0.4 * p[1];
_x = 0.1 * p[0];
_z = 0.6 * p[2];
var r = Math.floor(3*t/0.4)/3.0;
var rc = Math.cos(Math.PI*2.0*r);
var rs = Math.sin(Math.PI*2.0*r);
p[1] = _x+0.1*r+0.5*_y*_y;
p[0] = _y*rc+_z*
p[2] = _z*rc-_y*
p[3] = 0.2*t + 0.8*p[3];
p[1] = 0.2 + 0.8*p[1];
p[0] = 0.8 * p[0];
p[2] = 0.8 * p[2];
p[3] = 0.2 + 0.8*p[3];
var rot = 0.0;
function render() {
rot = rot + 0.1;
var rc = Math.cos(rot);
var rs = Math.sin(rot);
ctx.strokeStyle='#FF7F00';
ctx.lineWidth=2;
ctx.beginPath();
ctx.moveTo(size/2,size/8);
ctx.lineTo(size/2,size*15/16);
ctx.stroke();
var img = ctx.getImageData(0, 0, size, size);
for (var j = 0; j & size* j++) {
img.data[4*j+0] = 0.5*img.data[4*j+0];
img.data[4*j+1] = 0.5*img.data[4*j+1];
img.data[4*j+2] = 0.5*img.data[4*j+2];
img.data[4*j+3] = 255;
for (var i = 0; i & p3d. i++) {
var px = p3d[i][0];
var py = 0.5 - p3d[i][1];
var pz = p3d[i][2];
var col = Math.floor(128.0*p3d[i][3]);
var _x = rc*px + rs*
var _z = rc*pz - rs*
var z = 3.0 * size / (_z + 4.0);
var x = size / 2 + Math.round(_x * z);
var y = size / 2 + Math.round(py * z);
if(x&=0&&y&=0&&x&size&&y&size) {
img.data[4 * (y * size + x) + 0] =
img.data[4 * (y * size + x) + 1] = 128+
img.data[4 * (y * size + x) + 2] =
img.data[4 * (y * size + x) + 3] = 255;
ctx.putImageData(img, 0, 0);
setInterval(render, 1000 / 30);
21.7k23274
Yet another Mathematica / Wolfram Language tree based on :
s[t_, f_] := t^.6 - f
dt[cl_, ps_, sg_, hf_, dp_, f_, flag_] :=
Module[{sv, basePt},
{PointSize[ps],
sv = s[t, f];
Hue[cl (1 + Sin[.02 t])/2, 1, .3 + sg .3 Sin[hf sv]],
basePt = {-sg s[t, f] Sin[sv], -sg s[t, f] Cos[sv], dp + sv};
Point[basePt],
{Hue[cl (1 + Sin[.1 t])/2, 1, .6 + sg .4 Sin[hf sv]], PointSize[RandomReal[.01]],
Point[basePt + 1/2 RotationTransform[20 sv, {-Cos[sv], Sin[sv], 0}][{Sin[sv], Cos[sv], 0}]]},
frames = ParallelTable[
Graphics3D[Table[{
dt[1, .01, -1, 1, 0, f, True], dt[.45, .01, 1, 1, 0, f, True],
dt[1, .005, -1, 4, .2, f, False], dt[.45, .005, 1, 4, .2, f, False]},
{t, 0, 200, PD}],
ViewPoint -& Left, BoxRatios -& {1, 1, 1.3},
ViewVertical -& {0, 0, -1},
ViewCenter -& {{0.5, 0.5, 0.5}, {0.5, 0.55}}, Boxed -& False,
PlotRange -& {{-20, 20}, {-20, 20}, {0, 20}}, Background -& Black],
{f, 0, 1, .01}];
Export["tree.gif", frames]
Javascript
This is my first code golf!
var a=40,b=8,c=13,o="&div style='font-family:text-align:color:#094'&",w=1,x=0,y="|#|&br&";for(i=1;i&a;i++){for(j=0;j&w;j++){x%c==0?o+="&span style='color:#D00'&O&/span&":o+="+";x++;}i%b==0?w-=4:w+=2;o+="&br&";}document.write(o+"&span style='color:#640'&"+y+y+y+"&/span&&/div&");
It comes in at 295 Characters.
The size and decoration of the tree is set by the a,b,c variables:
a sets the amount of rows in the tree
b sets the amount of rows between decreases in width (set low for a skinny tree, high for a fat tree). Must be greater than or equal to 3.
c sets the amount of baubles (set zero for none, 1 for only baubles, higher numbers for less dense placement of baubles)
It looks best when a is a multiple of b, as in the example.
Paste into the console to create a tree. Looks better from far away!
Let's make it in the spirit of IOCCC and have the code in the shape of a tree as well! :D
#include &iostream&
w=a*2+5;for
0;x&a;++x){
for(int y=2;y&=
0;--y){for(int z=0;
z&a+y-x;++z
){cout&&" ";}for(
int z=0;z&x*2-y*2+5;++z
){cout&&".";}cout
&&}}for(int x=0;
x&w/5+1;++x){for(int z=0;
z&w/3+1;++z){cout&&" ";}for(
int z=0;z&w-(w/3+1)*2;z+=1){cout
&&"#";}cout
Takes an integer as input, and returns a Christmas tree with that many "stack levels". For example, an input of
...........
...........
.............
11.2k734112
Javascript
Quasirealistic fully 3D procedural fir tree generator.
Featuring: extensive configuration with even more configuration opt rotation of a fully grown tree.
Not featuring: jQuery, Underscore.js
hardware dependency - only canvas messy code (at least that was the intention)
Live page:
Edit page:
screenshot:
&canvas id=c width=200 height=300 style="display:none"&&/canvas&
&div id=config&&/div&
Javascript:
var TAU = 2*Math.PI,
deg = TAU/360,
TRUNK_VIEW
= {lineWidth:3, strokeStyle: "brown", zIndex: 1},
BRANCH_VIEW
= {lineWidth:1, strokeStyle: "green", zIndex: 2},
TRUNK_SPACING
TRUNK_BIAS_STR
TRUNK_SLOPE
BRANCH_LEN
INIT_SLOPE
MAX_D_SLOPE
DIR_KEEP_BIAS
GROWTH_MSPF
= 10, //ms per frame
GROWTH_TPF
= 10, //ticks per frame
ROTATE_MSPF
ROTATE_RPF
= 1* //radians per frame
var configurables = [
{key: "TRUNK_SPACING", name: "Branch spacing", widget: "number",
description: "Distance between main branches on the trunk, in pixels"},
{key: "TRUNK_BIAS_STR", name: "Branch distribution", widget: "number",
description: "Angular distribution between nearby branches. High values tend towards one-sided trees, highly negative values tend towards planar trees. Zero means that branches grow in independent directions."},
{key: "TRUNK_SLOPE", name: "Trunk slope", widget: "number",
description: "Amount of horizontal movement of the trunk while growing"},
{key: "BRANCH_P", name: "Branch frequency", widget: "number",
description: "Branch frequency - if =1/100, a single twig will branch off approximately once per 100 px"},
{key: "MIN_SLOPE", name: "Minimum slope", widget: "number", scale: deg,
description: "Minimum slope of a branch, in degrees"},
{key: "MAX_SLOPE", name: "Maximum slope", widget: "number", scale: deg,
description: "Maximum slope of a branch, in degrees"},
{key: "INIT_SLOPE", name: "Initial slope", widget: "number", scale: deg,
description: "Angle at which branches leave the trunk"},
{key: "DIR_KEEP_BIAS", name: "Directional inertia", widget: "number",
description: "Tendency of twigs to keep their horizontal direction"},
{get: function(){return maxY}, set: setCanvasSize, name: "Tree height",
widget:"number"}
var config = document.getElementById("config"),
canvas = document.getElementById("c"),
= canvas.width/2,
= canvas.height,
canvasRatio = canvas.width / canvas.height,
function setCanvasSize(height){
if(height === 'undefined') return maxY;
maxY = canvas.height =
canvas.width = height * canvasR
maxX = canvas.width/2;
var nodes = [{x:0, y:0, z:0, dir:'up', isEnd:true}], buds = [nodes[0]],
branches = [],
trunkDirBias = {x:0, z:0};
////////////////////////////////////////////////////////////////////////////////
configurables.forEach(function(el){
switch(el.widget){
case 'number':
widget = document.createElement("input");
if(el.key){
widget.value = window[el.key] / (el.scale||1);
el.set = function(value){window[el.key]=value * (el.scale||1)};
widget.value = el.get();
widget.onblur = function(){
el.set(+widget.value);
default: throw "unknown widget type";
var p = document.createElement("p");
p.textContent = el.name + ": ";
p.appendChild(widget);
p.title = el.
config.appendChild(p);
var button = document.createElement("input");
button.type = "button";
button.value = "grow";
button.onclick = function(){
button.value = "stop";
button.onclick = function(){clearInterval(interval)};
config.style.display="none";
canvas.style.display="";
c=canvas.getContext("2d");
c.translate(maxX, maxY);
c.scale(1, -1);
interval = setInterval(grow, GROWTH_MSPF);
document.body.appendChild(button);
function grow(){
for(var tick=0; tick&GROWTH_TPF; tick++){
var budId = 0 | Math.random() * buds.length,
nodeFrom = buds[budId], nodeTo, branch,
dir, slope, bias
if(nodeFrom.dir === 'up' && nodeFrom.isEnd){
nodeFrom.isEnd =
rndArg = Math.random()*TAU;
nodeTo = {
x:nodeFrom.x + TRUNK_SPACING * TRUNK_SLOPE * Math.sin(rndArg),
y:nodeFrom.y + TRUNK_SPACING,
z:nodeFrom.z + TRUNK_SPACING * TRUNK_SLOPE * Math.cos(rndArg),
dir:'up', isEnd:true}
if(nodeTo.y & maxY){
console.log("end");
clearInterval(interval);
rotateInit();
nodes.push(nodeTo);
buds.push(nodeTo);
branch = {from: nodeFrom, to: nodeTo, view: TRUNK_VIEW};
branches.push(branch);
renderBranch(branch);
}else{ //bud is not a trunk top
if(!(nodeFrom.dir !== 'up' && Math.random() & BRANCH_P)){
buds.splice(buds.indexOf(nodeFrom), 1)
nodeFrom.isEnd =
if(nodeFrom.dir === 'up'){
bias = {x:trunkDirBias.x * TRUNK_BIAS_STR,
z:trunkDirBias.z * TRUNK_BIAS_STR};
slope = INIT_SLOPE;
bias = {x:nodeFrom.dir.x * DIR_KEEP_BIAS,
z:nodeFrom.dir.z * DIR_KEEP_BIAS};
slope = nodeFrom.
var rndLen = Math.random(),
rndArg = Math.random()*TAU;
dir = {x: rndLen * Math.sin(rndArg) + bias.x,
z: rndLen * Math.cos(rndArg) + bias.z};
var uvFix = 1/Math.sqrt(dir.x*dir.x + dir.z*dir.z);
dir = {x:dir.x*uvFix, z:dir.z*uvFix};
if(nodeFrom.dir === "up") trunkDirBias =
slope += MAX_D_SLOPE * (2*Math.random() - 1);
if(slope & MAX_SLOPE) slope = MAX_SLOPE;
if(slope & MIN_SLOPE) slope = MIN_SLOPE;
var length = BRANCH_LEN * Math.random();
nodeTo = {
x: nodeFrom.x + length * Math.cos(slope) * dir.x,
y: nodeFrom.y + length * Math.sin(slope),
z: nodeFrom.z + length * Math.cos(slope) * dir.z,
dir: dir, slope: slope, isEnd: true
//if(Math.abs(nodeTo.x)/maxX + nodeTo.y/maxY & 1)
nodes.push(nodeTo);
buds.push(nodeTo);
branch = {from: nodeFrom, to: nodeTo, view: BRANCH_VIEW};
branches.push(branch);
renderBranch(branch);
}// end if-is-trunk
}// end for-tick
}//end func-grow
function rotateInit(){
branches.sort(function(a,b){
return (a.view.zIndex-b.view.zIndex);
interval = setInterval(rotate, ROTATE_MSPF);
var time = 0;
var view = {x:1, z:0}
function rotate(){
view = {x: Math.cos(time * ROTATE_RPF),
z: Math.sin(time * ROTATE_RPF)};
c.fillStyle = "white"
c.fillRect(-maxX, 0, 2*maxX, maxY);
branches.forEach(renderBranch);
c.stroke();
c.beginPath();
var prevView =
function renderBranch(branch){
if(branch.view !== prevView){
c.stroke();
for(k in branch.view) c[k] = branch.view[k];
c.beginPath();
prevView = branch.
c.moveTo(view.x * branch.from.x + view.z * branch.from.z,
branch.from.y);
c.lineTo(view.x * branch.to.x + view.z * branch.to.z,
branch.to.y);
8,12021745
Sample output:
The tree size (i.e. number of lines) is passed on the command line, and is limited to values of 5 or greater. The image above was produced from the command ./xmastree.sh 12. Here's the source code:
#!/bin/bash
declare -a a=('.' '~' "'" 'O' "'" '~' '.' '*')
[[ $# = 0 ]] && s=9 || s=$1
[[ $s -gt 5 ]] || s=5
for (( w=1, r=7, n=1; n&=$s; n++ )) ; do
for (( i=$s-n; i&0; i-- )) ;
echo -n " "
for (( i=1; i&=w; i++ )) ; do
echo -n "${a[r]}"
[[ $r -gt 5 ]] && r=0 || r=$r+1
16.9k33278
Disclaimer: this is based on my LaTeX christmas tree, first posted here:
The following code will generate a chrismtas tree, with random decorations. You can change both the size of the tree, and the random seed to generate a different tree.
To change the seed modify the value inside \pgfmathsetseed{\year * 6} to any other numerical value (the default one will generate a new tree every year)
To change the size of the tree modify the order=10 to be either larger, or smaller depending on the size of the tree you want.
Examples. order=11:
\documentclass{article}
\usepackage{tikz}
\usetikzlibrary{calc, lindenmayersystems,shapes,decorations,decorations.shapes}
\begin{document}
\def\pointlistleft{}
\def\pointlistright{}
\pgfmathsetseed{\year * 6}
\makeatletter
\pgfdeclarelindenmayersystem{Christmas tree}{
\symbol{C}{\pgfgettransform{\t} \expandafter\g@addto@macro\expandafter\pointlistleft\expandafter{\expandafter{\t}}}
\symbol{c}{\pgfgettransform{\t} \expandafter\g@addto@macro\expandafter\pointlistright\expandafter{\expandafter{\t}}}
\rule{S -& [+++G][---g]TS}
\rule{G -& +H[-G]CL}
\rule{H -& -G[+H]CL}
\rule{g -& +h[-g]cL}
\rule{h -& -g[+h]cL}
\rule{T -& TL}
\rule{L -& [-FFF][+FFF]F}
\makeatother
\begin{tikzpicture}[rotate=90]
\draw [color=green!50!black,l-system={Christmas tree,step=4pt,angle=16,axiom=LLLLLLSLFFF,order=10,randomize angle percent=20}] lindenmayer system --
\pgfmathdeclarerandomlist{pointsleft}{\pointlistleft}
\pgfmathdeclarerandomlist{pointsright}{\pointlistright}
\pgfmathdeclarerandomlist{colors}{{red}{blue}{yellow}}
\foreach \i in {0,1,...,5}
\pgfmathrandomitem{\c}{pointsleft}
\pgfsettransform{\c}
\pgfgettransformentries{\a}{\b}{\c}{\d}{\xx}{\yy}
\pgfmathrandomitem{\c}{pointsright}
\pgfsettransform{\c}
\pgfgettransformentries{\a}{\b}{\c}{\d}{\XX}{\YY}
\pgftransformreset
\pgfmathsetmacro\calcy{min(\yy,\YY)-max((abs(\yy-\YY))/3,25pt)}
\draw[draw=orange!50!black, fill=orange!50, decorate, decoration={shape backgrounds, shape=star, shape sep=3pt, shape size=4pt}, star points=5] (\xx,\yy) .. controls (\xx,\calcy pt) and (\XX,\calcy pt) .. (\XX,\YY);
\foreach \i in {0,1,...,15}
\pgfmathrandomitem{\c}{pointsleft}
\pgfsettransform{\c}
\pgftransformresetnontranslations
\draw[color=black] (0,0) -- (0,-4pt);
\pgfmathrandomitem{\c}{colors}
\shadedraw[ball color=\c] (0,-8pt) circle [radius=4pt];
\foreach \i in {0,1,...,15}
\pgfmathrandomitem{\c}{pointsright}
\pgfsettransform{\c}
\pgftransformresetnontranslations
\draw[color=black] (0,0) -- (0,-4pt);
\pgfmathrandomitem{\c}{colors}
\shadedraw[ball color=\c] (0,-8pt) circle [radius=4pt];
\end{tikzpicture}
\end{document}
Befunge 93
This is an undecorated tree:
&::00p20pv
&:0`!#v_" ",1-
&:0`!#v_" ",1-
&91+,00g1-::0`!#v_^
&:0`!#v_"-",1-
&:0`!#v_" ",1-
"||"$ &@,,
Sample output, input is 10:
----------------------
Let's add some decorations:
&::00p20pv
&:0`!#v_" ",1-
&?&&" "&,1-
&91+,00g1-::0`!#v_^
&:0`!#v_"-",1-
&:0`!#v_" ",1-
"||"$ &@,,
Sample output:
----------------------
15.6k84499
HTML and CSS
&!DOCTYPE html&
&meta charset="utf-8"&
&title&Scalable christmas tree&/title&
background-color:
background-size: 11px 11px, 21px 21px, 31px 31
background-image: radial-gradient(circle at 5px 5px,white,rgba(255,255,255,0) 1px), radial-gradient(circle at 5px 5px,white,rgba(255,255,255,0) 2px), radial-gradient(circle at 5px 5px,white 1px,skyblue 1px);
border-style:
border-color:
border-bottom-color:
border-width: 20
border-top-width: 0;
border-bottom-width: 30
border-bottom-left-radius: 35%;
border-bottom-right-radius: 35%;
box-shadow: red 0 15px 5px -13
animation-name:
animation-duration: 1s;
animation-direction:
animation-iteration-count:
-webkit-animation-name:
-webkit-animation-duration: 1s;
-webkit-animation-direction:
-webkit-animation-iteration-count:
font-size: 30
text-align:
text-shadow: red 0 0 10
line-height: .5;
margin-top: 10
animation-name:
animation-duration: 1.5s;
animation-direction:
animation-iteration-count:
-webkit-animation-name:
-webkit-animation-duration: 1.5s;
-webkit-animation-direction:
-webkit-animation-iteration-count:
width: 100%;
height: 20
background-image: linear-gradient(to right, transparent 45%, brown 45%, #600 48%, #600 52%, brown 55%, transparent 55%);
@keyframes star {
from { text-shadow: red 0 0 3 }
to { text-shadow: red 0 0 30 }
@-webkit-keyframes star {
from { text-shadow: red 0 0 3 }
to { text-shadow: red 0 0 30 }
@keyframes light {
from { box-shadow: red 0 15px 5px -13 }
to { box-shadow: blue 0 15px 5px -13 }
@-webkit-keyframes light {
from { box-shadow: red 0 15px 5px -13 }
to { box-shadow: blue 0 15px 5px -13 }
&header&★&/header&
&div id="0"&&div id="1"&&div id="2"&&div id="3"&&div id="4"&&div id="5"&&div id="6"&&div id="7"&&div id="8"&&div id="9"&&div id="10"&&div id="11"&&div id="12"&&div id="13"&&div id="14"&&div id="15"&&div id="16"&&div id="17"&&div id="18"&&div id="19"&&div id="20"&&div id="21"&&div id="22"&&div id="23"&&div id="24"&
&/div&&/div&&/div&&/div&&/div&&/div&&/div&&/div&&/div&&/div&&/div&&/div&&/div&&/div&&/div&&/div&&/div&&/div&&/div&&/div&&/div&&/div&&/div&&/div&&/div&
&footer&&/footer&
&/section&
Sizes between 1 and 25 are supported – just add the size to the URL as fragment identifier.
Works in Chrome, Explorer and Firefox. In Opera is ugly, but the scaling part works.
Sample access:
http://localhost/xmas.html#5
Sample access:
http://localhost/xmas.html#15
Live view:
(The live view contains no vendor prefixed CSS and includes links to change the size.)
12.8k32464
import java.awt.D
import java.awt.G
import java.awt.Graphics2D;
import java.awt.T
import java.awt.event.MouseE
import java.awt.event.MouseL
import java.awt.geom.AffineT
import java.awt.image.BufferedI
import java.io.IOE
import java.net.URL;
import javax.imageio.ImageIO;
import javax.swing.JF
import javax.swing.JP
import javax.swing.SwingU
* @author Quincunx
public class ChristmasTree {
public static double scale = 1.2;
public static void main(String[] args) {
SwingUtilities.invokeLater(new Runnable() {
public void run() {
new ChristmasTree();
public ChristmasTree() {
URL url = new URL("/comics/tree.png");
BufferedImage img = ImageIO.read(url);
JFrame frame = new JFrame();
frame.setUndecorated(true);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
Dimension d = Toolkit.getDefaultToolkit().getScreenSize();
BufferedImage result =
new BufferedImage((int)(img.getWidth() * scale),
(int) (img.getHeight() * scale),
BufferedImage.TYPE_INT_RGB);
Graphics2D g = (Graphics2D) result.getGraphics();
g.drawRenderedImage(img, AffineTransform.getScaleInstance(scale, scale));
JImage image = new JImage(result);
image.setToolTipText("Not only is that terrible in general, but you "
+ "just KNOW Billy's going to open the root present first, "
+ "and then everyone will have to wait while the heap is "
+ "rebuilt.");
frame.add(image);
frame.pack();
frame.setVisible(true);
} catch (IOException ex) {
class JImage extends JPanel implements MouseListener {
public JImage(){
this(null);
public JImage(BufferedImage image){
setPreferredSize(new Dimension(image.getWidth(), image.getHeight()));
addMouseListener(this);
public void paintComponent(Graphics g) {
super.paintComponent(g);
g.drawImage(img, WIDTH, WIDTH, this);
public void setImage(BufferedImage image) {
repaint();
public void mouseClicked(MouseEvent me) {
System.exit(0);
public void mousePressed(MouseEvent me) {
public void mouseReleased(MouseEvent me) {
public void mouseEntered(MouseEvent me) {
public void mouseExited(MouseEvent me) {
To alter the size, change scale to some other double value (keep it around 1 if you want to see anything).
Sample output (for 1.0 as scale, too lazy to take a screenshot, so just posted what it does):
The program takes this image from the internet, resizes it according to scale, then puts it in an undecorated window where it is displayed. Clicking on the window closes the program. Also, the tool tip text is there, but the link is not.
15.6k84499
TI-89 Basic
Just because I wanted to see a Christmas Tree on my calculator. I shall type it here as it appears on my calculator.
:Local size
:Prompt size
:Local d,x,y,str,orn
:{" "," "," "," "," "," "," "," ","°","∫","θ","O","(C)"}→orn
:While d≥0
: While x≥0
str&" "→str
: EndWhile
: str&"/"→str
: While x&0
str&elementAt(orn,rand(colDim(list?mat(orn))))→str
: EndWhile
: str&"\"→str
: Disp str
:For x,1,2*(size+2)
: str&"-"→str
:For x,1,size+1
: str&" "→str
:str&"||"→str
:elementAt(l,i)
:list?mat(l)→m
:colDim(m)→cd
:If i&cd or i≤0 Then
: If i=cd Then
Return sum(mat?list(subMat(m,1,i))) - sum(mat?list(subMat(m,1,i+1)))
Return sum(mat?list(subMat(m,1,i))) - sum(mat?list(subMat(m,1,i+1)))
This works the same way as my Befunge answer, but I use different ornaments. Yes, my elementAt function's repeated uses slows the program down because of many conversions between lists and matrices, but as I wrote it before, I decided against editing it. Also, I learned while typing this answer that (C) makes a comment (I thought it looked like @, but that is another character). Never knew what it was before now.
Sample output:
------------------
I love those ∫'s; they look like candy canes.
15.6k84499
Bash with Bc and ImageMagick
#!/bin/bash
size="${1:-10}"
width=$(( size*25 ))
height=$(( size*size+size*10 ))
cos=( $( bc -l &&& "for (i=0;i&3.14*2;i+=.05) c(i)*100" ) )
sin=( $( bc -l &&& "for (i=0;i&3.14*2;i+=.05) s(i)*100" ) )
cos=( "${cos[@]%.*}" )
sin=( "${sin[@]%.*}" )
cos=( "${cos[@]/%-/0}" )
sin=( "${sin[@]/%-/0}" )
for ((i=2;i&size+2;i++)); do
for ((j=3;j&=31;j++)); do
(( x=width/2+i*10+cos[62-j]*i*10/100 ))
(( y=i*i+sin[j]*i*5/100 ))
for ((e=0;e&i;e++)); do
-draw "line $x,$y $(( x+RANDOM%i-i/2 )),$(( y+RANDOM%i-i/2 ))"
-draw "line $(( width-x )),$y $(( width-x+RANDOM%i-i/2 )),$(( y+RANDOM%i-i/2 ))"
(( RANDOM%2 )) && (( x=width-x ))
-draw "circle $x,$(( y-i/2 )) $(( x+i/3 )),$(( y-i/2+i/3 ))"
(( RANDOM%10 )) || decor+=(
-fill "rgb($(( RANDOM%5*20+50 )),$(( RANDOM%5*20+50 )),$(( RANDOM%5*20+50 )))"
-draw "circle $x,$(( y+i )) $(( x+i/2 )),$(( y+i+i/2 ))"
for ((i=0;i&width*height/100;i++)); do
-draw "point $(( RANDOM%width )),$(( RANDOM%height ))"
-size "${width}x$height" \
xc:skyblue \
-stroke white \
-fill white \
"${snow[@]}" \
-blur 5x5 \
"${flake[@]}" \
-stroke brown \
-fill brown \
-draw "polygon $(( width/2 )),0 $(( width/2-size )),$height, $(( width/2+size )),$height" \
-stroke green \
-fill none \
"${needle[@]}" \
-stroke none \
-fill red \
"${decor[@]}" \
Sample run:
bash-4.1$ ./xmas.sh 5
Sample output:
Sample run:
bash-4.1$ ./xmas.sh 15
Sample output:
12.8k32464
Wolfram Language ( Mathematica )
As discussed at famed Reddit thread:
PD = .5; s[t_, f_] := t^.6 -
dt[cl_, ps_, sg_, hf_, dp_, f_] :=
{PointSize[ps], Hue[cl, 1, .6 + sg .4 Sin[hf s[t, f]]],
Point[{-sg s[t, f] Sin[s[t, f]], -sg s[t, f] Cos[s[t, f]], dp + s[t, f]}]};
frames = ParallelTable[
Graphics3D[Table[{dt[1, .01, -1, 1, 0, f], dt[.45, .01, 1, 1, 0, f],
dt[1, .005, -1, 4, .2, f], dt[.45, .005, 1, 4, .2, f]},
{t, 0, 200, PD}],
ViewPoint -& Left, BoxRatios -& {1, 1, 1.3}, ViewVertical -& {0, 0, -1},
ViewCenter -& {{0.5, 0.5, 0.5}, {0.5, 0.55}}, Boxed -& False, Lighting -& "Neutral",
PlotRange -& {{-20, 20}, {-20, 20}, {0, 20}}, Background -& Black],
{f, 0, 1, .01}];
Export["tree.gif", frames]
Sample output for depth=4, zoom=2.0
This answer employs an approach quite different from other answers. It generates a tree structure by recursively branching. Each branch is represented by a set of circles. And finally the main function samples the circles and fill with characters when circles are met. Since it is done by sampling a scene (like ray-tracing), it is intrinsically scalable. The downside is speed, since it traverse the whole tree structure for every "pixel"!
The first command-line argument controls the depth of branching. And the second controls scale (2 means 200%).
#include &math.h&
#include &stdio.h&
#include &stdlib.h&
#define PI 3.
float sdCircle(float px, float py, float r) {
float dx = px - sx, dy = py -
return sqrtf(dx * dx + dy * dy) -
float opUnion(float d1, float d2) {
return d1 & d2 ? d1 : d2;
#define T px + scale * r * cosf(theta), py + scale * r * sin(theta)
float f(float px, float py, float theta, float scale, int n) {
float d = 0.0f;
for (float r = 0.0f; r & 0.8f; r += 0.02f)
d = opUnion(d, sdCircle(T, 0.05f * scale * (0.95f - r)));
if (n & 0)
for (int t = -1; t &= 1; t += 2) {
float tt = theta + t * 1.8f;
float ss = scale * 0.9f;
for (float r = 0.2f; r & 0.8f; r += 0.1f) {
d = opUnion(d, f(T, tt, ss * 0.5f, n - 1));
ss *= 0.8f;
int ribbon() {
float x = (fmodf(sy, 0.1f) / 0.1f - 0.5f) * 0.5f;
return sx &= x - 0.05f && sx &= x + 0.05f;
int main(int argc, char* argv[]) {
int n = argc & 1 ? atoi(argv[1]) : 3;
float zoom = argc & 2 ? atof(argv[2]) : 1.0f;
for (sy = 0.8f; sy & 0.0f; sy -= 0.02f / zoom, putchar('\n'))
for (sx = -0.35f; sx & 0.35f; sx += 0.01f / zoom) {
if (f(0, 0, PI * 0.5f, 1.0f, n) & 0.0f) {
if (sy & 0.1f)
putchar('.');
if (ribbon())
putchar('=');
putchar("............................#j&o"[rand() % 32]);
putchar(' ');
I made this for , (not sure if reusing code is against the spirit/rules of this) but:
Brainfuck. Takes as input a number (length of bottom row of leaves) and two characters. One space between each.
Example input: 13 = +
Example output:
+++++++++++
+++++++++++++
---------[+
+++++++++++++
+++++++++++++++
+++&[&&++++++++++
&&-]&--------------
---------------------
-------------[&+&-]&[&&
+&&-]&,------------------
--------------],&,,&&++++[&
++++++++&-]++++++++++&+&&&&&-
[&&&&&&+&+&&&&&&&--]&&&&&&&[&&&
&&&&++&&&&&&&-]&&&&&&&[&&&&&&[&&&
.&&&&+&-]&[&+&-]&&[&&&.&&&&&+&&-]&&
[&&+&&-]&&&.&&&&-&++&&&&&--]&&...&&&-
--[&+&&&&..&&&--]&.&&[&&&.&&&&+&-]&&&&&
Mathematica ASCII
I really like ASCII art, so I add another very different answer - especially so it's so short in Mathematica:
Column[Table[Row[RandomChoice[{"+", ".", "*", "~", "^", "o"}, k]], {k, 1, 35, 2}],
Alignment -& Center]
And now with a bit more sophistication a scalable dynamic ASCII tree. Watch closely - the tree is also changing - snow sticks to -)
DynamicModule[{atoms, tree, pos, snow, p = .8, sz = 15},
Style["+", White],
Style["*", White],
Style["o", White],
Style[".", Green],
Style["~", Green],
Style["^", Green],
Style["^", Green]
pos = Flatten[Table[{m, n}, {m, 18}, {n, 2 m - 1}], 1];
tree = Table[RandomChoice[atoms, k], {k, 1, 35, 2}];
snow = Table[
RotateLeft[ArrayPad[{RandomChoice[atoms[[1 ;; 2]]]}, {0, sz}, " "],
RandomInteger[sz]], {sz + 1}];
Dynamic[Refresh[
tree[[Sequence @@ RandomChoice[pos]]] = RandomChoice[atoms];
Column[Row /@ tree, Alignment -& Center, Background -& Black],
RotateRight[
RotateLeft[#,
RandomChoice[{(1 - p)/2, p, (1 - p)/2} -& {-1, 0, 1}]] & /@
, {1, 0}]]
}, Alignment -& Center]
, UpdateInterval -& 0, TrackedSymbols -& {}]
Processing
The original fractal Christmas tree. Mouse Y position determines size, use up and down arrow keys to change the number of generations.
int size = 500;
int depth = 10;
void setup() {
frameRate(30);
size(size, size, P2D);
void draw() {
background(255);
tree(size/2.0, size, 0.0, radians(0), radians(108), (size - mouseY)/3, depth);
tree(size/2.0, size, 0.0, radians(108), radians(0), (size - mouseY)/3, depth);
void keyPressed() {
if(keyCode == UP) depth++;
if(keyCode == DOWN) depth--;
depth = max(depth, 1);
void tree(float posX, float posY, float angle, float forkRight, float forkLeft, float length, int generation) {
if (generation & 0) {
float nextX = posX + length * sin(angle);
float nextY = posY - length * cos(angle);
line(posX, posY, nextX, nextY);
tree(nextX, nextY, angle + forkRight, forkRight, forkLeft, length*0.6, generation - 1);
tree(nextX, nextY, angle - forkLeft,
forkRight, forkLeft, length*0.6, generation - 1);
Or, if you prefer a fuller tree:
int size = 500;
int depth = 10;
void setup() {
frameRate(30);
size(size, size, P2D);
void draw() {
background(255);
tree(size/2.0 - 5, size, 0.0, 0.0, (size - mouseY)/3, depth);
void keyPressed() {
if(keyCode == UP) depth++;
if(keyCode == DOWN) depth--;
depth = max(depth, 1);
void tree(float posX, float posY, float angle, float fork, float length, int generation) {
if (generation & 0) {
float nextX = posX + length * sin(angle);
float nextY = posY - length * cos(angle);
line(posX, posY, nextX, nextY);
tree(nextX, nextY, angle + fork + radians(108), fork, length*0.6, generation - 1);
tree(nextX, nextY, angle - fork,
fork, length*0.6, generation - 1);
tree(nextX, nextY, angle + fork - radians(108), fork, length*0.6, generation - 1);
((1..20).to_a+[6]*4).map{|i|puts ('*'*i*2).center(80)}
You can customize output by changing *.
For a green tree: ((1..20).to_a+[6]*4).map{|i|puts "\e[32m"+('*'*i*2).center(80)}
Approach 2 (Xmas tree that doesn't look like an arrow)
((1..6).to_a+(3..9).to_a+(6..12).to_a+[3]*4).map{|i|puts "\e[32m"+('*'*i*4).center(80)}
Approach 3
((1..20).to_a+[6]*4).map{|i|puts' '*(20-i)+'*'*(2*i-1)}
Based on properties of the .
The scale is determined by the step size (move forward by: 6). An interactive version is available .
P.S. Inspired by
Processing
I made this tree generator using an L-System and a Turtle.
//My code, made from scratch:
final int THE_ITERATIONS = 7;
final float SCALE = 1;
final int ANGLE = 130;
final int SIZE = 4;
final int ITERATIONS = THE_ITERATIONS - 1;
ArrayList&Turtle&
int turtleI
int lSystemI
void setup()
size(320, 420);
background(255);
translate(width / 2, height - 70);
lineLength = ITERATIONS * 2 + 2;
lSystem = "[-F][+F]F";
turtles = new ArrayList&Turtle&(ITERATIONS + 1);
lSystemIndex = 0;
calculateLSystem();
println(lSystem);
turtles.add(new Turtle(0, 0));
doTurtles();
save("Tree.png");
void doTurtles()
while(lSystemIndex & lSystem.length())
print("\"" + lSystem.charAt(lSystemIndex) + "\": ");
if(lSystem.charAt(lSystemIndex) == 'F')
turtleForward();
else if(lSystem.charAt(lSystemIndex) == '[')
lineLength -= 2;
addTurtle();
println(turtles.size());
else if(lSystem.charAt(lSystemIndex) == ']')
lineLength += 2;
removeTurtle();
println(turtles.size());
else if(lSystem.charAt(lSystemIndex) == '+')
turtleRight();
else if(lSystem.charAt(lSystemIndex) == '-')
turtleLeft();
lSystemIndex++;
void addTurtle()
turtles.add(new Turtle(turtles.get(turtles.size() - 1)));
void removeTurtle()
turtles.remove(turtles.size() - 1);
void turtleLeft()
turtles.get(turtles.size() - 1).left(ANGLE + random(-5, 5));
void turtleRight()
turtles.get(turtles.size() - 1).right(ANGLE + random(-5, 5));
void turtleForward()
print(turtles.get(turtles.size() - 1) + ": ");
strokeWeight(min(lineLength / SIZE, 1));
stroke(5 + random(16), 90 + random(16), 15 + random(16));
if(turtles.size() == 1)
strokeWeight(lineLength / 2);
stroke(100, 75, 25);
turtles.get(turtles.size() - 1).right(random(-3, 3));
turtles.get(turtles.size() - 1).forward(lineLength);
void calculateLSystem()
for(int i = 0; i & ITERATIONS; i++)
lSystem = lSystem.replaceAll("F", "F[-F][+F][F]");
lSystem = "FF" + lS
void draw()
//——————————————————————————————————————————————————————
// Turtle code, heavily based on code by Jamie Matthews
// http://j4mie.org/blog/simple-turtle-for-processing/
//——————————————————————————————————————————————————————
class Turtle {
float x, // Current position of the turtle
float angle = -90; // Current heading of the turtle
boolean penDown = // Is pen down?
// Set up initial position
Turtle (float xin, float yin) {
//lineLength = lineL
Turtle (Turtle turtle) {
x = turtle.x;
y = turtle.y;
angle = turtle.
//lineLength = turtle.lineLength - 1;
// Move forward by the specified distance
void forward (float distance) {
distance = distance * SIZE * random(0.9, 1.1);
// Calculate the new position
float xtarget = x+cos(radians(angle)) *
float ytarget = y+sin(radians(angle)) *
// If the pen is down, draw a line to the new position
if (penDown) line(x, y, xtarget, ytarget);
println(x + ", " + y + ", " + xtarget + ", " + ytarget);
// Update position
// Turn left by given angle
void left (float turnangle) {
println(angle);
// Turn right by given angle
void right (float turnangle) {
println(angle);
JavaScript (run on any page in console)
I was golfing this but then decided not to, so as you can see there are TONS of magic numbers :P
document.write('&canvas id=c width=' + s + ' height=' + s + '&')
c = document.getElementById('c').getContext('2d')
c.fillStyle = '#0D0'
for (var i = s / 3; i &= s / 3 * 2; i += s / 6) {
c.moveTo(s / 2, s / 10)
c.lineTo(s / 3, i)
c.lineTo(s / 3 * 2, i)
c.fillStyle = '#DA0'
c.fillRect(s / 2 - s / 20, s / 3 * 2, s / 10, s / 6)
Result for s = 300:
43.2k1185295
Game Maker Language
The tree's Create Event
image_speed=0
size=get_integer("How big do you want me to be?#Integer between 1 and 10, please!",10)
image_index=size-1
Room, 402 by 599
The tree is placed at (0,0)
Bonus! You can resize the Christmas tree after the initial input with the keys 0-9.
8,08212749
AppleScript + SE Answer
Actually picked this up by accident while editing an answer in this question. Go figure.
Use this by running the code, typing in your number that you want, swiping over to the SE post and clicking in the text field. This exploits the fact that quotes stack.
tell application "System Events"
set layers to (display dialog "" default answer "")'s text returned as number
repeat layers times
keystroke ">"
end repeat
Output (input 50):
6,94712367
Decorated FORTRAN tree
character(len=36) :: f='/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\'
character(len=18) :: g = '
character(len=14) :: p = ".x$.+oO+oO.#,~"
character(len=10) :: q
n = iargc()
if (n /= 1) then
k = len(g)
call getarg(1,q)
read(q,*) k
l = modulo(k,len(g))+1
j = mod(i,len(p)-1)+1
print *,g(1:l-i),p(j:j),f(1:2*i),p(j+1:J+1)
print *,g(1:l-1),f(1:4)
The tree has a limited range of sizes, but it believe it accurately reflects the life of most Christmas trees.
From infant tree:
To adolescent tree:
+/\/\/\/\o
o/\/\/\/\/\O
O/\/\/\/\/\/\+
+/\/\/\/\/\/\/\o
$./tree 17
+/\/\/\/\o
o/\/\/\/\/\O
O/\/\/\/\/\/\+
+/\/\/\/\/\/\/\o
o/\/\/\/\/\/\/\/\O
O/\/\/\/\/\/\/\/\/\.
./\/\/\/\/\/\/\/\/\/\#
#/\/\/\/\/\/\/\/\/\/\/\,
,/\/\/\/\/\/\/\/\/\/\/\/\~
./\/\/\/\/\/\/\/\/\/\/\/\/\x
x/\/\/\/\/\/\/\/\/\/\/\/\/\/\$
$/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\.
./\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\+
+/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\o
o/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\O
import java.awt.C
import java.awt.Graphics2D;
import java.awt.image.BufferedI
import java.io.F
import java.io.IOE
import java.util.*;
import javax.imageio.ImageIO;
public class ChristmasTree {
static class Point{
Point(int a,int b){x=a;y=b;}
double distance(Point o){
int dx=x-o.x;
int dy=y-o.y;
return Math.sqrt(dx*dx+dy*dy);
static BufferedI
static Random r=new Random();
public static void main(String[]args) throws IOException{
if(args.length==0){
siz=(new Scanner(System.in)).nextInt();
siz=Integer.parseInt(args[0]);
b=new BufferedImage(20*siz,30*siz,BufferedImage.TYPE_INT_RGB);
Graphics2D g=(Graphics2D)b.getGraphics();
g.setColor(new Color(140,70,20));
int h=b.getHeight();h*=0.4;
for(int i=(int)(0.4*b.getWidth());i&(int)(0.6*b.getWidth());i++){
if(r.nextDouble()&0.3){
g.drawLine(i,b.getHeight(),i+r.nextInt(2)-1,h);
for(int i=h;i&b.getHeight();i++){
if(r.nextDouble()&0.3){
g.drawLine((int)(0.4*b.getWidth()),i,(int)(0.6*b.getWidth()),i);
for(int i=0;i&i++){
g.setColor(new Color(r.nextInt(4),150+r.nextInt(15),20+r.nextInt(7)));
g.drawLine(b.getWidth()/2-(int)(b.getWidth()*0.42*i/siz),(int)(b.getHeight()*0.9)+r.nextInt(5)-2,b.getWidth()/2+(int)(b.getWidth()*0.42*i/siz),(int)(b.getHeight()*0.9)+r.nextInt(5)-2);
g.setColor(new Color(r.nextInt(4),150+r.nextInt(15),20+r.nextInt(7)));
g.drawLine(b.getWidth()/2-(int)(b.getWidth()*0.42*i/siz),(int)(b.getHeight()*0.9),b.getWidth()/2,(int)(b.getHeight()*(0.1+(.06*i)/siz)));
g.setColor(new Color(r.nextInt(4),150+r.nextInt(15),20+r.nextInt(7)));
g.drawLine(b.getWidth()/2+(int)(b.getWidth()*0.42*i/siz),(int)(b.getHeight()*0.9),b.getWidth()/2,(int)(b.getHeight()*(0.1+(.06*i)/siz)));
g.setColor(new Color(150,120,40));
g.fillOval((b.getWidth()-siz-2)/2,b.getHeight()/10,siz+2,siz+2);
g.setColor(new Color(250,240,80));
g.fillOval((b.getWidth()-siz)/2,b.getHeight()/10,siz,siz);
List&Color&c=Arrays.asList(new Color(0,255,0),new Color(255,0,0),new Color(130,0,100),new Color(0,0,200),new Color(110,0,200),new Color(200,205,210),new Color(0,240,255),new Color(255,100,0));
List&Point&pts=new ArrayList&&();
pts.add(new Point((b.getWidth()-siz)/2,b.getHeight()/10));
loop:for(int i=0;i&8+siz/4;i++){
int y=r.nextInt((8*b.getHeight())/11);
int x=1+(int)(b.getWidth()*0.35*y/((8*b.getHeight())/11));
x=r.nextInt(2*x)-x+b.getWidth()/2;
y+=b.getHeight()/8;
g.setColor(c.get(r.nextInt(c.size())));
Point p=new Point(x,y);
for(Point q:pts){
if(q.distance(p)&1+2*siz)
pts.add(p);
g.fillOval(x,y,siz,siz);
ImageIO.write(b,"png",new File("tree.png"));
Sample results:
7,82612752
With a dialect to display the symbols. To change the tree size, just change the parameter of make-tree.
make-tree: func [int /local tr] [
tr: copy []
length: (int * 2) + 3
repeat i int [
repeat j 3 [
ast: to-integer ((i * 2) - 1 + (j * 2) - 2)
sp: to-integer (length - ast) / 2
append/dup tr space sp
append/dup tr "*" ast
append tr lf
append/dup tr space (length - 1) / 2
append tr "|"
append tr lf
print make-tree 3
import sys
w = sys.stdout.write
def t(n,s):
for i in range(n):
for a in range(n-i):
for l in range(i&&1):
if i==n-1:
for o in range(s):
for i in range(n):
print("[]")
Ti-Basic 84
Asks for a size:
:Disp Str2+
Str1+"*":Disp "
"+Str1+"*-"+"||-*
":Disp Str1+"*--||-
-*":Disp "
-*":Disp "
*----||----
*":Disp Str1+"
":If S&0:Goto 2:Goto 1:Lbl
Output (size 1):
*---||---*
*----||----*
8,08212749
protected by
Thank you for your interest in this question.
Because it has attracted low-quality or spam answers that had to be removed, posting an answer now requires 10
on this site (the ).
Would you like to answer one of these
Not the answer you're looking for?
Browse other questions tagged
The week's top questions and answers
Important community announcements
Questions that need answers
rev .24741
Programming Puzzles & Code Golf Stack Exchange works best with JavaScript enabled