Programming Languages

; You can copy-paste this whole bit into DrRacket. I think.

; These are due before class on Tuesday.

#lang racket

(require test-engine/racket-tests)

;; In all cases, it may make sense to write a helper procedure. For example, if you are given a string and asked to count how many vowels are in it, you may want to convert the string to a list of characters. You could write:

;; (define (count-vowels str)

;;   (count-vowels-helper (string->list str)))

;; and in the function count-vowels-helper do the interesting work. Not all problems benefit from the use of a helper, but it is sometimes the case that we can solve a problem more simply by writing more than one function.

;; 1. This is a problem about using first, second, third, and rest to access elements of a list. Requirements regarding contract and purpose statements are suspended for this question.

(define message 

   '(oh ((there once) 

         (was (a)) 

         man (from (nantucket)))))

;; a. Write a function called message-a that extracts the list (was (a)) from the message.

(define (message-a) 

  '...)

(check-expect (message-a) '(was (a)))

;; b. Write a function called message-b that extracts the symbol 'a from the message. It should make use of the function message-a.

(define (message-b) 

  '...)

(check-expect (message-b) 'a)

;; c. Write a function called message-c that extracts the symbol 'from from the message.

(define (message-c)

  '...)

(check-expect (message-c) 'from)

;; 2. Using symbols, cons, and empty, define the value build-message that is equal to

;;    '((was (a)) man)

(define build-message '...)

(check-expect build-message '((was (a)) man))

;; 3. Write a function called ice-cream-flavor-maker that consumes a list of four symbols, and returns two lists of length two. The input type is (list-of symbol), and the output type is (list-of (list-of symbol)). For example:

;; (check-expect (ice-cream-flavor-maker '(the amazing chocolate fudge))

;;               '((the amazing) (chocolate fudge)))

;; (check-expect (ice-cream-flavor-maker '(an exquisite vanilla bean))

;;               '((an exquisite) (vanilla bean)))

;; 4. Write a function called all-divisible-by? that consumes a number and a (list-of number). It should return a boolean if every number in the list is divisible by the first argument. For example:

;; (check-expect (all-divisible-by? 3 empty) true)

;; (check-expect (all-divisible-by? 5 '(10 20)) true)

;; 5. Write a function called all-lists?. It should consume a list of anything and return true if all of the elements of the list are lists.

;; (check-expect (all-lists? '((a b) (c d))) true)

;; (check-expect (all-lists? '((a b) c)) false)

;; 6. Write a function called only-symbols?. It consumes a deep-list-of-symbols, where any element could be a list or a symbol. We might define a deep-list-of-symbols (abbreviated DLOS) as follows:

;; A DLOS is EITHER

;;  - empty OR

;;  - (cons symbol DLOS) OR

;;  - (cons DLOS DLOS)

;; Your function should return true if the data we are given conforms to this definition---meaning our data is only composed of symbols and lists.

;; For example:

;; (check-expect (only-symbols? '(a b c)) true)

;; (check-expect (only-symbols? '(a (b) c)) true)

;; (check-expect (only-symbols? '((the amazing) (chocolate fudge))) true)

;; 7. Write a function reverse-list that consumes a list and rebuilds it in reverse order. Your function may not use the built-in function reverse. This would be a good time to use a helper and program in the accumulator-passing style.

;; (check-expect (reverse-list '(1 2 3)) '(3 2 1))

;; 8. Write a function append-lists that consumes two lists and returns a single list. Your solution may not use the built-in function append.

;; (check-expect (append-lists '(1 2 3) '(4 5 6)) '(1 2 3 4 5 6))

;; 9. Write a function called palindrome? that consumes a list and determines whether that list contains the same sequence of symbols forwards and backwards. I solved this with a helper that recurred on indices, but I think you can solve it other ways as well. (For example, you could use 'reverse' and recur on two lists.)

;; (check-expect (palindrome? '(x p e d e x)) true)

;; 10. Write a function called flatten that consumes a DLOS and returns a flattened list.

;; (check-expect (flatten '(a (b c (d e)) f (g))) '(a b c d e f g))

;; 11. Define a function called fact that consumes a single number and calculates the factorial of that number.

;; (check-expect (fact 5) 120)

;; 12. Write a function called compress that eliminates sequential duplicates from a list.

;; (check-expect (compress '(a a a a b c c a a d e e e e))

;;               '(a b c a d e))

;; 15. Write a function dupli that duplicates each element of a list.

;; (check-expect (dupli '(a b c)) '(a a b b c c))

;; 16. Write a function repli that replicates each element of a list some number of times.

;; (check-expect (repli '(a b c) 3) '(a a a b b b c c c))

;; 17. Write a function, drop, that drops every n'th element of a list.

;; (check-expect (drop '(a b c d e f g h i) 3) '(a b d e g h))

;; 18. Write a function, slice, that slices a list.

;; (check-expect (slice '(a b c d e f g) 3 5) '(d e f))

;; 19. Write a function called checked-slice that first checks that the slice range is valid, and if it is, calls slice. If it is incorrect, use the function error to produce an error message.

;; 20. Write a function called split that takes a list and an index and splits the list after the given index. It should return a list of two lists.

;; (check-expect (split '(a b c d e f g) 3) '((a b c d) (e f g)))

;; 21. Write a function, rotate, that rotates a list n places to the left. This can make use of functions you've written previously, as well as list and append.

;; (check-expect (rotate '(a b c d e f g) 3) '(d e f g a b c))

;; 22. Write a function, range, that generates a list of numbers in a given range.

;; (check-expect (range 5 10) '(5 6 7 8 9 10))

;; 23. Write a function, rand-select, that selects a number of random elements from a list. Search the help desk for "random."

;; ;; Testing this is a bit tricky. You could do better.

;; (check-expect (length (rand-select '(a b c d e f) 3)) 3)

;; 24. Write a function called lotto that draws N random numbers from a given range. Using previously written functions is a good idea.

;; ;; For example:

;; ;; (lotto 5 15 30) => '(7 28 19 8 15)

;; (check-expect (length (lotto 5 15 30)) 5)

;; 25. Write a function called set-equal? that determines if two sets (represented as lists) contain all of the same elements. For example:

;; (check-expect (set-equal? '(1 2 3) '(2 3 1)) true)

;; (check-expect (set-equal? '(1 2) '(2 3 1)) false)

;; 26. Write a function called union that takes two sets and returns a set containing... er, their union. There should be no duplicates.

;; (check-expect (union '(1 2 3) '(2 4)) '(1 2 3 4)) ; Order does not matter in sets.

;; (check-expect (union '(1 2 3) '(1 2 3)) '(1 2 3))

;; 27. Write a function called intersect that takes two sets and returns a set containing only those elements in both of the sets.

;; (check-expect (intersect '(1 2 3) '(2)) '(2))

;; (check-expect (intersect '(1 2 3) '(1 3)) '(3))

;; (check-expect (intersect '(1 2 3) empty) empty)

(test)