Question

Using Racket, write a bridgely? function that takes a list of at least 3 numbers and returns #true if it is bridgely, otherwise #false. A list of numbers is called "bridgely" if it contains at least 3 numbers, and every number in the list,
except for the first and the last, is greater than both the first and the last number.

Thus, these lists are bridgely:
(list 1 2 3 4 5 6 5 4 3 2 1)
(list 0 4 4 4 4 4 2)

And these are not:
(list 1 2 3 4 5)
(list 1 1 2 3 4 3 2 1)

HERE IS MY CODE SO FAR BUT IT IS NOT CORRECT

; List of Numbers -> Numbers
; Produces the last number of the given list
(define (last-item lon)
(cond
[(empty? (rest lon)) (first lon)]
[else (last-item (rest lon))]))

; List of Numbers -> Boolean
; Produces true if list is a bridgley and false if list is not
(define (bridgely? lon)
(cond
[(empty? (first (first (rest lon)))) #f]
[(and (< (first lon) (first (rest lon)))
(< (last-item lon) (first (rest lon))))
(bridgely? (cons (first lon) (rest lon)))]
[else #f]))

Answer 1

check out the code and do comment if any queries.

---------------------------------------------------------

; function definition
(define (bridgely? lst fst last)
; 3 conditions defined in function
; 1. length == 1 : only last element is remaining so return true
; 2. compares each element with first and last, if true then recursively call the function
; 3. if above 2 conditions fails then return false
(cond
[( = (length lst) 1) (write #t)]
[(and ( > (first lst) fst) ( > (first lst) last)) (bridgely? (rest lst) fst last)]
[else (write #f)]))

; define a list and print it
(define lst (list 1 2 3 4 5 6 5 4 3 2 1))
(writeln lst)
; extract first and last element of the list
(define fst (first lst))
(define last (first (reverse lst)))

; list should contain minimum 3 elements, if true then function call else return false
(if ( >= (length lst) 3) (bridgely? (rest lst) fst last) (write #f))

---------------------------------------------------------------------------------------------------

code and output :

function definition (define (bridgely? 1st fst last) 3 conditions defined in function 1: only last element is remaining so return true ; 1. length ; 2. compares each element with first and last, if true then recursively call the function ; 3. if above 2 conditions fails then return false (cond [( = (length 1st) 1) (write #t)] [(and ( > (first 1st) fst) ( > (first 1st) last)) (bridgely? (rest 1st) fst last)] [else (write #f)])) 10 11 12 ; define a list and print it (define 1st (list 1 2 3 4 5 6 5 4 3 2 1)) (writeln 1st) ; extract first and last element of the list (define fst (first 1st)) (define last (first (reverse 1st))) 13 14 15 16 17 18 19 ; list should contain minimum 3 elements, if true then function call else return false (if ( >= (length 1st) 3) (bridgely? (rest 1st) fst last) (write #f))| 20 21 Execute Mode, Version, Inputs & Arguments Exect Result executed in 2.148 sec(s) (1 2 3 4 5 6 5 4 3 2 1) #t