Tree from nesting levels: Difference between revisions

Added C#
(→‎Applescript :: functional: Added a functional draft in AppleScript)
(Added C#)
 
(38 intermediate revisions by 15 users not shown)
Line 1:
{{draft task}}
 
Given a flat list of integers greater than zero, representing object nesting
Line 34:
===Iterative===
 
<langsyntaxhighlight lang="applescript">on treeFromNestingLevels(input)
set maxLevel to 0
repeat with thisLevel in input
Line 80:
set output to output as text
set AppleScript's text item delimiters to astid
return output</langsyntaxhighlight>
 
{{output}}
<langsyntaxhighlight lang="applescript">"{} nests to: {}
{1, 2, 4} nests to: {1, {2, {{4}}}}
{3, 1, 3, 1} nests to: {{{3}}, 1, {{3}}, 1}
{1, 2, 3, 1} nests to: {1, {2, {3}}, 1}
{3, 2, 1, 3} nests to: {{{3}, 2}, 1, {{3}}}
{3, 3, 3, 1, 1, 3, 3, 3} nests to: {{{3, 3, 3}}, 1, 1, {{3, 3, 3}}}"</langsyntaxhighlight>
 
===Recursive===
 
Same task code and output as above.
<langsyntaxhighlight lang="applescript">on treeFromNestingLevels(input)
script recursion
property emptyList : {}
Line 119:
return recursion's recurse(input, 1)
end treeFromNestingLevels</langsyntaxhighlight>
 
 
===Functional===
Mapping from the sparse list format to a generic tree structure, and using both:
:# a generic forestFromNestedLevels''forestFromNestLevels'' function to map from a normalised input list to a generic tree, and
:# a standard catamorphism over trees (''foldTree'') to generate both the nested list format, and the round-trip regeneration of a sparse list from the generic tree.
<syntaxhighlight lang="applescript">----------------- FOREST FROM NEST LEVELS ----------------
<lang applescript>
----------------- FOREST FROM NEST LEVELS ----------------
 
-- forestFromNestLevels :: [(Int, a)] -> [Tree a]
Line 154 ⟶ 153:
 
 
-- nestedList :: Maybe Int -> Nest -> Nest
-- nestedListFromNodeAndList
on nestedList(maybeLevel, xs)
set subTree to concat(xs)
Line 193 ⟶ 192:
set returnTrip to foldTree(my levelList, tree)
map(my showList, {showList(ns), showList(bracketNest), showList(returnTrip})}
end |λ|
end script
Line 224 ⟶ 223:
 
-------------- FROM TREE BACK TO SPARSE LIST -------------
 
 
-- levelListFromNestedList :: Maybe a -> NestedList -> [a]
Line 311 ⟶ 309:
-- nest of oTree
end nest
 
 
-- root :: Tree a -> a
Line 582 ⟶ 581:
end repeat
v
end |until|</langsyntaxhighlight>
<pre>
INPUT -> NESTED -> ROUND-TRIP
Line 594 ⟶ 593:
=={{header|C++}}==
Uses C++20
<langsyntaxhighlight lang="cpp">#include <any>
#include <iostream>
#include <iterator>
Line 675 ⟶ 674:
}
}
</syntaxhighlight>
</lang>
 
{{out}}
Line 698 ⟶ 697:
</pre>
 
=={{header|C sharp|C#}}==
{{works with|C sharp|12}}
<syntaxhighlight lang="csharp">public static class TreeFromNestingLevels
{
public static void Main()
{
List<int[]> tests = [[], [1,2,4], [3,1,3,1], [1,2,3,1], [3,2,1,3], [3,3,3,1,1,3,3,3]];
Console.WriteLine($"{"Input",24} -> {"Nested",-32} -> Round-trip");
foreach (var test in tests) {
var tree = BuildTree(test);
string input = $"[{string.Join(", ", test)}]";
string roundTrip = $"[{string.Join(", ", tree.ToList())}]";
Console.WriteLine($"{input,24} -> {tree,-32} -> {roundTrip}");
}
}
 
private static Tree BuildTree(int[] levels)
{
Tree root = new(0);
Tree current = root;
foreach (int level in levels) {
while (current.Level > level) current = current.Parent;
current = current.Parent.Add(level);
}
return root;
}
 
private class Tree
{
public int Level { get; }
public Tree Parent { get; }
private readonly List<Tree> children = [];
 
public Tree(int level, Tree? parent = null)
{
Level = level;
Parent = parent ?? this;
}
 
public Tree Add(int level)
{
if (Level == level) return this;
Tree tree = new(Level + 1, this);
children.Add(tree);
return tree.Add(level);
}
 
public override string ToString() => children.Count == 0
? (Level == 0 ? "[]" : $"{Level}")
: $"[{string.Join(", ", children.Select(c => c.ToString()))}]";
 
public List<int> ToList()
{
List<int> list = [];
ToList(this, list);
return list;
}
 
private static void ToList(Tree tree, List<int> list)
{
if (tree.children.Count == 0) {
if (tree.Level > 0) list.Add(tree.Level);
} else {
foreach (Tree child in tree.children) {
ToList(child, list);
}
}
}
 
}
 
}</syntaxhighlight>
{{out}}
<pre>
Input -> Nested -> Round-trip
[] -> [] -> []
[1, 2, 4] -> [1, [2, [[4]]]] -> [1, 2, 4]
[3, 1, 3, 1] -> [[[3]], 1, [[3]], 1] -> [3, 1, 3, 1]
[1, 2, 3, 1] -> [1, [2, [3]], 1] -> [1, 2, 3, 1]
[3, 2, 1, 3] -> [[[3], 2], 1, [[3]]] -> [3, 2, 1, 3]
[3, 3, 3, 1, 1, 3, 3, 3] -> [[[3, 3, 3]], 1, 1, [[3, 3, 3]]] -> [3, 3, 3, 1, 1, 3, 3, 3]</pre>
 
=={{header|Delphi}}==
{{works with|Delphi|6.0}}
{{libheader|SysUtils,StdCtrls}}
 
 
<syntaxhighlight lang="Delphi">
 
 
const TreeData1: array [0..0] of integer = (0);
const TreeData2: array [0..2] of integer = (1, 2, 4);
const TreeData3: array [0..3] of integer = (3, 1, 3, 1);
const TreeData4: array [0..3] of integer = (1, 2, 3, 1);
const TreeData5: array [0..3] of integer = (3, 2, 1, 3);
const TreeData6: array [0..7] of integer = (3, 3, 3, 1, 1, 3, 3, 3);
 
 
function GetDataString(Data: array of integer): string;
var I: integer;
begin
Result:='[';
for I:=0 to High(Data) do
begin
if I<>0 then Result:=Result+', ';
Result:=Result+IntToStr(Data[I]);
end;
Result:=Result+']';
end;
 
 
function GetNestingLevel(Data: array of integer): string;
var Level,Level2: integer;
var I,J,HLen: integer;
begin
Level:=0;
Result:='';
for I:=0 to High(Data) do
begin
Level2:=Data[I];
if Level2>Level then for J:=Level to Level2-1 do Result:=Result+'['
else if Level2<Level then
begin
for J:=Level-1 downto Level2 do Result:=Result+']';
Result:=Result+', ';
end
else if Level2=0 then
begin
Result:='[]';
break;
end
else Result:=Result+', ';
Result:=Result+IntToStr(Level2);
Level:=Level2;
if (I<High(Data)) and (Level<Data[I+1]) then Result:=Result+', ';
end;
for J:=Level downto 1 do Result:=Result+']';
end;
 
 
procedure ShowNestData(Memo: TMemo; Data: array of integer);
begin
Memo.Lines.Add(GetDataString(Data)+' Nests to: ');
Memo.Lines.Add(GetNestingLevel(Data));
Memo.Lines.Add('');
end;
 
procedure ShowNestingLevels(Memo: TMemo);
var S: string;
begin
ShowNestData(Memo,TreeData1);
ShowNestData(Memo,TreeData2);
ShowNestData(Memo,TreeData3);
ShowNestData(Memo,TreeData4);
ShowNestData(Memo,TreeData5);
ShowNestData(Memo,TreeData6);
end;
 
 
 
</syntaxhighlight>
{{out}}
<pre>
[0] Nests to:
[]
 
[1, 2, 4] Nests to:
[1, [2, [[4]]]]
 
[3, 1, 3, 1] Nests to:
[[[3]], 1, [[3]], 1]
 
[1, 2, 3, 1] Nests to:
[1, [2, [3]], 1]
 
[3, 2, 1, 3] Nests to:
[[[3], 2], 1, [[3]]]
 
[3, 3, 3, 1, 1, 3, 3, 3] Nests to:
[[[3, 3, 3]], 1, 1, [[3, 3, 3]]]
 
 
Elapsed Time: 21.513 ms.
 
</pre>
 
=={{header|Fōrmulæ}}==
 
{{FormulaeEntry|page=https://formulae.org/?script=examples/Tree_from_nesting_levels}}
 
'''Solution'''
 
[[File:Fōrmulæ - Tree from nesting levels 01.png]]
 
'''Test cases'''
 
[[File:Fōrmulæ - Tree from nesting levels 02.png]]
 
[[File:Fōrmulæ - Tree from nesting levels 03.png]]
 
Notice that in Fōrmulæ an array of arrays (of the same cardinality each) is automatically shown as a matrix.
 
[[File:Fōrmulæ - Tree from nesting levels 04.png]]
 
[[File:Fōrmulæ - Tree from nesting levels 05.png]]
 
[[File:Fōrmulæ - Tree from nesting levels 06.png]]
 
[[File:Fōrmulæ - Tree from nesting levels 07.png]]
 
[[File:Fōrmulæ - Tree from nesting levels 08.png]]
 
[[File:Fōrmulæ - Tree from nesting levels 09.png]]
 
[[File:Fōrmulæ - Tree from nesting levels 10.png]]
 
[[File:Fōrmulæ - Tree from nesting levels 11.png]]
 
[[File:Fōrmulæ - Tree from nesting levels 12.png]]
 
[[File:Fōrmulæ - Tree from nesting levels 13.png]]
 
'''Other test cases'''
 
Cases generated with random numbers:
 
[[File:Fōrmulæ - Tree from nesting levels 14.png]]
 
[[File:Fōrmulæ - Tree from nesting levels 15.png]]
 
=={{header|FreeBASIC}}==
<syntaxhighlight lang="vb">Sub ShowTree(List() As Integer)
Dim As Integer I, NestLevel = 0
For I = 0 To Ubound(List)
While List(I) < NestLevel
Print "]";
NestLevel -= 1
Wend
If List(I) = 0 Then
Print
Elseif I <> Lbound(List) Then Print ", ";
End If
While List(I) > NestLevel
Print "[";
NestLevel += 1
Wend
If NestLevel <> 0 Then Print NestLevel;
Next I
End Sub
 
Dim As Integer list(0 To ...) = {0}
ShowTree(list())
Dim As Integer list0(0 To ...) = {1, 2, 4, 0}
ShowTree(list0())
Dim As Integer list1(0 To ...) = {3, 1, 3, 1, 0}
ShowTree(list1())
Dim As Integer list2(0 To ...) = {1, 2, 3, 1, 0}
ShowTree(list2())
Dim As Integer list3(0 To ...) = {3, 2, 1, 3, 0}
ShowTree(list3())
Dim As Integer list4(0 To ...) = {3, 3, 3, 1, 1, 3, 3, 3, 0}
ShowTree(list4())
Dim As Integer list5(0 To ...) = {1, 2, 4, 2, 2, 1, 0}
ShowTree(list5())
 
Sleep</syntaxhighlight>
{{out}}
<pre> 'Note that [0] displays nothing.
[ 1, [ 2, [[ 4]]]]
[[[ 3]], 1, [[ 3]], 1]
[ 1, [ 2, [ 3]], 1]
[[[ 3], 2], 1, [[ 3]]]
[[[ 3, 3, 3]], 1, 1, [[ 3, 3, 3]]]
[ 1, [ 2, [[ 4]], 2, 2], 1]</pre>
 
=={{header|Go}}==
===Iterative===
{{trans|Python}}
<langsyntaxhighlight lang="go">package main
 
import "fmt"
Line 742 ⟶ 1,015:
fmt.Printf("%17s => %v\n", fmt.Sprintf("%v", test), nest)
}
}</langsyntaxhighlight>
 
{{out}}
Line 756 ⟶ 1,029:
===Recursive===
{{trans|Python}}
<langsyntaxhighlight lang="go">package main
 
import "fmt"
Line 797 ⟶ 1,070:
fmt.Printf("%17s => %v\n", fmt.Sprintf("%v", test), nest)
}
}</langsyntaxhighlight>
 
{{out}}
<pre>
Same as iterative version.
</pre>
 
=={{header|Guile}}==
<syntaxhighlight lang="scheme">;; helper function that finds the rest that are less than or equal
(define (rest-less-eq x ls)
(cond
((null? ls) #f)
((<= (car ls) x) ls)
(else (rest-less-eq x (cdr ls)))))
 
;; nest the input as a tree
(define (make-tree input depth)
(cond
((null? input) '())
((eq? input #f ) '())
((= depth (car input))
(cons (car input)(make-tree(cdr input) depth)))
((< depth (car input))
(cons (make-tree input (+ depth 1))
(make-tree (rest-less-eq depth input) depth)))
(#t '())
))
 
(define examples
'(()
(1 2 4)
(3 1 3 1)
(1 2 3 1)
(3 2 1 3)
(3 3 3 1 1 3 3 3)))
 
(define (run-examples x)
(if (null? x) '()
(begin
(display (car x))(display " -> ")
(display (make-tree(car x) 1))(display "\n")
(run-examples (cdr x)))))
 
(run-examples examples)
</syntaxhighlight>
{{out}}
<pre>
() -> ()
(1 2 4) -> (1 (2 ((4))))
(3 1 3 1) -> (((3)) 1 ((3)) 1)
(1 2 3 1) -> (1 (2 (3)) 1)
(3 2 1 3) -> (((3) 2) 1 ((3)))
(3 3 3 1 1 3 3 3) -> (((3 3 3)) 1 1 ((3 3 3)))
</pre>
 
Line 817 ⟶ 1,138:
See ''sparseLevelsFromTree'' below:
 
<langsyntaxhighlight lang="haskell">{-# LANGUAGE TupleSections #-}
 
import Data.Bifunctor (bimap)
Line 885 ⟶ 1,206:
(x, Just x) :
(succ x, Nothing) : normalised (y : xs)
| otherwise = (x, Just x) : normalised (y : xs)</langsyntaxhighlight>
{{Out}}
<pre>From: []
Line 987 ⟶ 1,308:
 
Back to: [3,3,3,1,1,3,3,3]</pre>
 
=={{header|J}}==
 
Without any use cases for these trees, it's difficult to know if any implementation is correct.
 
As a side note here, the notation used to describe these trees has some interesting consequences in the context of J:
 
<syntaxhighlight lang="j"> [[[3]], 1, [[3]], 1
1 1
[[[3]], 1, [[3]], 1]
|syntax error</syntaxhighlight>
 
But, on a related note, there are type issues to consider -- in J's type system, a box (which is what we would use here to represent a tree node) cannot exist in a tuple with an integer. A box can, however, contain an integer. This makes a literal interpretation of the task somewhat... difficult. We might, hypothetically, say that we are working with boxes containing integers and that it's these boxes which must achieve a specific nesting level. (If we fail to make this distinction then we wind up with a constraint which forces some tree nodes to be structured different from what appears to be the task specification. Whether or not this is an important issue is difficult to determine without use cases. So, for now, let's assume that this is an important distinction.)
 
Anyways, here's an interpretation which might be close enough to the task description:
 
<syntaxhighlight lang="j">NB. first we nest each integer to the required depth, independently
NB. then we recursively merge deep boxes
NB. for consistency, if there are no integers, we box that empty list
dtree=: {{
<^:(0=L.) merge <^:]each y
}}
 
merge=: {{
if.(0=#$y)+.2>L.y do.y return.end. NB. done if no deep boxes left
shallow=. 2 > L."0 y NB. locate shallow boxes
group=. shallow} (+/\ shallow),:-#\y NB. find groups of adjacent deep boxes
merge each group ,each//. y NB. combine them and recursively merge their contents
}}</syntaxhighlight>
 
Task example:
 
<syntaxhighlight lang="j"> dtree ''
┌┐
││
└┘
dtree 1 2 4
┌─────────────┐
│┌─┬─────────┐│
││1│┌─┬─────┐││
││ ││2│┌───┐│││
││ ││ ││┌─┐││││
││ ││ │││4│││││
││ ││ ││└─┘││││
││ ││ │└───┘│││
││ │└─┴─────┘││
│└─┴─────────┘│
└─────────────┘
dtree 3 1 3 1
┌─────────────────┐
│┌─────┬─┬─────┬─┐│
││┌───┐│1│┌───┐│1││
│││┌─┐││ ││┌─┐││ ││
││││3│││ │││3│││ ││
│││└─┘││ ││└─┘││ ││
││└───┘│ │└───┘│ ││
│└─────┴─┴─────┴─┘│
└─────────────────┘
dtree 1 2 3 1
┌─────────────┐
│┌─┬───────┬─┐│
││1│┌─┬───┐│1││
││ ││2│┌─┐││ ││
││ ││ ││3│││ ││
││ ││ │└─┘││ ││
││ │└─┴───┘│ ││
│└─┴───────┴─┘│
└─────────────┘
dtree 3 2 1 3
┌─────────────────┐
│┌───────┬─┬─────┐│
││┌───┬─┐│1│┌───┐││
│││┌─┐│2││ ││┌─┐│││
││││3││ ││ │││3││││
│││└─┘│ ││ ││└─┘│││
││└───┴─┘│ │└───┘││
│└───────┴─┴─────┘│
└─────────────────┘
dtree 3 3 3 1 1 3 3 3
┌─────────────────────────┐
│┌─────────┬─┬─┬─────────┐│
││┌───────┐│1│1│┌───────┐││
│││┌─┬─┬─┐││ │ ││┌─┬─┬─┐│││
││││3│3│3│││ │ │││3│3│3││││
│││└─┴─┴─┘││ │ ││└─┴─┴─┘│││
││└───────┘│ │ │└───────┘││
│└─────────┴─┴─┴─────────┘│
└─────────────────────────┘</syntaxhighlight>
 
Note that merge does not concern itself with the contents of boxes, only their nesting depth. This means that we could replace the implementation of dtree with some similar mechanism if we wished to use this approach with something else. For example:
 
<syntaxhighlight lang="j"> t=: ;:'(a b c) d (e f g)'
p=: ;:'()'
d=: +/\-/p=/t
k=: =/p=/t
merge d <@]^:[&.>&(k&#) t
┌───────┬─┬───────┐
│┌─┬─┬─┐│d│┌─┬─┬─┐│
││a│b│c││ ││e│f│g││
│└─┴─┴─┘│ │└─┴─┴─┘│
└───────┴─┴───────┘</syntaxhighlight>
 
Or, generalizing:
 
<syntaxhighlight lang="j">pnest=: {{
t=. ;:y NB. tokens
p=. (;:'()')=/t NB. paren token matches
d=: +/\-/p NB. paren token depths
k=: =/p NB. keep non-paren tokens
merge d <@]^:[&.>&(k&#) t NB. exercise task
}}</syntaxhighlight>
 
Example use:
 
<syntaxhighlight lang="j"> pnest '((a b) c (d e) f) g (h i)'
┌─────────────────┬─┬─────┐
│┌─────┬─┬─────┬─┐│g│┌─┬─┐│
││┌─┬─┐│c│┌─┬─┐│f││ ││h│i││
│││a│b││ ││d│e││ ││ │└─┴─┘│
││└─┴─┘│ │└─┴─┘│ ││ │ │
│└─────┴─┴─────┴─┘│ │ │
└─────────────────┴─┴─────┘</syntaxhighlight>
 
=={{header|Java}}==
 
<syntaxhighlight lang="java">
 
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
 
public final class TreeNestingLevels {
 
public static void main(String[] args) {
List<List<Integer>> lists = List.of(
Arrays.asList(),
Arrays.asList( 1, 2, 4 ),
Arrays.asList( 3, 1, 3, 1 ),
Arrays.asList( 1, 2, 3, 1 ),
Arrays.asList( 3, 2, 1, 3 ),
Arrays.asList( 3, 3, 3, 1, 1, 3, 3, 3 )
);
for ( List<Integer> list : lists ) {
List<Object> tree = createTree(list);
System.out.println(list + " --> " + tree);
}
}
private static List<Object> createTree(List<Integer> list) {
return makeTree(list, 0, 1);
}
private static List<Object> makeTree(List<Integer> list, int index, int depth) {
List<Object> tree = new ArrayList<Object>();
int current;
while ( index < list.size() && depth <= ( current = list.get(index) ) ) {
if ( depth == current ) {
tree.add(current);
index += 1;
} else {
tree.add(makeTree(list, index, depth + 1));
final int position = list.subList(index, list.size()).indexOf(depth);
index += ( position == -1 ) ? list.size() : position;
}
}
return tree;
}
}
</syntaxhighlight>
{{ out }}
<pre>
[] --> []
[1, 2, 4] --> [1, [2, [[4]]]]
[3, 1, 3, 1] --> [[[3]], 1, [[3]], 1]
[1, 2, 3, 1] --> [1, [2, [3]], 1]
[3, 2, 1, 3] --> [[[3], 2], 1, [[3]]]
[3, 3, 3, 1, 1, 3, 3, 3] --> [[[3, 3, 3]], 1, 1, [[3, 3, 3]]]
</pre>
 
=={{header|Julia}}==
<langsyntaxhighlight lang="julia">function makenested(list)
nesting = 0
str = isempty(list) ? "[]" : ""
Line 1,011 ⟶ 1,514:
end
 
</langsyntaxhighlight>{{out}}
<pre>
[] => []
Line 1,020 ⟶ 1,523:
[3, 3, 3, 1, 1, 3, 3, 3] => [[[3, 3, 3]], 1, 1, [[3, 3, 3]]]
</pre>
 
=={{header|Nim}}==
In a strongly and statically typed language as Nim, there is no way to mix integer values and lists. So, we have defined a variant type <code>Node</code> able to contain either an integer value or a list of Node objects, depending on the value of a discriminator. The procedure <code>newTree</code> converts a list of levels into a list of nodes with the appropriate nesting.
 
<syntaxhighlight lang="nim">import sequtils, strutils
 
type
Kind = enum kValue, kList
Node = ref object
case kind: Kind
of kValue: value: int
of kList: list: seq[Node]
 
 
proc newTree(s: varargs[int]): Node =
## Build a tree from a list of level values.
var level = 1
result = Node(kind: kList)
var stack = @[result]
for n in s:
if n <= 0:
raise newException(ValueError, "expected a positive integer, got " & $n)
let node = Node(kind: kValue, value: n)
if n < level:
# Unstack lists.
stack.setLen(n)
level = n
else:
while n > level:
# Create intermediate lists.
let newList = Node(kind: kList)
stack[^1].list.add newList
stack.add newList
inc level
# Add value.
stack[^1].list.add node
 
 
proc `$`(node: Node): string =
## Display a tree using a nested lists representation.
if node.kind == kValue: $node.value
else: '[' & node.list.mapIt($it).join(", ") & ']'
 
 
for list in [newSeq[int](), # Empty list (== @[]).
@[1, 2, 4],
@[3, 1, 3, 1],
@[1, 2, 3, 1],
@[3, 2, 1, 3],
@[3, 3, 3, 1, 1, 3, 3, 3]]:
echo ($list).align(25), " → ", newTree(list)</syntaxhighlight>
 
{{out}}
<pre> @[] → []
@[1, 2, 4] → [1, [2, [[4]]]]
@[3, 1, 3, 1] → [[[3]], 1, [[3]], 1]
@[1, 2, 3, 1] → [1, [2, [3]], 1]
@[3, 2, 1, 3] → [[[3], 2], 1, [[3]]]
@[3, 3, 3, 1, 1, 3, 3, 3] → [[[3, 3, 3]], 1, 1, [[3, 3, 3]]]</pre>
 
=={{header|OxygenBasic}}==
 
<syntaxhighlight lang="text">
uses console
declare DemoTree(string src)
DemoTree "[]"
DemoTree "[1, 2, 4]"
DemoTree "[3, 1, 3, 1]"
DemoTree "[1, 2, 3, 1]"
DemoTree "[3, 2, 1, 3]"
DemoTree "[3, 3, 3, 1, 1, 3, 3, 3]"
pause
end
 
/*
RESULTS:
========
 
[]
[]
 
[1, 2, 4]
[ 1,[ 2,[[ 4]]]]
 
[3, 1, 3, 1]
[[[ 3]], 1,[[ 3]], 1]
 
[1, 2, 3, 1]
[ 1,[ 2,[ 3]], 1]
 
[3, 2, 1, 3]
[[[ 3], 2], 1,[[ 3]]]
 
[3, 3, 3, 1, 1, 3, 3, 3]
[[[ 3, 3, 3]], 1, 1,[[ 3, 3, 3]]]
*/
 
 
 
sub DemoTree(string src)
========================
 
string tree=nuls 1000 'TREE OUTPUT
int i=1 'src char iterator
int j=1 'tree char iterator
byte bs at strptr src 'src bytes
byte bt at strptr tree 'tree bytes
int bl=len src 'end of src
int lvl 'current tree level
int olv 'prior tree level
int v 'number value
string vs 'number in string form
 
do
exit if i>bl
select bs[i]
case 91 '['
i++
case 93 ']'
if i=bl
gosub writex
endif
i++
case 44 ','
i++
gosub writex
case 0 to 32 'white space
i++
'bt[j]=" " : j++
case 48 to 57 '0..9'
gosub ReadDigits
case else
i++
end select
loop
tree=left(tree,j-1)
output src cr
output tree cr cr
exit sub
 
'SUBROUTINES OF DEMOTREE:
=========================
 
writex:
=======
olv=lvl
if i>=bl
if v=0 and olv=0
tree="[]" : j=3
ret
endif
endif
if v<olv
gosub WriteRbr
endif
if olv
gosub WriteComma
endif
if v>olv
gosub WriteLbr
endif
gosub WriteDigits '3]]'
if i>=bl
v=0
gosub WriteRbr
endif
ret
 
ReadDigits:
===========
v=0
while i<=bl
select bs[i]
case 48 to 57 '1..9
v*=10 : v+=bs[i]-48 'digit
case else
exit while
end select
i++
wend
ret
'
WriteDigits:
============
vs=" "+str(v) : mid(tree,j,vs) : j+=len vs
ret
 
WriteLbr:
=========
while v>lvl
bt[j]=91 : j++ : lvl++
wend
ret
 
WriteRbr:
=========
while v<lvl
bt[j]=93 : j++ : lvl--
wend
ret
 
WriteComma:
===========
bt[j]=44 : j++ ','
ret
 
end sub
</syntaxhighlight>
 
=={{header|Perl}}==
===String Eval===
<langsyntaxhighlight lang="perl">#!/usr/bin/perl
 
use strict;
Line 1,046 ⟶ 1,757:
my $after = eval;
dd { after => $after };
}</langsyntaxhighlight>
{{out}}
<pre>
Line 1,064 ⟶ 1,775:
===Iterative===
{{trans|Raku}}
<langsyntaxhighlight lang="perl">use 5.020_000; # Also turns on `strict`
use warnings;
use experimental qw<signatures>;
Line 1,087 ⟶ 1,798:
}
my @tests = ([],[1,2,4],[3,1,3,1],[1,2,3,1],[3,2,1,3],[3,3,3,1,1,3,3,3]);
say sprintf('%15s => ', join(' ', @{$_})), pp(to_tree_iterative(@{$_})) for @tests;</langsyntaxhighlight>
{{out}}
<pre>
Line 1,100 ⟶ 1,811:
=={{header|Phix}}==
I was thinking along the same lines but admit I had a little peek at the (recursive) python solution..
<!--<syntaxhighlight lang="phix">-->
<lang Phix>function test(sequence s, integer level=1, idx=1)
<span style="color: #008080;">function</span> <span style="color: #000000;">test</span><span style="color: #0000FF;">(</span><span style="color: #004080;">sequence</span> <span style="color: #000000;">s</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">integer</span> <span style="color: #000000;">level</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">idx</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span><span style="color: #0000FF;">)</span>
sequence res = {}, part
<span style="color: #004080;">sequence</span> <span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{},</span> <span style="color: #000000;">part</span>
while idx<=length(s) do
<span style="color: #008080;">while</span> <span style="color: #000000;">idx</span><span style="color: #0000FF;"><=</span><span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">do</span>
switch compare(s[idx],level) do
<span style="color: #008080;">switch</span> <span style="color: #7060A8;">compare</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">[</span><span style="color: #000000;">idx</span><span style="color: #0000FF;">],</span><span style="color: #000000;">level</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">do</span>
case +1: {idx,part} = test(s,level+1,idx)
<span style="color: #008080;">case</span> <span style="color: #0000FF;">+</span><span style="color: #000000;">1</span><span style="color: #0000FF;">:</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">idx</span><span style="color: #0000FF;">,</span><span style="color: #000000;">part</span><span style="color: #0000FF;">}</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">test</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">,</span><span style="color: #000000;">level</span><span style="color: #0000FF;">+</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">idx</span><span style="color: #0000FF;">)</span>
res = append(res,part)
<span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">append</span><span style="color: #0000FF;">(</span><span style="color: #000000;">res</span><span style="color: #0000FF;">,</span><span style="color: #000000;">part</span><span style="color: #0000FF;">)</span>
case 0: res &= s[idx]
<span style="color: #008080;">case</span> <span style="color: #000000;">0</span><span style="color: #0000FF;">:</span> <span style="color: #000000;">res</span> <span style="color: #0000FF;">&=</span> <span style="color: #000000;">s</span><span style="color: #0000FF;">[</span><span style="color: #000000;">idx</span><span style="color: #0000FF;">]</span>
case -1: idx -= 1 exit
<span style="color: #008080;">case</span> <span style="color: #0000FF;">-</span><span style="color: #000000;">1</span><span style="color: #0000FF;">:</span> <span style="color: #000000;">idx</span> <span style="color: #0000FF;">-=</span> <span style="color: #000000;">1</span> <span style="color: #008080;">exit</span>
end switch
<span style="color: #008080;">end</span> <span style="color: #008080;">switch</span>
idx += 1
<span style="color: #000000;">idx</span> <span style="color: #0000FF;">+=</span> <span style="color: #000000;">1</span>
end while
<span style="color: #008080;">end</span> <span style="color: #008080;">while</span>
return iff(level=1?res:{idx,res})
<span style="color: #008080;">return</span> <span style="color: #008080;">iff</span><span style="color: #0000FF;">(</span><span style="color: #000000;">level</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span><span style="color: #0000FF;">?</span><span style="color: #000000;">res</span><span style="color: #0000FF;">:{</span><span style="color: #000000;">idx</span><span style="color: #0000FF;">,</span><span style="color: #000000;">res</span><span style="color: #0000FF;">})</span>
end function
<span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
 
constant tests = {{},
<span style="color: #008080;">constant</span> <span style="color: #000000;">tests</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{{},</span>
{1, 2, 4},
<span style="color: #0000FF;">{</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">2</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">4</span><span style="color: #0000FF;">},</span>
-- {1, 2, 4, 2, 2, 1}, -- (fine too)
<span style="color: #000080;font-style:italic;">-- {31, 12, 34, 2, 2, 1}, -- (fine too)</span>
<span style="color: #0000FF;">{</span><span style="color: #000000;">3</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">1</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">3</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">1</span><span style="color: #0000FF;">},</span>
{1, 2, 3, 1},
<span style="color: #0000FF;">{</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">2</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">3</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">1</span><span style="color: #0000FF;">},</span>
{3, 2, 1, 3},
<span style="color: #0000FF;">{</span><span style="color: #000000;">3</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">2</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">1</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">3</span><span style="color: #0000FF;">},</span>
{3, 3, 3, 1, 1, 3, 3, 3}}
<span style="color: #0000FF;">{</span><span style="color: #000000;">3</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">3</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">3</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">1</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">1</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">3</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">3</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">3</span><span style="color: #0000FF;">}}</span>
 
for i=1 to length(tests) do
<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">tests</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">do</span>
sequence ti = tests[i],
<span style="color: #004080;">sequence</span> <span style="color: #000000;">ti</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">tests</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">],</span>
res = test(ti),
<span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">test</span><span style="color: #0000FF;">(</span><span style="color: #000000;">ti</span><span style="color: #0000FF;">),</span>
rpp = ppf(res,{pp_Nest,3,pp_Indent,4})
<span style="color: #000000;">rpp</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">ppf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">res</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">pp_Nest</span><span style="color: #0000FF;">,</span><span style="color: #000000;">3</span><span style="color: #0000FF;">,</span><span style="color: #000000;">pp_Indent</span><span style="color: #0000FF;">,</span><span style="color: #000000;">4</span><span style="color: #0000FF;">})</span>
printf(1,"%v nests to %v\n or %s\n",{ti,res,rpp})
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%v nests to %v\n or %s\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">ti</span><span style="color: #0000FF;">,</span><span style="color: #000000;">res</span><span style="color: #0000FF;">,</span><span style="color: #000000;">rpp</span><span style="color: #0000FF;">})</span>
end for</lang>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<!--</syntaxhighlight>-->
{{out}}
<pre>
Line 1,167 ⟶ 1,880:
</pre>
=== iterative ===
<!--<syntaxhighlight lang="phix">-->
<lang Phix>function nest(sequence input)
<span style="color: #008080;">function</span> <span style="color: #000000;">nest</span><span style="color: #0000FF;">(</span><span style="color: #004080;">sequence</span> <span style="color: #000000;">input</span><span style="color: #0000FF;">)</span>
if length(input) then
<span style="color: #008080;">if</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">input</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">then</span>
for level=max(input) to 2 by -1 do
<span style="color: #008080;">for</span> <span style="color: #000000;">level</span><span style="color: #0000FF;">=</span><span style="color: #7060A8;">max</span><span style="color: #0000FF;">(</span><span style="color: #000000;">input</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">to</span> <span style="color: #000000;">2</span> <span style="color: #008080;">by</span> <span style="color: #0000FF;">-</span><span style="color: #000000;">1</span> <span style="color: #008080;">do</span>
sequence output = {}
<span style="color: #004080;">sequence</span> <span style="color: #000000;">output</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{}</span>
bool subnest = false
<span style="color: #004080;">bool</span> <span style="color: #000000;">subnest</span> <span style="color: #0000FF;">=</span> <span style="color: #004600;">false</span>
for i=1 to length(input) do
<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">input</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">do</span>
object ii = input[i]
<span style="color: #004080;">object</span> <span style="color: #000000;">ii</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">input</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">]</span>
if integer(ii) and ii<level then
<span style="color: #008080;">if</span> <span style="color: #004080;">integer</span><span style="color: #0000FF;">(</span><span style="color: #000000;">ii</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">and</span> <span style="color: #000000;">ii</span><span style="color: #0000FF;"><</span><span style="color: #000000;">level</span> <span style="color: #008080;">then</span>
subnest = false
<span style="color: #000000;">subnest</span> <span style="color: #0000FF;">=</span> <span style="color: #004600;">false</span>
output &= ii
<span style="color: #000000;">output</span> <span style="color: #0000FF;">&=</span> <span style="color: #000000;">ii</span>
elsif not subnest then
<span style="color: #008080;">elsif</span> <span style="color: #008080;">not</span> <span style="color: #000000;">subnest</span> <span style="color: #008080;">then</span>
output &= {{ii}}
<span style="color: #000000;">output</span> <span style="color: #0000FF;">&=</span> <span style="color: #0000FF;">{{</span><span style="color: #000000;">ii</span><span style="color: #0000FF;">}}</span>
subnest = true
<span style="color: #000000;">subnest</span> <span style="color: #0000FF;">=</span> <span style="color: #004600;">true</span>
else
<span output[$] &style="color: {ii}#008080;">else</span>
<span style="color: #000000;">output</span><span style="color: #0000FF;">[$]</span> <span style="color: #0000FF;">&=</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">ii</span><span style="color: #0000FF;">}</span>
end if
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
end for
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
input = output
<span style="color: #000000;">input</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">output</span>
end for
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
end if
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
return input
<span style="color: #008080;">return</span> <span style="color: #000000;">input</span>
end function</lang>
<span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
<!--</syntaxhighlight>-->
Same output (using nest instead of test)
 
Line 1,195 ⟶ 1,910:
===Python: Procedural===
====Python: Recursive====
<langsyntaxhighlight lang="python">def to_tree(x, index=0, depth=1):
so_far = []
while index < len(x):
Line 1,229 ⟶ 1,944:
nest = to_tree(flat)
print(f"{flat} NESTS TO: {nest}")
pnest(nest)</langsyntaxhighlight>
 
{{out}}
Line 1,269 ⟶ 1,984:
 
====Python: Iterative====
<langsyntaxhighlight lang="python">def to_tree(x: list) -> list:
nested = []
stack = [nested]
Line 1,283 ⟶ 1,998:
 
return nested
</syntaxhighlight>
</lang>
 
{{out}}
Line 1,291 ⟶ 2,006:
A translation of the sparse level-lists to a stricter generic data structure
gives us access to standard tree-walking functions,
 
allowing for simpler top-level functions, and higher levels of code reuse.
 
Here, for example, we apply:
# a generic tree-drawing (''drawTree'') function, and
# for the return trip from tree to list, a generic catamorphism over trees (''foldTree''). for:
: the generation of a bracket-nest from an underlying tree, and
: a return-trip regeneration of the sparse level list from the same tree.
 
Each node in the underlying tree structure is a tuple of a value (None or an integer),
and list of child nodes:
 
<pre>Node (None|Int) :: ((None|Int), [Node])</pre>
<lang python>'''Tree from nesting levels'''
<syntaxhighlight lang="python">'''Tree from nesting levels'''
 
from itertools import chain, repeat
Line 1,308 ⟶ 2,027:
def treeFromSparseLevels(levelList):
'''A Forest (list of Trees) of (Maybe Int) values,
in which implicit nodes have the value NothingNone.
'''
return Node(Nothing()None)(
forestFromLevels(
rooted(normalized(levelList))
)
)
 
 
# sparseLevelsFromTree :: Tree (Maybe Int) -> [Int]
def sparseLevelsFromTree(tree):
'''Sparse representation of the tree
a list of nest level integers.
'''
def go(x):
return lambda xs: concat(xs) if (
x.get('Nothing', False)
) else [x.get('Just', 0)] + concat(xs)
return foldTree(go)(tree)
 
 
Line 1,345 ⟶ 2,052:
return []
return go(nvs)
 
 
# bracketNest :: Maybe Int -> Nest -> Nest
def bracketNest(maybeLevel):
'''An arbitrary nest of bracketed
lists and sublists.
'''
def go(xs):
subNest = concat(xs)
return [subNest] if None is maybeLevel else (
[maybeLevel, subNest] if subNest else (
[maybeLevel]
)
)
return go
 
 
Line 1,353 ⟶ 2,075:
'''
return drawTree(
fmapTree(showMayberepr)(tree)
)
 
 
# sparseLevelsFromTree :: Tree (Maybe Int) -> [Int]
def sparseLevelsFromTree(tree):
'''Sparse representation of the tree
a list of nest level integers.
'''
def go(x):
return lambda xs: concat(xs) if (
None is x
) else [x] + concat(xs)
return foldTree(go)(tree)
 
 
Line 1,374 ⟶ 2,108:
(
print('From: ' + repr(xs)),
print('Through tuple nest:'),
print(repr(tree)),
print('\nTree:'),
print(showTree(tree)),
print('\nto bracket nest:'),
print(
repr(
root(foldTree(bracketNest)(tree))
)
),
print(
'Backand back to: ' + (
repr(sparseLevelsFromTree(tree))
)
Line 1,392 ⟶ 2,135:
if xs:
x = xs[0]
h = [(x, Just(x))]
return h if 1 == len(xs) else (
h + [(1 + x, Nothing()None)] if (
1 < (xs[1] - x)
) else h
Line 1,425 ⟶ 2,168:
more child trees.
'''
return lambda xs: {'type': 'Tree', 'root': (v, 'nest': xs})
 
 
Line 1,482 ⟶ 2,225:
def go(x):
return Node(
f(x['root'](x))
)([go(v) for v in x['nest'](x)])
return go
 
Line 1,502 ⟶ 2,245:
def nest(t):
'''Accessor function for children of tree node.'''
return t.get('nest')[1]
 
 
Line 1,508 ⟶ 2,251:
def root(t):
'''Accessor function for data of tree node.'''
return t.get('root')[0]
 
 
# -------------------- GENERIC OTHER ---------------------
 
# Just :: a -> Maybe a
def Just(x):
'''Constructor for an inhabited Maybe (option type) value.
Wrapper containing the result of a computation.
'''
return {'type': 'Maybe', 'Nothing': False, 'Just': x}
 
 
# Nothing :: () -> Maybe a
Line 1,526 ⟶ 2,261:
Empty wrapper returned where a computation is not possible.
'''
return {'type': 'Maybe', 'Nothing': True}None
 
 
Line 1,544 ⟶ 2,279:
)
) if xs else []
 
 
# showMaybe :: Maybe a -> String
def showMaybe(mb):
'''Stringification of a Maybe value.'''
return 'Nothing' if (
mb.get('Nothing')
) else 'Just ' + repr(mb.get('Just'))
 
 
Line 1,592 ⟶ 2,319:
# MAIN ---
if __name__ == '__main__':
main()</langsyntaxhighlight>
{{Out}}
<pre>From: []
Through tuple nest:
Nothing
Back to:(None, [])
 
Tree:
None
 
to bracket nest:
[]
and back to: []
 
From: [1, 2, 4]
Through tuple nest:
Nothing
(None, [(1, [(2, [(None, [(4, [])])])])])
 
Tree:
None
|
└─ Just 1
|
└─ Just 2
|
└─ NothingNone
|
└─ Just 4
 
Back to: [1, 2, 4]
to bracket nest:
[1, [2, [[4]]]]
and back to: [1, 2, 4]
 
From: [3, 1, 3, 1]
Through tuple nest:
Nothing
(None, [(None, [(None, [(3, [])])]), (1, [(None, [(3, [])])]), (1, [])])
 
Tree:
None
|
├─ NothingNone
│ |
│ └─ NothingNone
│ |
│ └─ Just 3
|
├─ Just 1
│ |
│ └─ NothingNone
│ |
│ └─ Just 3
|
└─ Just 1
 
Back to: [3, 1, 3, 1]
to bracket nest:
[[[3]], 1, [[3]], 1]
and back to: [3, 1, 3, 1]
 
From: [1, 2, 3, 1]
Through tuple nest:
Nothing
(None, [(1, [(2, [(3, [])])]), (1, [])])
 
Tree:
None
|
├─ Just 1
│ |
│ └─ Just 2
│ |
│ └─ Just 3
|
└─ Just 1
 
Back to: [1, 2, 3, 1]
to bracket nest:
[1, [2, [3]], 1]
and back to: [1, 2, 3, 1]
 
From: [3, 2, 1, 3]
Through tuple nest:
Nothing
(None, [(None, [(None, [(3, [])]), (2, [])]), (1, [(None, [(3, [])])])])
 
Tree:
None
|
├─ NothingNone
│ |
│ ├─ NothingNone
│ │ |
│ │ └─ Just 3
│ |
│ └─ Just 2
|
└─ Just 1
|
└─ NothingNone
|
└─ Just 3
 
Back to: [3, 2, 1, 3]
to bracket nest:
[[[3], 2], 1, [[3]]]
and back to: [3, 2, 1, 3]
 
From: [3, 3, 3, 1, 1, 3, 3, 3]
Through tuple nest:
Nothing
(None, [(None, [(None, [(3, []), (3, []), (3, [])])]), (1, []), (1, [(None, [(3, []), (3, []), (3, [])])])])
 
Tree:
None
|
├─ NothingNone
│ |
│ └─ NothingNone
│ |
│ ├─ Just 3
│ |
│ ├─ Just 3
│ |
│ └─ Just 3
|
├─ Just 1
|
└─ Just 1
|
└─ NothingNone
|
├─ Just 3
|
├─ Just 3
|
└─ Just 3
 
Back to: [3, 3, 3, 1, 1, 3, 3, 3]</pre>
to bracket nest:
[[[3, 3, 3]], 1, 1, [[3, 3, 3]]]
and back to: [3, 3, 3, 1, 1, 3, 3, 3]</pre>
 
=={{header|Quackery}}==
 
<syntaxhighlight lang="quackery"> [ stack ] is prev ( --> s )
 
[ temp take
swap join
temp put ] is add$ ( x --> )
 
[ dup [] = if done
0 prev put
$ "' " temp put
witheach
[ dup prev take -
over prev put
dup 0 > iff
[ times
[ $ "[ " add$ ] ]
else
[ abs times
[ $ "] " add$ ] ]
number$ space join add$ ]
prev take times
[ $ "] " add$ ]
temp take quackery ] is nesttree ( [ --> [ )
 
' [ [ ]
[ 1 2 4 ]
[ 3 1 3 1 ]
[ 1 2 3 1 ]
[ 3 2 1 3 ]
[ 3 3 3 1 1 3 3 3 ] ]
 
witheach
[ dup echo say " --> "
nesttree echo cr cr ]</syntaxhighlight>
 
{{out}}
 
<pre>[ ] --> [ ]
 
[ 1 2 4 ] --> [ 1 [ 2 [ [ 4 ] ] ] ]
 
[ 3 1 3 1 ] --> [ [ [ 3 ] ] 1 [ [ 3 ] ] 1 ]
 
[ 1 2 3 1 ] --> [ 1 [ 2 [ 3 ] ] 1 ]
 
[ 3 2 1 3 ] --> [ [ [ 3 ] 2 ] 1 [ [ 3 ] ] ]
 
[ 3 3 3 1 1 3 3 3 ] --> [ [ [ 3 3 3 ] ] 1 1 [ [ 3 3 3 ] ] ]
</pre>
 
=={{header|Raku}}==
===Iterative===
{{trans|Python}}
<syntaxhighlight lang="raku" perl6line>sub new_level ( @stack --> Nil ) {
my $e = [];
push @stack.tail, $e;
Line 1,705 ⟶ 2,525:
}
my @tests = (), (1, 2, 4), (3, 1, 3, 1), (1, 2, 3, 1), (3, 2, 1, 3), (3, 3, 3, 1, 1, 3, 3, 3);
say .Str.fmt( '%15s => ' ), .&to_tree_iterative for @tests;</langsyntaxhighlight>
{{out}}
<pre>
Line 1,717 ⟶ 2,537:
===Recursive===
{{trans|Python}}
<syntaxhighlight lang="raku" perl6line>sub to_tree_recursive ( @list, $index is copy, $depth ) {
my @so_far = gather while $index <= @list.end {
my $t = @list[$index];
Line 1,741 ⟶ 2,561:
}
my @tests = (), (1, 2, 4), (3, 1, 3, 1), (1, 2, 3, 1), (3, 2, 1, 3), (3, 3, 3, 1, 1, 3, 3, 3);
say .Str.fmt( '%15s => ' ), to_tree_recursive( $_, 0, 1 ).[1] for @tests;</langsyntaxhighlight>
{{out}}
<pre>
Line 1,754 ⟶ 2,574:
===String Eval===
{{trans|Perl}}
<syntaxhighlight lang="raku" perl6line>use MONKEY-SEE-NO-EVAL;
sub to_tree_string_eval ( @xs --> Array ) {
my @gap = [ |@xs, 0 ] Z- [ 0, |@xs ];
Line 1,766 ⟶ 2,586:
}
my @tests = (), (1, 2, 4), (3, 1, 3, 1), (1, 2, 3, 1), (3, 2, 1, 3), (3, 3, 3, 1, 1, 3, 3, 3);
say .Str.fmt( '%15s => ' ), .&to_tree_string_eval for @tests;</langsyntaxhighlight>
{{out}}
<pre>
Line 1,782 ⟶ 2,602:
{{libheader|Wren-seq}}
{{libheader|Wren-fmt}}
<langsyntaxhighlight ecmascriptlang="wren">import "./seq" for Stack
import "./fmt" for Fmt
 
var toTree = Fn.new { |list|
Line 1,815 ⟶ 2,635:
var nest = toTree.call(test)
Fmt.print("$24n => $n", test, nest)
}</langsyntaxhighlight>
 
{{out}}
Line 1,829 ⟶ 2,649:
===Recursive===
{{trans|Python}}
<langsyntaxhighlight ecmascriptlang="wren">import "./fmt" for Fmt
 
var toTree // recursive
Line 1,863 ⟶ 2,683:
var n = toTree.call(test, 0, 1)
Fmt.print("$24n => $n", test, n[1])
}</langsyntaxhighlight>
 
{{out}}
<pre>
Same as iterative version.
</pre>
 
=={{header|XPL0}}==
A sentinel 0 is used to terminate the input arrays because XPL0 does not have built-in lists.
Note that [0] displays nothing.
<syntaxhighlight lang "XPL0">proc ShowTree(List);
int List, NestLevel, I;
[NestLevel:= 0;
for I:= 0 to -1>>1 do
[while List(I) < NestLevel do
[ChOut(0, ^]); NestLevel:= NestLevel-1];
if List(I) = 0 then [CrLf(0); return];
if I # 0 then Text(0, ", ");
while List(I) > NestLevel do
[ChOut(0, ^[); NestLevel:= NestLevel+1];
IntOut(0, NestLevel);
];
];
 
[ShowTree([0]);
ShowTree([1, 2, 4, 0]);
ShowTree([3, 1, 3, 1, 0]);
ShowTree([1, 2, 3, 1, 0]);
ShowTree([3, 2, 1, 3, 0]);
ShowTree([3, 3, 3, 1, 1, 3, 3, 3, 0]);
ShowTree([1, 2, 4, 2, 2, 1, 0]);
]</syntaxhighlight>
{{out}}
<pre>
 
[1, [2, [[4]]]]
[[[3]], 1, [[3]], 1]
[1, [2, [3]], 1]
[[[3], 2], 1, [[3]]]
[[[3, 3, 3]], 1, 1, [[3, 3, 3]]]
[1, [2, [[4]], 2, 2], 1]
</pre>
196

edits