(define (rl) (load "3.ss"))

(define let->application
  (lambda (let-expression)
    (let ((args (cadr let-expression))
	  (body (caddr let-expression)))
      (cons (list 'lambda (make-args args) body)
	    (make-vals args)))))

(define make-args
  (lambda (list)
    (map car list)))

(define make-vals
  (lambda (list)
    (map cadr list)))


(define let*->let
  (lambda (expression)
    (let ([var-defs (cadr expression)]
	  [body (caddr expression)])
      (if (null? var-defs)
	  (list 'let '() body)
	  (make_lets var-defs body)))))

(define make_lets
  (lambda (var-defs body)
    (if (null? var-defs)
	body
	(list 'let (list (car var-defs)) (make_lets (cdr var-defs) body)))))


(define for->named_let
  (lambda (expression)
    (let ([header (cadr expression)]
	  [body (caddr expression)])
      (let ([var-expressions (car header)]
	    [conditional (cadr header)]
	    [update-expressions (caddr header)])
	(list 'let 'loop var-expressions (list 'if conditional (cons 'loop update-expressions)
					       body))))))


(define named_let->letrec
  (lambda (expression)
    (let ([name (cadr expression)]
	  [var-defs (caddr expression)]
	  [body (cadddr expression)])
      (let ([vars (map car var-defs)]
	    [vals (map cadr var-defs)])
	(list 'letrec
	      (list (list name
			  (list 'lambda vars body)))
	      (cons name vals))))))

;;; N: number of intervals
;;; sort: O(N log(N))

(define minimize-interval-list
  (lambda (l)
    (minimize-sorted-list (sort (lambda (i1 i2)
				  (< (car i1)
				     (car i2)))
				l))))

;;; O(N)
(define minimize-sorted-list
  (lambda (ls)
    (cond [(null? (cdr ls)) ls]
	  [(sorted-interval-intersects? (car ls) (cadr ls))
	   (minimize-sorted-list (cons (join-sorted-interval (car ls) (cadr ls))
				       (cddr ls)))]
	  [else (cons (car ls)
		      (minimize-sorted-list (cdr ls)))])))

;;; O(1)
(define sorted-interval-intersects?
  (lambda (l1 l2)
    (>= (cadr l1) (car l2))))

;;; O(1)
(define join-sorted-interval
  (lambda (l1 l2)
    (if (>= (cadr l1) (cadr l2))
	l1
	(list (car l1) (cadr l2)))))



;;; All in one
(define minimize-interval-list
  (lambda (lst)
    (let ([sorted-interval-intersects?
	   (lambda (l1 l2)
	     (>= (cadr l1) (car l2)))]
	  [join-sorted-interval
	   (lambda (l1 l2)
	     (if (>= (cadr l1) (cadr l2))
		 l1
		 (list (car l1) (cadr l2))))])
      (letrec ([minimize-sorted-list
		(lambda (ls)
		  (cond [(null? (cdr ls)) ls]
			[(sorted-interval-intersects? (car ls) (cadr ls))
			 (minimize-sorted-list (cons (join-sorted-interval (car ls) (cadr ls))
						     (cddr ls)))]
			[else (cons (car ls)
				    (minimize-sorted-list (cdr ls)))]))])
	(minimize-sorted-list (sort (lambda (i1 i2)
				      (< (car i1)
					 (car i2)))
				    lst))))))



;;; All in one
;;; removed some code but made it less intuitive
(define minimize-interval-list
  (lambda (lst)
    (let ([ls (sort (lambda (i1 i2) (< (car i1) (car i2))) lst)])
      (letrec ([minimize-sorted-list
		(lambda (ls)
		  (cond [(null? (cdr ls)) ls]
			[(>= (cadar ls) (caadr ls))
			 (minimize-sorted-list (cons (if (>= (cadar ls) (cadadr ls))
							 (car ls)
							 (list (caar ls) (cadadr ls)))
						     (cddr ls)))]
			[else (cons (car ls)
				    (minimize-sorted-list (cdr ls)))]))])
	(minimize-sorted-list ls)))))



;;; All in one
;;; removed some code but made it less intuitive
;;; Added some names to give a sense of what is going on.
(define minimize-interval-list
  (lambda (lst)
    (let ([ls (sort (lambda (i1 i2) (< (car i1) (car i2))) lst)])
      (letrec ([minimize-sorted-list
		(lambda (ls)
		  (if (null? (cdr ls))
		      ls
		      (let* ([1st_ls (car ls)]
			     [2nd_ls (cadr ls)]
			     [1st_elem_1st_ls (car 1st_ls)]
			     [2nd_elem_1st_ls (cadr 1st_ls)]
			     [1st_elem_2nd_ls (car 2nd_ls)]
			     [2nd_elem_2nd_ls (cadr 2nd_ls)])
			(if (>= 2nd_elem_1st_ls 1st_elem_2nd_ls)
			    (minimize-sorted-list (cons (if (>= 2nd_elem_1st_ls 2nd_elem_2nd_ls)
							    1st_ls
							    (list 1st_elem_1st_ls 2nd_elem_2nd_ls))
							(cddr ls)))
			    (cons (car ls) (minimize-sorted-list (cdr ls)))))))])
	(minimize-sorted-list ls)))))











(define pascal-triangle
  (lambda (n)
    (if (< n 0)
	()
	(pt n '((1))))))


(define pt
  (lambda (n accu)
    (if (= n 0)
	accu
	(pt (- n 1) (cons (cons 1 (make-row (car accu)))
			  accu)))))

(define make-row
  (lambda (row)
    (cond [(null? (cdr row)) '(1)]
	  [else (cons (+ (car row) (cadr row))
		      (make-row (cdr row)))])))