18-8-27-- scheme practice

#lang racket

(cons "hi" "somebody")
(cons 0 '())
(cons 1 (cons 10 100))
(cons 1 (cons 10 (cons 100 '())))
(cons #\I (cons "saw" (cons 3 (cons "girls" '()))))
(cons "sum of" (cons 1 (cons 2 (cons 3 (cons 4 (cons "is" (cons 10 '())))))))


(car '(0))
(car '((1 2 3) (4 5 6)))
(cdr '(1 2 3 . 4))
(cdr (cons 3 (cons 2 (cons 1 '()))))

;;make a funct to add 1 to a number x
(define add1
  (λ (x)
    (+ 1 x)))
(add1 6)
;;syntactic sugar
(define (addd1 x) (+ 1 x))
(addd1 8)


;;write an if statement to show reciprocal of a number n
(define (inv n)
  (if (not (zero? n))
      (/ n)
      (0)))
(inv 5)

;;; write a procedure called "bigger than 5", it take a an integer 'n' and if
;; 'n > 5' than it returns the string "bigger than 5" otherwise returns "less than 5"

(define (big5 n)
  (if (>= n 5)
      "greater than"
      "less than"
      ))


  
(eq? (big5 7) "greater than")

;; cond practice
;;The grade (A – D) of exam is determined by the score (score). Write a function that takes a score as an argument and returns a grade.
;;A if score ≥ 80
;;B if 60 ≤ score ≤ 79
;;C if 40 ≤ score ≤ 59
;;D if score < 40


(define grade
  (λ (score)
    (cond
      ((>= score 80) 'A)
      ((<= 60 score 79) 'B)
      ((<= 40 score 59) 'C)
      (else 'D))))

(grade 81)

;;recursion

;; write a function that counts the number of list items "my-length"

(define (my-length ls)
  (if (null? ls)
      0
      (+ 1 (my-length (cdr ls)))))
     

(my-length '(1 2 3 8))

;;A function that takes a list (ls) and an object (x)
;;as arguments and returns a list removing x from ls.
      
      
(define (take-away ls x)
  (cond
    ((null? ls) '())
    ((eq? (car ls) x) (take-away (cdr ls) x))
    (else (cons (car ls) (take-away (cdr ls) x)))))
(println "hey")
(take-away '() "cat")

;; A function that takes a list (ls) and and an object (x)
;; and returns the first position of x in ls. The position is counted from 0.
;; If x is not found in ls, the function returns #f


;; modification suggestion:
;; a function that takes a list (ls), an object (x), and a starting position (idx) which you make 0
;; cases you need to consider:
;; if list is null, return false
;; if (car ls) == x, return idx
;; else return (λ (car ls) x (+ 1 idx))

(println 'ah)

(define (ugh ls x idx)
  (cond
    ((null? ls) #f)
    ((eq? (car ls) x) idx)
    (else
     (ugh (cdr ls) x (+ 1 idx)))))

(ugh '(1 2 3 4) 3 0)

;; tail recursion

; write fn "my-reverse" that reverses the order of list items

(define (my-rev ls res)
  (if (null? ls)
      res
      (my-rev (cdr ls) (cons (car ls) res))))

(my-rev '(1 2 3 4) '())


;; write recursive function to return value when key (x) is searched for

(define m
  '((1 2) (3 "cat") (8 9)))

(define (get m x)
  (if (null? m)
      '()
      (let* ((pair (car m))
         (key (car pair))
         (value (cadr pair)))
    (cond
      ((eq? key x) value)
      (else
       (get (cdr m) x))))))

(get m 1)
(get m 8)
(get m 10)

(let* ((s '(1 2 3))
       (l '()))
  (cons s l))


;;write a recursive function that returns a list recursively

;;(define (my-list ls)
;;  (if (null? ls)
;;      '()
;;      (cons (car ls) (cons (my-list (cdr ls)) '()))))

;; ^ not right

(define (my-ls ls)
  (if (null? ls)
      '()
      (cons (car ls) (my-ls (cdr ls) ))))

(my-ls '(2 3 4 5 9))