trees.ss

(define l1 (list 1 3 (list 5 7) 9))

(define l2 (list (list 7)))

(define l3 (cons 1 (cons 2 (cons 3 ( cons 4 ( cons 5 (cons 6 7)))))))

(define m 
 (cdr (cdr (cdr (cdr (cdr (cdr l3))))))
)

(define x1 (list 1 2 3))
(define y1 (list 4 5 6))

(define x2 (list (list 1 2) (list 3 4)))


(define (deep-reverse l)
 (define (rev l result) 
   (cond ((null? l) result)
         ((not (pair? l)) l)
         (else (rev (cdr l) (cons (rev (car l) (list)) result ) ))
        )
   )
 (rev l (list))
)

(define x3 (list 1 2 3 4))
(define x4 (list (list 1 2 3 4) (list 5 6 7 8)))
(define x5 (list x4 x4))

(
define (fringe t)
 (cond ((null? t) (list))
          ((not (pair? t)) (list t))
          (else (append (fringe (car t)) (fringe (cdr t))))      
 )
)

(define (fringe1 t)
 (define (f1-iter ls result)
  (cond ((null? ls) result)
        ((not (pair? ls)) (cons ls result))
        (else (f1-iter (car ls) (f1-iter (cdr ls) result)))      
  )
 )     
 (f1-iter t (list))      
)


(define (make-mobile left right)
  (list left right)
)

(define (make-branch length1 structure)
  (list length1 structure)
)

(define (left-branch mobile)
  (car mobile)
)

(define (right-branch mobile)
  (car (cdr mobile))
)

(define (branch-length branch)
 (car branch)
)

(define (branch-structure branch)
  (car (cdr branch))
)

(define mob (make-mobile (make-branch 1 (make-mobile (make-branch 10 11) (make-branch 60 70)) ) (make-branch 5 6) )) 

(define mob1 (make-mobile (make-branch 1 (make-mobile (make-branch 1 1) (make-branch 1 1))) (make-branch 1 (make-mobile (make-branch 1 1) (make-branch 1 1)))))

(define (total-weight mobile)
  (let ( (left (left-branch mobile)) (right (right-branch mobile)))
    (+ (branch-weight left) (branch-weight right))
  )
)

(define (branch-weight branch)
  (let ((struct (branch-structure branch)))
    (if (pair? struct)
        (total-weight struct)
        struct
    )
  )
)

(define (balanced? mobile)
 (let ((left (left-branch mobile)) (right (right-branch mobile)))
   (and 
     (if (pair? (branch-structure left))
      (balanced? (branch-structure left))
      #t
     )
     (if (pair? (branch-structure right))
      (balanced? (branch-structure right))
      #t
     )
     ( = 
      (* (branch-length left) (branch-weight left))
      (* (branch-length right) (branch-weight right))
     )
    )
 )
)

(define tr1 (list (list 2 3) (list 3 4)))

(define (sq-tree tree)
 (cond ((null? tree) (list))
       ((not (pair? tree)) (* tree tree))
       (else (cons (square-tree (car tree)) (square-tree (cdr tree))) )      
 )
)
  
(define (sq-tree1 tree)
 (map 
   (lambda (sub-tree)
    (if (pair? sub-tree)
        (sq-tree1 sub-tree)
        (* sub-tree sub-tree)
    )
   )   
   tree
 )  
)

(define (tree-map fct tree) 
 (map 
    (lambda (sub-tree)
      (if (pair? sub-tree)
          (tree-map fct sub-tree)
          (fct sub-tree)
      )
    )
    tree
 )
)

(define (tree-map1 fct tree) 
 (cond ((null? tree) (list))
       ((not (pair? tree)) (fct tree))
       (else (cons (tree-map1 fct (car tree)) (tree-map1 fct (cdr tree))) )
 )
)

(define (sq-tree2 tree) (tree-map square tree))

(define set (list 1 2 3))

(define (subsets s)
  (if (null? s)
      (list (list))
      (let ( (rest (subsets (cdr s))) )
        (append rest (map 
                       (lambda (x) (append x (list (car s)))) 
                       rest)
                     )
      )
   )
)