;;;;
;;;; length
;;;;

;; embedded
(define (length sent)
   (if (empty? sent)
      0
      (+ 1 (length (bf sent)))))
      
;; tail
(define (length sent)
   (length-helper sent 0))

   
(define (length-helper sent length-so-far)
   (if (empty? sent)
      length-so-far
      (length-helper (bf sent) (+ 1 length-so-far))))

      

;;;
;;; sent-max   
;;;


;; tail!
(define (sent-max sent)
  (if (empty? sent)
    '()
    (sent-max-helper (bf sent) (first sent))))


(define (sent-max-helper sent max-so-far)
  (if (empty? sent)
    max-so-far
    (sent-max-helper (bf sent) (first sent))))








;;;
;;; pascal
;;;


(define (pascal C R)
  (cond 
    ((= C 0) 1)   ;base case

    ((= C R) 1)   ;base case

    (else         ;tree recurse 
     (+ (pascal    C    (- R 1))
        (pascal (- C 1) (- R 1)) )
     )))











        
        
        
;;;        
;;; pair-all
;;;
        
        
;; separate procedures way
(define (pair-all s1 s2)
        (if (empty? s1)
           '()
           (se (pair-this (first s1) s2)
               (pair-all (bf s1) s2))))

;; this was named differently in lecture...
(define (pair-this wd sent)
        (if (empty? sent)
           '()
           (se (word wd (first sent))
               (pair-this wd (bf sent)))))

 
;; single procedure way (trickier!)

(define (pair-all2 word-or-sent sent)
    (cond ((or (empty? word-or-sent) (empty? sent))
           '())
          ((empty? (bf word-or-sent))
           (se (word (first word-or-sent) (first sent))
               (pair-all2 word-or-sent (bf sent))))
          (else 
           (se (pair-all2 (se (first word-or-sent)) sent)
               (pair-all2 (bf word-or-sent) sent)))))



 
;;;
;;; binary
;;;

;; using pair-all, less tree-recursion like
(define (binary n)
   (if (= n 1)
      '(0 1)
      (pair-all '(0 1) (binary (- n 1)))))


;; more tree-recursion like
(define (binary n)
   (if (= n 1)
      '(0 1)
      (se (pair-this 0 (binary (- n 1)))
          (pair-this 1 (binary (- n 1))))))






;;;
;;;  Roman-sum-helper (from first "advanced" recursions)
;;;


(define (roman-sum number-sent)
  (if (empty? number-sent)
      0
     (roman-sum-helper 
            (first number-sent)
            (bf number-sent) 
            (first number-sent)) ) )


(define (roman-sum-helper so-far number-sent most-recent)
  (cond ((empty? number-sent) so-far)
	
        ((>= most-recent (first number-sent))

	 (roman-sum-helper (+ so-far (first number-sent))
			   (bf number-sent)
			   (first number-sent))) 
	(else

	 (roman-sum-helper (+ so-far
			      (- most-recent)
			      (- (first number-sent) most-recent))
			   (bf number-sent)
			   (first number-sent) )) ) ) 


; (roman-sum-helper 100 '(10 50 1 5) 100)
; (roman-sum-helper 110 '(50 1 5) 10)
; (roman-sum-helper 140 '(1 5)  50)
; (roman-sum-helper 141 '(5)  1)
; (roman-sum-helper 156 '( )  5)