Racket代写 | CIS 352 Quiz0 and Quiz1 / Sample questions

Question Format
Objective #N [ do not title questions, it makes it even easier for students to collude ]
[potential code / diagram / figure that will be referenced in the question]
Satisfactory:
[problem description that outlines what the student must answer to be marked as
satisfactory. Note that small mistakes (e.g., typos such as 1-2 misplaced
parentheses where the TA can understand what the student meant without spending
>60seconds) are okay if they do not compromise the essence of the answer.]
Excellent:
[an add-on to the satisfactory problem, usually a bit harder, that the student must
perform to get this question right. Note that they can only get the excellent mark if
they both get a good solution and also have a nearly-100% correct answer to the
satisfactory part]
Objective #1: “Identify expressions, forms, and callsites (in
Racket)”
Question 1Sample
Satisfactory:
Both A-B required for satisfactory

How many callsites does the following piece of Racket code contain:
(define (foo) (bar (baz)))
(define (bar x) (baz))
(define (baz) (+ 1 (bar x)))
Explain why the following Racket expression prints 3 rather than 1.
(let ([x 3]) (let ([x 1] [y x]) y))
Excellent:
A student believes that one of the guards to their if forms is incorrect, so they
deﬁne the following helper function:
(define (if guard e-true e-false)
(displayln (format “guard is ~a” guard))
(if guard e-true e-false))
Aside from printing to the console, are there any other ways in which deﬁning
this helper function may change the behavior of the program? Give a precise
explanation (with example code, if possible) of how this may happen.

Satisfactory:
Both A-B required for satisfactory
(A)How many callsites does the following Racket expression contain?
(g (f ((lambda (x) x) 2))1)2 3

(B) Consider the following Racket expression using let*:
(let ([x (let* ([x 1] [y x]) y)]) x)
How could this expression be written without let* (using only let). For your
solution to receive credit, it must still include bindings for each of x and y within
(let ([x (let ([x 1]) (let ([y x])) y)]) x)
(let* ([x 1]
[y …])
…)
(let ([x 1]) (let ([y …]) …)…)
Excellent:
In class, we have discussed that or is not a Racket function, but rather it is a
form. In general, for arbitrary expressions e-ﬁrst and e-second the following two
Racket snippets are not identical (in the sense that you could replace one with
the other).
(deﬁne (loop) (loop))
(if #t #t (loop)) ;; #t
(if #t #t (loop)) ;; #t
((lambda (x y) (if x x y)) #t (loop)) ;; function call to (lambda (x y) …)

E-mail: vipdue@outlook.com  微信号:vipnxx