Given a flat list of integers greater than zero, representing object nesting
levels, e.g. [1, 2, 4],
generate a tree formed from nested lists of those nesting level integers where:

 Every int appears, in order, at its depth of nesting.
 If the next level int is greater than the previous then it appears in a sub-list of the list containing the previous item


The generated tree data structure should ideally be in a languages nested list format that can
be used for further calculations rather than something just calculated for printing.



An input of [1, 2, 4] should produce the equivalent of: [1, [2, [[4]]]]
where 1 is at depth1, 2 is two deep and 4 is nested 4 deep.

[1, 2, 4, 2, 2, 1] should produce [1, [2, [[4]], 2, 2], 1]. 

All the nesting integers are in the same order but at the correct nesting
levels.

Similarly [3, 1, 3, 1] should generate [[[3]], 1, [[3]], 1]

Task

Generate and show here the results for the following inputs:

 []
 [1, 2, 4]
 [3, 1, 3, 1]
 [1, 2, 3, 1]
 [3, 2, 1, 3]
 [3, 3, 3, 1, 1, 3, 3, 3]


;; 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)
 