## CSci 1301: Lab 8

You may work in groups of 2 (preferred) or individually.

#### What to submit

At the end of the lab please send me and your group partner(s) all your Racket files as e-mail attachments. My e-mail is elenam at morris.umn.edu. The subject of your e-mail must be "1301 Lab 8" followed by "Final" or "Not final", depending on whether this is a final submission or you are still working on it. If you need to finish it, make sure to set up a time with your group partner(s) to finish the lab.

#### When to submit

Due Monday, November 29th, at 11:59pm. If you submit the final version during the lab, you are done.

### Problem 1 (10 points)

Question 1 Write a function `filter-function-builder` that builds filter functions, similarly to a building function for `map` or `foldr` here. Your function must take one parameter (a filtering criterion which is a function `X -> boolean`) and returns a function that filters a list of type X according to that criterion. For instance, using the filtering function builder allows us to create a function to filter out all odd numbers by passing `even?` to a `filter-builder`.

You may use `local` or `lambda` to define the function.

Question 2

Use your function to define the following functions. Use `lambda` to define the criterion function that is passed to filter-builder.

• `filter-div3` that takes a list of integers and creates a list of all its elements divisible by 3. For instance:
``````
(check-expect (filter-div3 (list 2 21 22 33 -1 -3)) (list 21 33 -3))
``````
Hint: use a predefined `remainder` function to check if a number is divisible by 3.
• `filter-longer-than-3` that takes a list of lists and leaves only lists of length 3 and shorter:
``````
(check-expect (filter-longer-than-3 (list (list 1 2 3 4) (list 1 2) (list 1 2 3) (list 1 2 3 4 5)))
(list (list 1 2) (list 1 2 3)))
``````
• `filter-a-b` that removes all symbols from a list of symbols that are not 'a or 'b:
``````
(check-expect (filter-a-b (list 'a 'c 'b 'd 'a)) (list 'a 'b 'a))
``````

### Problem 2 (8 points)

The following starting code includes a circle structure and its draw and clear functions and some helpful functions:

``````
;; The structure represents a circle
;; center is the position (posn structure) of the center
;; color is a symbol representing a color

;; draw-a-circle: circle -> true
;; the function draws a circle structure as a disk
;; and returns true
(define (draw-a-circle a-circle)
(draw-solid-disk (circle-center a-circle)
(circle-color a-circle))
)

;; clear-a-circle: circle -> true
;; the function clears a disk corresponding to a circle
;; and returns true
(define (clear-a-circle a-circle)
(clear-solid-disk (circle-center a-circle)
)

(define colors (list 'red 'green 'blue 'magenta 'cyan 'yellow 'orange 'purple))

(define (nth a-list n)
(cond
[(= n 0) (first a-list)]
[else (nth (rest a-list) (- n 1))]
)
)
``````

Write a function random-circle: integer -> circle that takes an integer number (which is not going to be used!!!) and creates a circle with a random position on the canvas, random radius, and a random color (use `nth` with a random parameter to select a color, see above). Test it by calling it with any integer parmeter and draw the resulting circle: ```(draw-a-circle (random-circle 5))```.

Use `build-list` to build a list of 50 circles, store the list in a variable (you will need to clear the circles later). Then use `map` to map the `draw-a-circle`. This will draw all the circles.

Use `sleep-for-while`, then clear the circles list by mapping the clear function over the list. Then create another list and draw and clear it using map.

### Problem 3 (10 points)

A prime number is defined as a positive integer greater than 1 divisible only by 1 and itself. The first five prime numbers are: 2, 3, 5, 7, 11. A common approach for generating prime numbers is known as Sieve of Eratosthenes. The algorithm starts off with a list of all integers up to some given N and then proceeds to "cross out" numbers that are divisible by 2, 3, 4, etc. The largest number that it needs to cross out is the sqaure root of N rounded up.

Use build-list to generate a list of all numbers from 2 to 1000. Use `lambda` to define a function passed to build-list.

Write a recursive function that takes a list, integer n, and a maximum integer. If n exceeds the maximum, the list is returned. Otherwise the function filters out numbers that are divisible by n from the result of the recursive call with n+1.

The criteria to filter must be writtten using `lambda`. Be careful when writing the criteria: make sure that you are not filtering out numbers that are divisible by themselves, or you will get an empty list.

Call the function with the list of numbers from 2 to 1000, 2 as the starting value of n, and square root of 1000 as the maximum. The resulting list will have all prime numbers between 2 and 1000.

Use Intermediate Student with lambda language level for this lab.

The views and opinions expressed in this page are strictly those of the page author. The contents of this page have not been reviewed or approved by the University of Minnesota.