## Quiz 1

### Instructions

• The quiz consists of five questions and one image. Be sure that you have all of these items and that they are all legible.

• Read all questions and their instructions thoroughly before you begin. It is always worth your time to plan ahead!

• You have also been given two blank pages. Use these sheets for your quiz answers. Write your name on each sheet.

• The quiz is worth 60 points. Each question is worth twelve points.

• Keep the quiz questions when you are done, for future reference.

• Points will be awarded based on your explicit answers. Partial credit will be given where possible, so show all of your work.

• The quiz lasts thirty (30) minutes. It is due at 1:45 PM.

### Exercises

1. Write brief answers for each of the following items. (One phrase or code expression is usually sufficient for each question.)

• One of the three things that every programming language has is a means of combination. What is Racket's only means of combination? Give an example to illustrate your answer.

• What are the other two things that every programming language has? Give an example of each from Racket.

• We say that define is a special form. What does that mean? List one way we can know that is true from define's behavior.

• What does it mean to say that a function is variable arity?

2. Answer each of these questions about the structure of Racket lists.

• Write the Racket list literal that corresponds to this box-and-pointer diagram. • Draw a box-and-pointer diagram that corresponds to this Racket list literal.
```
'(if (positive? n) n (- n))
```

3. Write a Racket function named line-item-cost that takes three arguments, all numbers: the number of items being purchased, the price per item, and the sales tax rate. line-item-cost returns the total cost for this purchase, including sales tax. For example:
```     > (line-item-cost 1 1.00 0.05)      ; 1 x \$1.00, plus 5%
1.05

> (line-item-cost 4 5.00 0.07)      ; 4 x \$5.00, plus 7%
21.40

> (line-item-cost 6 10.00 0.15)     ; 6 x \$10.00, plus 15%
69.00
```
You may write a helper function, but do not have to.

4. Write a Racket function named fun-less-than that takes two arguments, functions f and g. Both f and g take a single integer argument.

fun-less-than returns a function of one argument, an integer n. The returned function computes the value f(n) < g(n). For example:
```    > (define double (lambda (n) (* n 2)))
> (define square (lambda (n) (* n n)))
> (define 2n+1   (lambda (n) (add1 (double n))))

> ((fun-less-than double square) 2)  ; is (2*2) < (2*2)?
#f
> ((fun-less-than double square) 5)  ; is (5*2) < (5*5)?
#t

> (define 2n+1<n²? (fun-less-than 2n+1 square))

> (2n+1<n²? 5)     ; because 11 < 25
#t
> (2n+1<n²? 2)     ; because 5 is not < 4
#f
```
You'll earn a bonus point if you don't use an if or a cond in your solution. Boolean values are values, too!

5. Suppose that we have a list of pixels from an image, where each pixel is a list (r g b) containing the red, green, and blue (RGB) values of the pixel:
```     ( (76 195 202) (255 71 208) (175 81 214) (0 165 81) ... )
```
Write a Racket function named least-red-green that takes one argument, a list of pixels lst in this form. least-red-green computes the sum of the red and green values for every pixel in lst and returns the smallest of the sums. For example:
```     > (least-red-green '((1 3 5)))
4

; the red + green sums are 220 and 480, respectively
> (least-red-green '((100 120 140) (240 240 240)))
220

; trust me: this pixel has smallest red + green ||||||
;                                               vvvvvv
> (least-red-green '((76 195 202) (255 71 208) (175 81 214)))
256
```
Use the higher-order functions apply and map as needed to implement your function. No recursion or looping are allowed!

You will want to use Racket's variable-arity min function in your solution.

Eugene Wallingford ..... wallingf@cs.uni.edu ..... February 8, 2023