;; The first three lines of this file were inserted by DrRacket. They record metadata
;; about the language level of this file in a form that our tools can easily process.
#reader(lib "htdp-beginner-abbr-reader.ss" "lang")((modname week5_tu_full) (read-case-sensitive #t) (teachpacks ((lib "image.ss" "teachpack" "2htdp"))) (htdp-settings #(#t constructor repeating-decimal #f #t none #f ((lib "image.ss" "teachpack" "2htdp")))))
; a sorted list is either:
; - empty
; - (cons number[n] list-of-numbers[l])
; INVARIANT: each number in 'l' is greater than 'n'

; remove-least : sorted-list -> sorted-list
; removes the least element of the given list, returns empty if slon empty
(define (remove-least slon) 
  (cond [(empty? slon) empty]
        [else (rest slon)])
  )

(check-expect (remove-least (list 2 4 6)) (list 4 6))
(check-expect (remove-least (list 1 3 8 120)) (list 3 8 120))

;----------Binary Search Trees-------------

; a person is
; - (make-person number symbol)
(define-struct person (ssn name))

(define Adam (make-person 1 'adam))
(define George (make-person 2 'george))
(define Jon (make-person 3 'jon))

; a database is:
; - empty
; - (make-db-node person database[left] database[right])
; INVARIANT: everyone in left has lower ssn than person,
;            everyone in right has higher ssn than person
(define-struct db-node (person left right))

(define mydb (make-db-node George 
                           (make-db-node Adam empty empty)
                           (make-db-node Jon empty empty)))

; person-matches? : person number -> boolean
; returns whether person matches ssn
(define (person-matches? per n)
  (= (person-ssn per) n))

; smaller? : number person -> boolean
; returns whether number is smaller than person's ssn
(define (smaller? n per) (< n (person-ssn per)))

; person-change-name : person symbol -> person
; changes person's name to given name
(define (person-change-name per s) 
  (make-person (person-ssn per) s)
  )

(check-expect (person-change-name Jon 'frank)
              (make-person 3 'frank))

; Q2 : Write a function that takes a database, a name, and an ssn, and changes the name of the person with the given ssn to be the given name.  It should return the same database, with this one change.  Use the above helper functions if they are helpful.

; name-change : database symbol number -> database
; returns database after changing name of person with given ssn
(define (name-change db name ssn) 
  (cond [(empty? db) empty]
        [else 
           (cond [(person-matches? (db-node-person db) ssn)
                  (make-db-node 
                   (person-change-name (db-node-person db) name)
                   (db-node-left db)
                   (db-node-right db))
                   ]                  ;match
                 [(smaller? ssn (db-node-person db))
                (make-db-node (db-node-person db)
                              (name-change (db-node-left db) name ssn)
                              (db-node-right db))
                  ] ;go left
                 [else ;go right
                  (make-db-node (db-node-person db)
                                (db-node-left db)
                  (name-change (db-node-right db) name ssn))])]) 
             
  )

(check-expect (name-change mydb 'frank 3)
                (make-db-node George 
                           (make-db-node Adam empty empty)
                           (make-db-node 
                            (make-person 3 'frank) empty empty)))

; Q3: Design a function that takes two lists of numbers, and returns the set difference A - B.
; Assume the numbers in each individual list are unique

; remember with 2 lists, we can recurse in three ways:
; (fun A (rest B))
; (fun (rest A) B)
; (fun (rest A) (rest B))

; set-diff : list-of-numbers list-of-numbers -> list-of-numbers
; computes set difference of two lists, assuming no dup elems in lists
(define (set-diff lon1 lon2) 
  (cond [(empty? lon1) empty]
        [(empty? lon2) lon1]
        [else (cond [(member? (first lon1) lon2)
                     (set-diff (rest lon1) lon2)]
                    [else (cons (first lon1) 
                       (set-diff (rest lon1) lon2))])]     
  ))

(check-expect (set-diff (list 1 2 3) (list 2 3 4)) (list 1))
(check-expect (set-diff (list 1 2) empty) (list 1 2))