- Write a function that squares a number
;square : number -> number
(define (square number)
(* number number)
)
(square 5)
- Write a function that converts fahrenheit to celsius
;converter : number -> number
(define (converter f_degree)
(/ (- f_degree 32) 1.800)
)
(converter 200)
- Write a function that takes farhenheit and returns "brrr" if the temperature in celsisus is less than zero, and "could be worse" if the temperature in celsisus is above zero. (Edge case: what if it is zero? I'll decide it'll return "brrr".)
#lang racket
;converter : number -> number
(define (converter f_degree)
(/ (- f_degree 32) 1.800)
)
;weather-man : number -> string
(define ( weather-man f_degree )
( if (
<=
(converter f_degree)
0
)
"brr"
"could be worse"
)
)
(converter 10)
(weather-man 10)
(converter 200)
(weather-man 200)
(converter 32)
(weather-man 32)
- Write a function that returns a greeting based on a name and a language (english, spanish).
;greeting-getter : string -> string
(define (gretting-getter language)
(
case language
[( "english" ) "hello" ]
[( "spanish" ) "hola" ]
[else "[language not found]" ]
)
)
;greeting : string -> string
(define ( greeting name language )
(string-append ( gretting-getter language) " " name )
)
(greeting "alice" "english")
(greeting "bob" "spanish")
(greeting "charlie" "esperanto")
- Write a function that calculates the surface area of a pipe.
;todo - find out how to actually calculate a surface area of the pipe
;pipe-surface-area : number number number -> number
(define (pipe-surface-area outer-radius core-radius length)
(* (* core-radius (* 2 pi) ) (+ core-radius length ) )
)
(pipe-surface-area 0 10 100)
- Write a function that takes a list and return the length of that list.
;length : list -> number
(define (length list)
(cond
[ ( null? list ) 0]
[ ( null? (cdr list ) ) 1]
[ else (+ (length (cdr list)) 1) ]
)
)
( length `(1 2 3 4 5 6))
( length null )
- Write a function that searches a list for an item and return the index of that item...or -1 if the item cannot be found.
; end-of-list? : list -> boolean
(define (end-of-list? list)
( null? list )
)
; find-element-index : list number number -> number
(define (find-element-index list element ( index 0 ) )
(cond
[ ( end-of-list? list ) -1 ]
[ ( equal? element (car list) ) index]
[ else (find-element-index (cdr list) element (+ 1 index) ) ]
)
)
( find-element-index `(1 2 3 4 5 6) 2)
( find-element-index null 2)
( find-element-index `(1 2 3 4 5 6) 7)
( find-element-index `(1 2 3 4 5 6) 6)
- Write a function that takes a list and an index and returns the element at that index.
; end-of-list? : list -> boolean
(define (end-of-list? list)
( null? list )
)
;index : list number -> element
( define ( index list integer )
(cond
[( end-of-list? list ) "out of bounds exception" ]
[( equal? 0 integer ) (car list) ]
[ else (index ( cdr list ) (- integer 1 ) ) ]
)
)
( index `(1 2 3 4 5 6) 2)
( index null 2)
( index `(1 2 3 4 5 6) 5 )
( index `(1 2 3 4 5 6) 6 )
- Write a function that takes a list and returns a new list containing just the first and last element.
; end-of-list? : list -> boolean
(define (end-of-list? list)
( null? list )
)
; last-element? : list -> boolean
(define (last-element? list)
( end-of-list? (cdr list ) )
)
; last-element : list -> element
(define (last-element list )
(if
( last-element? list)
( car list )
( last-element (cdr list) )
)
)
; alternative approach
; last-element : list -> element
;(define (last-element list)
; (cond
; [(last-element? list) (car list)]
; [ else (last-element (cdr list))]
; )
;)
; first-and-last : list -> list
( define ( first-and-last list)
(
if
(null? list)
"list is null"
(cons
(car list)
(if ( null? (cdr list) ) null (last-element list ) )
)
)
)
( first-and-last `(1 2 3 4 5 6))
( first-and-last `(1))
( first-and-last null)
( first-and-last `(1 2))
- Write a function that only returns even numbers from a list.
;is-even : number -> boolean
(define (is-even number)
( equal? 0 ( remainder number 2))
)
;even-numbers : list -> list
(define (even-numbers numbers)
(cond
[ ( empty? numbers ) null ]
[ (is-even (car numbers) ) (cons (car numbers) (even-numbers ( cdr numbers )))]
[ else ( even-numbers ( cdr numbers ))]
)
)
(even-numbers '(1 2 3 4 5 6))
(even-numbers '(1 3 5))
(even-numbers '(-1 -2 -3 -4 -5 -6))
- Write a function that returns items from a list that match a provided criteria. The criteria will be a function that returns true or false given an item. You should be able to re-implement the last list drill using the function you write in this drill
;is-even : number -> boolean
(define (is-even number)
( equal? 0 ( remainder number 2))
)
;filter : list conditional -> list
(define (filter target-list conditional)
(define (filter-rest target-list)
(filter (cdr target-list) conditional)
)
(cond
[ ( empty? target-list ) null ]
[ (conditional (car target-list) ) (cons (car target-list) (filter-rest target-list))]
[ else (filter-rest target-list)]
)
)
;even-numbers : list -> list
(define (even-numbers list)
( filter list is-even)
)
(even-numbers '(1 2 3 4 5 6))
(even-numbers '(1 3 5))
(even-numbers '(-1 -2 -3 -4 -5 -6))
(even-numbers '(2 4 6))
- Write a function that triples all numbers in a list, filter out the odds, and sum the remaining numbers. Use Racket's higher order functions for this.
- First, let's try writing our own higher-order functions.
; is-even : number -> boolean
(define (is-even number)
( equal? 0 ( remainder number 2))
)
; filter : list conditional -> list
(define (filter target-list conditional)
(define (filter-rest target-list)
(filter (cdr target-list) conditional)
)
(cond
[ ( empty? target-list ) null ]
[ (conditional (car target-list) ) (cons (car target-list) (filter-rest target-list))]
[ else (filter-rest target-list)]
)
)
; sum : list -> number
(define (sum target-list)
(
cond
[ ( empty? target-list ) 0 ]
[ else (+ (car target-list) (sum (cdr target-list)))]
)
)
; triple : list -> list
(define (triple target-list)
(
cond
[ ( empty? target-list ) null ]
[ else (cons (* 3 (car target-list)) (triple (cdr target-list)))]
)
)
; triple-even-sum : list -> number
(define (triple-even-sum target-list)
(sum ( filter (triple target-list) is-even) )
)
(triple '(1 2 3 4 5 6) )
(filter (triple'(1 2 3 4 5 6)) is-even)
(triple-even-sum '(1 2 3 4 5 6))
(triple-even-sum '())
(triple-even-sum '(4))
- Now that we understood the problem better, let's refactor our code to use Racket's built-in functions (in this case,
apply, filter, and map).
; is-even : number -> boolean
(define (is-even number)
( equal? 0 ( remainder number 2))
)
; triple : number -> number
(define (triple number)
(* 3 number)
)
; sum : list -> number
(define (sum target-list)
( apply + target-list)
)
; triple-even-sum : list -> number
(define (triple-even-sum target-list)
(sum ( filter is-even (map triple target-list) ) )
)
(triple-even-sum '(1 2 3 4 5 6))
(triple-even-sum '())
(triple-even-sum '(4))
- Write a function that checks if all characters in a list are lowercase. Note that characters are different from strings (for example, this is a character
#\b).
; is-valid? : element conditional -> boolean
(define ( is-valid? element conditional )
( conditional element )
)
; is-lowercase-character? : list -> boolean
(define (is-lowercase-character? element )
(and ( char? element ) ( char-lower-case? element ) )
)
; all? : list function -> boolean
; note - need to return false if list is already empty
(define (all? target-list conditional)
(define (end-of-list? target-list)
(empty? (cdr target-list))
)
(define (first-element-matches? target-list)
(is-valid? (car target-list) conditional)
)
(define (successful-match? target-list)
(and (first-element-matches? target-list) ( end-of-list? target-list ) )
)
(cond
[ (empty? target-list ) #f ]
[ (successful-match? target-list) #t]
[ (first-element-matches? target-list) (all? (cdr target-list) conditional)]
[ else #f ]
)
)
; all-lowercase-characters : list -> boolean
(define (all-lowercase-characters? target-list)
(all? target-list is-lowercase-character? )
)
(all-lowercase-characters? '(1 2 3 4 5 6))
(all-lowercase-characters? '())
(all-lowercase-characters? '("alice"))
(all-lowercase-characters? '(#\b))
(all-lowercase-characters? '(#\b #\c #\d #\e))
(all-lowercase-characters? '(#\b #\c #\d #\E))
- Write
map . map should take a function and a list as arguments. It should return a new list.
; map : function list -> list
(define (map function target-list)
(
if
(empty? target-list )
null
(cons (function (car target-list)) (map function (cdr target-list)))
)
)
; double : number -> number
(define (double x)
(* 2 x)
)
(map double '(1 2 3 4 5) )
(map double '() )
- Write two functions
greet-english and greet-spanish, using the greeting function you created above.
;greeting-getter : string -> string
(define (gretting-getter language)
(
case language
[( "english" ) "hello" ]
[( "spanish" ) "hola" ]
[else "[language not found]" ]
)
)
;greeting : string string -> string
(define ( greeting name language )
(string-append ( gretting-getter language) " " name )
)
;greet-english : string -> string
(define (greet-english name)
(greeting name "english")
)
;greet-spanish : string -> string
(define (greet-spanish name)
(greeting name "spanish")
)
(greet-english "Alice")
(greet-spanish "Bob");greeting-getter : string -> string
(define (gretting-getter language)
(
case language
[( "english" ) "hello" ]
[( "spanish" ) "hola" ]
[else "[language not found]" ]
)
)
;greeting : string string -> string
(define ( greeting name language )
(string-append ( gretting-getter language) " " name )
)
;greet-curry : string -> procedure
(define (greet-curry name)
(curry greeting name)
)
;greet-english : string -> string
(define (greet-english name)
((greet-curry name) "english")
)
;greet-spanish : string -> string
(define (greet-spanish name)
((greet-curry name) "spanish")
)
(greet-english "Alice")
(greet-spanish "Bob")
- With Currying (Right-To-Left Argument Accumlation)
;greeting-getter : string -> string
(define (gretting-getter language)
(
case language
[( "english" ) "hello" ]
[( "spanish" ) "hola" ]
[else "[language not found]" ]
)
)
;greeting : string string -> string
(define ( greeting name language )
(string-append ( gretting-getter language) " " name )
)
;greet-curryr : string -> procedure
(define (greet-curryr language)
(curryr greeting language)
)
;greet-english : procedure
(define greet-english
(greet-curryr "english")
)
;greet-spanish : procedure
(define greet-spanish
(greet-curryr "spanish")
)
(greet-english "Alice")
(greet-spanish "Bob")