Scheme Introduction Lab
As always an unreadable or unclear answer is a wrong answer.
Expressions
Enter the following expressions into the Scheme transcript window and write the results. If an expression is entered and nothing happens, check your parentheses!
1. (/ 10 (/ 10 (/ 10 2)))
2. (+ (* 3 12) 10)
3. (+ 2 4 6 8)
4. (define x 12)
5. (define y 20)
6. (* (- y x) (+ x y))
7. (define z (+ x y))
8. z
9. (define ans (+ z (* x 2)))
10. ans
11. (> 50 43)
12. (<= 3 53)
13. (define one 5)
14. (define two 10)
15. (= one 5)
16. (= two (* 2 one))
17. (define name 'george)
18. (eq? name 'george)
19. (eq? name name)
20. (eq? 'name 'george)
21. (and (= one 1) (eq? name 'george))
22. (or (= one 1) (eq? name 'george))
23. (not (= one 1))
Built-in Procedures
The following built-in procedures will identify different types and perform operations on those types. Write the results of each expression. (Note: Most questions will have several results, i.e. number (1) will have four results, so make it CLEAR which results go with each expression.)
1. (number? 5)
(string? 5)
(symbol? 5)
(boolean? 5)
2. (define str 5)
(number? str)
3. (string? str)
(string? 'str)
(string? "str")
4. (define num "this is a string")
(string? num)
5. (symbol? num)
(symbol? str)
(symbol? 'num)
(symbol? 'str)
6. (string-append "Laurie King")
7. (define first "Laurie")
(define second "King")
(string-append first second)
(define long (string-append first second))
long
8. (define false #t)
(boolean? false)
(boolean? #f)
9. (pair? '(1 2 43))
(list? '(1 2 43))
(pair? 21)
(define false '('yes "no" 12))
(pair? false)
10. (cons 'a '(b c))
(cons '(a) '(b c))
(cons 'a 'b)
(cons 'a (cons 'b '() ))
11. (eqv? (+ 4 5 6) (+ 6 5 4))
(eqv? 5 'five)
(eqv? (car '(a b c)) 'a)
12. (equal? (+ 3 2) 5)
(equal? '(1 2 3) '(1 (2 3)))
13. (null? '())
(null? '(1 2))
14. (car (cons 'a '(b c)))
(cdr (cons 'a '(b c)))
(cadr (cons 'a '(b c)))
15. (list? 'a) ;;(pair? ‘a)
16. (list? '(a b c)) ;;(pair? '(a b c))
Lists
A list data structure is central to Scheme as an abstract data type. A list is formed by enclosing any number of items within matching left and right parentheses. Write the resulting list for each expression shown below.
1. (define one (cons 'a (cons 'b (cons 'c '()))))
2. (define two (cons 'a (cons 'b 'c)))
3. one
4. two
5. (define rslt1 (car one))
6. (define rslt2 (car two))
7. (define rslt3 (caddr one))
8. (define rslt4 (caddr two)) ----Why error??
[Try (list? two) and (pair? two)]
9. (define lst (cons (cons 'a '()) (cons 'b (cons 'c '()))))
10. (define get-a (car (car (cdr '(b (a c) d)))))
11. (define get-b (car (cdaddr '(z (y) (x b) (a)))))
12. (define make-new (cons (car '(a b c)) (cdr '(1 2 3))))
13. (define ans1 (equal? (car '(a b)) (car (cdr '(b a)))))
14. (define ans2 (equal? (cons 'a '(b c))
The If-Construct
There are two syntactically correct forms for the if-construct:
(if <logical-test> <true-action> <false-action>)
(if <logical-test> <true-action>)
Enter the following lists:
(define lst1 '(1 2 3))
(define lst2 '(10 20 30))
(define lst3 '(15 25 35))
If we want the largest list returned/displayed, what should be put in place of the (?????) in the following if-construct? (Rewrite the whole if construct in your answer as if you did not know how the lists above were defined.)
(define get-true (if (< (car lst1) (car lst2)) (?????) (?????)))
More Practice with Lists
Using the symbols
one and two and the procedure cons, we can construct the list object(one two)
by typing (cons 'one (cons 'two '()))We can create the list object
((one) two)
by typing (cons (cons 'one '()) (cons 'two '()))Using the symbols
one, two, three, and four and the procedure cons, construct the following list objects.(one (two) three four)
(one (two three four))
(one (two three) four)
((one two) (three four))
For each of the following lists, write the expression using
car and cdr that extracts the symbol a. You can use abbreviations like cadr, caar, etc.(b c a d)
((b a) (c d))
(((a)))
((d c) (a) b)
Cond
The most widely used LISP syntactic form for conditional execution is
cond which has the following syntax:Each clause is evaluated in turn until a clause is encountered with a true logical-test, or until the else clause is encountered. When the first true clause is encountered, each associated expression is evaluated in left-to-right order. The result of the last expression evaluation is returned as the result of the cond.
(You may use lists from the above list section to fill in the following cond-construct.)