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


;;; #1
(define rotate
  (lambda (ls)
    (cond [(null? ls) '()]
	  [(null? (cdr ls)) ls]
	  [else (let ([temp (rotate (cdr ls))])
		  (cons (car temp) (cons (car ls) (cdr temp))))])))

;;; #2
(define make-list-c
  (lambda (c)
    (lambda (item)
      (letrec ([foo (lambda (n)
		      (if (= n 0)
			  '()
			  (cons item (foo (- n 1)))))])
	(foo c)))))

;;; #3
(define filter-out
  (lambda (pred)
    (letrec ([foo (lambda (ls)
		    (cond [(null? ls) '()]
			  [(pred (car ls)) (foo (cdr ls))]
			  [else (cons (car ls) (foo (cdr ls)))]))])
      foo)))



;;; #4

(define substitute-all-m
  (lambda (x y)
    (letrec ([subs (lambda (ls)
		     (cond [(null? ls) '()]
			   [(equal? (car ls) x) (cons y (subs (cdr ls)))]
			   [(pair? (car ls)) (cons (subs (car ls))
						   (subs (cdr ls)))]
			   [else (cons (car ls) (subs (cdr ls)))]))])
      subs)))



;;; #6

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





;;; #5
(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)))])))



;;; #7

;V1
;(define complete
;  (lambda (l1 l2)
;    (cond [(null? l2) ()]
;	  [else (complete (cons (car l2) l1)
;			  (cdr l2))])))

;V2
;(define complete
;  (lambda (l1 e l2)
;    (cond [(null? l2) ()]
;	  [else (complete (append l1 e)
;			  (list (car l2))
;			  (cdr l2))])))

;V3
;(define complete
;  (lambda (l1 e l2)
;    (cond [(null? l2) ()]
;	  [else (cons (append e l1 l2)
;		      (complete (append l1 e)
;				(list (car l2))
;				(cdr l2)))])))


;V4-5-6
(define complete2
  (lambda (l1 e l2)
    (cond [(null? l2) (list (list e (append l1 l2)))]
	  [else (cons (list e (append l1 l2))
		      (complete2 (append l1 (list e))
				 (car l2)
				 (cdr l2)))])))

(define complete
  (lambda (l)
    (cond [(null? l) '()]
	  [(null? (cdr l)) (list (list (car l) '()))]
	  [else (complete2 '() (car l) (cdr l))])))



;;; #8
(define complete?
  (lambda (graph)
    (if (null? graph)
	#t
	(complete?2 (map car graph) (map car graph) graph))))

(define complete?2
  (lambda (current_node nodes graph)
    (cond [(null? current_node) #t]
	  [(check-node (car current_node) nodes (cadar graph))
	   (complete?2 (cdr current_node) nodes (cdr graph))]
	  [else #f])))

(define check-node
  (lambda (node_name nodes neighbors)
    (let ([nodes_to_check (remq node_name nodes)])
      (letrec ([check (lambda (nodes_to_check neighbors)
			(if (null? nodes_to_check)
			    (null? neighbors)
			    (if (memq (car nodes_to_check) neighbors)
				(check (cdr nodes_to_check)
				       (remq (car nodes_to_check) neighbors))
				#f)))])
	(check nodes_to_check neighbors)))))