(define rl
  (lambda ()
    (load "4.ss")))


(define exists?
  (lambda (pred ls)
    (cond [(null? ls) #f]
	  [(pred (car ls))]
	  [else (exists? pred (cdr ls))])))


(define product
  (lambda (l1 l2)
    (cond [(null? l1) ()]
	  [(null? l2) ()]
	  [else (prod l1 l2)])))

(define prod
  (lambda (l1 l2)
    (if (null? l1)
	()
	(append (product-element (car l1) l2) (prod (cdr l1) l2)))))

(define product-element
  (lambda (e l)
    (if (null? l)
	()
	(cons (list e (car l))
	      (product-element e (cdr l))))))

	

(define rotate
  (lambda (l)
    (cond [(null? l) l]
	  [(null? (cdr l)) l]
	  [else (let ([last '()])
		  (letrec ([rot (lambda (l)
				  (cond [(null? (cddr l)) (begin (set! last (cadr l))
								 (list (car l)))]
					[else (cons (car l) (rot (cdr l)))]))])
		    (let ([ls (rot l)])
		      (cons last ls))))])))



	  
;(define rotate
;  (lambda (l)
;    (let ([r1 (reverse l)])
;      (cons (car r1) (reverse (cdr r1))))))


(define flatten
  (lambda (l)
    (cond [(null? l) ()]
	  [(atom? l) (list l)]
	  [(null? (cdr l)) (flatten (car l))]
	  [else (append (flatten (car l))
			(flatten (cdr l)))])))
	  

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



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


(define snlist-recur
  (lambda (flist fatom init)
    (letrec ([helper (lambda (l)
		       (cond [(null? l) init]
			     [(list? (car l)) (flist (helper (car l))
						     (helper (cdr l)))]
			     [else (fatom (car l) (helper (cdr l)))]))])
      helper)))



(define sn-list-sum (snlist-recur + + 0))

(define paren-count (snlist-recur + (lambda (x y) y) 2))

(define sn-list-map (lambda (f ls)
		      ((snlist-recur cons
				     (lambda (x y)
				       (cons (f x) y))
				     ())
		       ls)))