Add tasks for all the new languages

Task/Tree-traversal/Ceylon/tree-traversal.ceylon

@@ -0,0 +1,97 @@
+import ceylon.collection {
+	ArrayList
+}
+
+shared void run() {
+
+	class Node(label, left = null, right = null) {
+		shared Integer label;
+		shared Node? left;
+		shared Node? right;
+		string => label.string;
+	}
+	
+	void preorder(Node node) {
+		process.write(node.string + " ");
+		if(exists left = node.left) {
+			preorder(left);
+		}
+		if(exists right = node.right) {
+			preorder(right);
+		}
+	}
+	
+	void inorder(Node node) {
+		if(exists left = node.left) {
+			inorder(left);
+		}
+		process.write(node.string + " ");
+		if(exists right = node.right) {
+			inorder(right);
+		}
+	}
+	
+	void postorder(Node node) {
+		if(exists left = node.left) {
+			postorder(left);
+		}
+		if(exists right = node.right) {
+			postorder(right);
+		}
+		process.write(node.string + " ");
+	}
+	
+	void levelOrder(Node node) {
+		value nodes = ArrayList<Node> {node};
+		while(exists current = nodes.accept()) {
+			process.write(current.string + " ");
+			if(exists left = current.left) {
+				nodes.offer(left);
+			}
+			if(exists right = current.right) {
+				nodes.offer(right);
+			}
+		}
+	}
+
+	value tree = Node {
+		label = 1;
+		left = Node {
+			label = 2;
+			left = Node {
+				label = 4;
+				left = Node {
+					label = 7;
+				};
+			};
+			right = Node {
+				label = 5;
+			};
+		};
+		right = Node {
+			label = 3;
+			left = Node {
+				label = 6;
+				left = Node {
+					label = 8;
+				};
+				right = Node {
+					label = 9;
+				};
+			};
+		};
+	};
+	
+	process.write("preorder:   ");
+	preorder(tree);
+	print("");
+	process.write("inorder:    ");
+	inorder(tree);
+	print("");
+	process.write("postorder:  ");
+	postorder(tree);
+	print("");
+	process.write("levelorder: ");
+	levelOrder(tree);
+	print("");
+}

Task/Tree-traversal/FunL/tree-traversal.funl

@@ -0,0 +1,36 @@
+data Tree = Empty | Node( value, left, right )
+
+def
+  preorder( Empty )          =  []
+  preorder( Node(v, l, r) )  =  [v] + preorder( l ) + preorder( r )
+
+  inorder( Empty )           =  []
+  inorder( Node(v, l, r) )   =  inorder( l ) + [v] + inorder( r )
+
+  postorder( Empty )         =  []
+  postorder( Node(v, l, r) ) =  postorder( l ) + postorder( r ) + [v]
+
+  levelorder( x ) =
+    def
+      order( [] )                 =  []
+      order( Empty         : xs ) =  order( xs )
+      order( Node(v, l, r) : xs ) =  v : order( xs + [l, r] )
+
+    order( [x] )
+
+tree =    Node( 1,
+            Node( 2,
+              Node( 4,
+                Node( 7, Empty, Empty ),
+                Empty ),
+              Node( 5, Empty, Empty ) ),
+            Node( 3,
+              Node( 6,
+                Node( 8, Empty, Empty ),
+                Node( 9, Empty, Empty ) ),
+              Empty ) )
+
+println( preorder(tree) )
+println( inorder(tree) )
+println( postorder(tree) )
+println( levelorder(tree) )

Task/Tree-traversal/GFA-Basic/tree-traversal.gfa

@@ -0,0 +1,116 @@
+maxnodes%=100 ! set a limit to size of tree
+content%=0 ! index of content field
+left%=1 ! index of left tree
+right%=2 ! index of right tree
+DIM tree%(maxnodes%,3) ! create space for tree
+'
+OPENW 1
+CLEARW 1
+'
+@create_tree
+PRINT "Preorder:   ";
+@preorder_traversal(1)
+PRINT ""
+PRINT "Inorder:    ";
+@inorder_traversal(1)
+PRINT ""
+PRINT "Postorder:  ";
+@postorder_traversal(1)
+PRINT ""
+PRINT "Levelorder: ";
+@levelorder_traversal(1)
+PRINT ""
+'
+~INP(2)
+CLOSEW 1
+'
+' Define the example tree
+'
+PROCEDURE create_tree
+  tree%(1,content%)=1
+  tree%(1,left%)=2
+  tree%(1,right%)=3
+  tree%(2,content%)=2
+  tree%(2,left%)=4
+  tree%(2,right%)=5
+  tree%(3,content%)=3
+  tree%(3,left%)=6
+  tree%(3,right%)=0 ! 0 is used for no subtree
+  tree%(4,content%)=4
+  tree%(4,left%)=7
+  tree%(4,right%)=0
+  tree%(5,content%)=5
+  tree%(5,left%)=0
+  tree%(5,right%)=0
+  tree%(6,content%)=6
+  tree%(6,left%)=8
+  tree%(6,right%)=9
+  tree%(7,content%)=7
+  tree%(7,left%)=0
+  tree%(7,right%)=0
+  tree%(8,content%)=8
+  tree%(8,left%)=0
+  tree%(8,right%)=0
+  tree%(9,content%)=9
+  tree%(9,left%)=0
+  tree%(9,right%)=0
+RETURN
+'
+' Preorder traversal from given node
+'
+PROCEDURE preorder_traversal(node%)
+  IF node%<>0 ! 0 means there is no node
+    PRINT tree%(node%,content%);
+    preorder_traversal(tree%(node%,left%))
+    preorder_traversal(tree%(node%,right%))
+  ENDIF
+RETURN
+'
+' Postorder traversal from given node
+'
+PROCEDURE postorder_traversal(node%)
+  IF node%<>0 ! 0 means there is no node
+    postorder_traversal(tree%(node%,left%))
+    postorder_traversal(tree%(node%,right%))
+    PRINT tree%(node%,content%);
+  ENDIF
+RETURN
+'
+' Inorder traversal from given node
+'
+PROCEDURE inorder_traversal(node%)
+  IF node%<>0 ! 0 means there is no node
+    inorder_traversal(tree%(node%,left%))
+    PRINT tree%(node%,content%);
+    inorder_traversal(tree%(node%,right%))
+  ENDIF
+RETURN
+'
+' Level order traversal from given node
+'
+PROCEDURE levelorder_traversal(node%)
+  LOCAL nodes%,first_free%,current%
+  '
+  ' Set up initial queue of nodes
+  '
+  DIM nodes%(maxnodes%) ! some working space to store queue of nodes
+  current%=1
+  nodes%(current%)=node%
+  first_free%=current%+1
+  '
+  WHILE nodes%(current%)<>0
+    ' add the children of current node onto queue
+    IF tree%(nodes%(current%),left%)<>0
+      nodes%(first_free%)=tree%(nodes%(current%),left%)
+      first_free%=first_free%+1
+    ENDIF
+    IF tree%(nodes%(current%),right%)<>0
+      nodes%(first_free%)=tree%(nodes%(current%),right%)
+      first_free%=first_free%+1
+    ENDIF
+    ' print the current node content
+    PRINT tree%(nodes%(current%),content%);
+    ' advance to next node
+    current%=current%+1
+  WEND
+RETURN

Task/Tree-traversal/Lingo/tree-traversal-1.lingo

@@ -0,0 +1,28 @@
+-- parent script "BinaryTreeNode"
+
+property _val, _left, _right
+
+on new (me, val)
+  me._val = val
+  return me
+end
+
+on getValue (me)
+  return me._val
+end
+
+on setLeft (me, node)
+  me._left = node
+end
+
+on setRight (me, node)
+  me._right = node
+end
+
+on getLeft (me)
+  return me._left
+end
+
+on getRight (me)
+  return me._right
+end

Task/Tree-traversal/Lingo/tree-traversal-2.lingo

@@ -0,0 +1,51 @@
+-- parent script "BinaryTreeTraversal"
+
+on inOrder (me, node, l)
+  if voidP(l) then l = []
+  if voidP(node) then return l
+  if not voidP(node.getLeft()) then l = me.inOrder(node.getLeft(), l)
+  l.add(node)
+  if not voidP(node.getRight()) then l = me.inOrder(node.getRight(), l)
+  return l
+end
+
+on preOrder (me, node, l)
+  if voidP(l) then l = []
+  if voidP(node) then return l
+  l.add(node)
+  if not voidP(node.getLeft()) then l = me.preOrder(node.getLeft(), l)
+  if not voidP(node.getRight()) then l = me.preOrder(node.getRight(), l)
+  return l
+end
+
+on postOrder (me, node, l)
+  if voidP(l) then l = []
+  if voidP(node) then return l
+  if not voidP(node.getLeft()) then l = me.postOrder(node.getLeft(), l)
+  if not voidP(node.getRight()) then l = me.postOrder(node.getRight(), l)
+  l.add(node)
+  return l
+end
+
+on levelOrder (me, node)
+  l = []
+  queue = [node]
+  repeat while queue.count
+    node = queue[1]
+    queue.deleteAt(1)
+    l.add(node)
+    if not voidP(node.getLeft()) then queue.add(node.getLeft())
+    if not voidP(node.getRight()) then queue.add(node.getRight())
+  end repeat
+  return l
+end
+
+-- print utility function
+on serialize (me, l)
+  str = ""
+  repeat with node in l
+    put node.getValue()&" " after str
+  end repeat
+  delete the last char of str
+  return str
+end

Task/Tree-traversal/Lingo/tree-traversal-3.lingo

@@ -0,0 +1,20 @@
+-- create the tree
+l = []
+repeat with i = 1 to 10
+  l[i] = script("BinaryTreeNode").new(i)
+end repeat
+l[6].setLeft (l[8])
+l[6].setRight(l[9])
+l[3].setLeft (l[6])
+l[4].setLeft (l[7])
+l[2].setLeft (l[4])
+l[2].setRight(l[5])
+l[1].setLeft (l[2])
+l[1].setRight(l[3])
+
+-- print traversal results
+trav = script("BinaryTreeTraversal")
+put "preorder:    " & trav.serialize(trav.preOrder(l[1]))
+put "inorder:     " & trav.serialize(trav.inOrder(l[1]))
+put "postorder:   " & trav.serialize(trav.postOrder(l[1]))
+put "level-order: " & trav.serialize(trav.levelOrder(l[1]))

Task/Tree-traversal/Nim/tree-traversal.nim

@@ -0,0 +1,47 @@
+import queues, sequtils
+
+type
+  Node[T] = ref TNode[T]
+  TNode[T] = object
+    data: T
+    left, right: Node[T]
+
+proc newNode[T](data: T; left, right: Node[T] = nil): Node[T] =
+  Node[T](data: data, left: left, right: right)
+
+proc preorder[T](n: Node[T]): seq[T] =
+  if n == nil: @[]
+  else: @[n.data] & preorder(n.left) & preorder(n.right)
+
+proc inorder[T](n: Node[T]): seq[T] =
+  if n == nil: @[]
+  else: inorder(n.left) & @[n.data] & inorder(n.right)
+
+proc postorder[T](n: Node[T]): seq[T] =
+  if n == nil: @[]
+  else: postorder(n.left) & postorder(n.right) & @[n.data]
+
+proc levelorder[T](n: Node[T]): seq[T] =
+  result = @[]
+  var queue = initQueue[Node[T]]()
+  queue.enqueue(n)
+  while queue.len > 0:
+    let next = queue.dequeue()
+    result.add next.data
+    if next.left != nil: queue.enqueue(next.left)
+    if next.right != nil: queue.enqueue(next.right)
+
+let tree = 1.newNode(
+             2.newNode(
+               4.newNode(
+                 7.newNode),
+               5.newNode),
+             3.newNode(
+               6.newNode(
+                 8.newNode,
+                 9.newNode)))
+
+echo preorder tree
+echo inorder tree
+echo postorder tree
+echo levelorder tree

Task/Tree-traversal/Oforth/tree-traversal.oforth

@@ -0,0 +1,31 @@
+Object Class new: Tree(v, l, r)
+
+Tree method: initialize(v, l, r)  v := v l := l r := r ;
+Tree method: v   @v ;
+Tree method: l   @l ;
+Tree method: r   @r ;
+
+Tree method: preOrder(f)
+   @v f perform
+   @l ifNotNull: [ @l preOrder(f) ]
+   @r ifNotNull: [ @r preOrder(f) ] ;
+
+Tree method: inOrder(f)
+   @l ifNotNull: [ @l inOrder(f) ]
+   @v f perform
+   @r ifNotNull: [ @r inOrder(f) ] ;
+
+Tree method: postOrder(f)
+   @l ifNotNull: [ @l postOrder(f) ]
+   @r ifNotNull: [ @r postOrder(f) ]
+   @v f perform ;
+
+Tree method: levelOrder(f)
+| c n |
+   Channel new self over send drop ->c
+   while(c notEmpty) [
+      c receive ->n
+      n v f perform
+      n l dup ifNotNull: [ c send ] drop
+      n r dup ifNotNull: [ c send ] drop
+      ] ;

Task/Tree-traversal/Phix/tree-traversal.phix

@@ -0,0 +1,46 @@
+constant VALUE = 1, LEFT = 2, RIGHT = 3
+
+constant tree = {1, {2, {4, {7, 0, 0}, 0},
+                        {5, 0, 0}},
+                    {3, {6, {8, 0, 0},
+                            {9, 0, 0}},
+                        0}}
+
+procedure preorder(object tree)
+    if sequence(tree) then
+        printf(1,"%d ",{tree[VALUE]})
+        preorder(tree[LEFT])
+        preorder(tree[RIGHT])
+    end if
+end procedure
+
+procedure inorder(object tree)
+    if sequence(tree) then
+        inorder(tree[LEFT])
+        printf(1,"%d ",{tree[VALUE]})
+        inorder(tree[RIGHT])
+    end if
+end procedure
+
+procedure postorder(object tree)
+    if sequence(tree) then
+        postorder(tree[LEFT])
+        postorder(tree[RIGHT])
+        printf(1,"%d ",{tree[VALUE]})
+    end if
+end procedure
+
+procedure level_order(object tree, sequence more = {})
+    if sequence(tree) then
+        more &= {tree[LEFT],tree[RIGHT]}
+        printf(1,"%d ",{tree[VALUE]})
+    end if
+    if length(more) > 0 then
+        level_order(more[1],more[2..$])
+    end if
+end procedure
+
+puts(1,"\n preorder:    ")  preorder(tree)
+puts(1,"\n inorder:     ")  inorder(tree)
+puts(1,"\n postorder:   ")  postorder(tree)
+puts(1,"\n level-order: ")  level_order(tree)

Task/Tree-traversal/Sidef/tree-traversal.sidef

@@ -0,0 +1,28 @@
+func preorder(t) {
+    t ? [t[0], __FUNC__(t[1])..., __FUNC__(t[2])...] : [];
+}
+
+func inorder(t) {
+    t ? [__FUNC__(t[1])..., t[0], __FUNC__(t[2])...] : [];
+}
+
+func postorder(t) {
+    t ? [__FUNC__(t[1])..., __FUNC__(t[2])..., t[0]] : [];
+}
+
+func depth(t) {
+    var a = [t];
+    var ret = [];
+    while (a.len > 0) {
+        var v = (a.shift \\ next);
+        ret « v[0];
+        a += [v[1,2]];
+    };
+    return ret;
+}
+
+var x = [1,[2,[4,[7]],[5]],[3,[6,[8],[9]]]];
+say "pre:   #{preorder(x)}";
+say "in:    #{inorder(x)}";
+say "post:  #{postorder(x)}";
+say "depth: #{depth(x)}";

Task/Tree-traversal/jq/tree-traversal-1.jq

@@ -0,0 +1,26 @@
+def preorder:
+  if length == 0 then empty
+  else .[0], (.[1]|preorder), (.[2]|preorder)
+  end;
+
+def inorder:
+  if length == 0 then empty
+  else (.[1]|inorder), .[0] , (.[2]|inorder)
+  end;
+
+def postorder:
+  if length == 0 then empty
+  else (.[1] | postorder), (.[2]|postorder), .[0]
+  end;
+
+# Helper functions for levelorder:
+  # Produce a stream of the first elements
+  def heads: map( .[0] | select(. != null)) | .[];
+
+# Produce a stream of the left/right branches:
+  def tails:
+    if length == 0 then empty
+    else [map ( .[1], .[2] ) | .[] | select( . != null)]
+    end;
+
+def levelorder: [.] | recurse( tails ) | heads;

Task/Tree-traversal/jq/tree-traversal-2.jq

@@ -0,0 +1,17 @@
+def task:
+  # [node, left, right]
+  def atree: [1, [2, [4, [7,[],[]],
+                         []],
+                     [5, [],[]]],
+
+                 [3, [6, [8,[],[]],
+                         [9,[],[]]],
+                     []]] ;
+
+  "preorder:   \( [atree|preorder ])",
+  "inorder:    \( [atree|inorder  ])",
+  "postorder:  \( [atree|postorder ])",
+  "levelorder: \( [atree|levelorder])"
+;
+
+task