Finding min and max of list - racket

Question

(define (find-extrema-helper xs max min length)
(if (null? xs)
(printf "The maximum of your list is ~a and the minimum is ~a." max min)
(let ((head (car xs))
(tail (cdr xs)))
(when (> head max)
(set! max head))
(when (< head min)
(set! min head))
(when (not (null? length))
(set! length (- length 1)))
(when (equal? length 0)
(set! xs null))
(find-extrema-helper tail max min length))))
(define (find-extrema xs)
(let ((max (car xs))
(min (car xs)))
(find-extrema-helper xs max min null)))
(define (find-extrema-sublist-helper xs first length)
(if (> first 0)
(let ((head (car xs))
(tail (cdr xs))
(first (- first 1)))
(find-extrema-sublist tail first length))
(let ((max (car xs))
(min (car xs)))
(find-extrema-helper xs max min length))))
(define (find-extrema-sublist xs first last)
(set! last (- last first))
(find-extrema-sublist-helper xs first last))
Everything works fine except when finding the maximum of the sublist, it's like the length variable is being ignored and it's finding the maximum of the whole list. Thanks for your help.

Answer 1

You almost never need `set!´, and you should recurse over the structure of the list, not its length.
For a nonempty list, the maximum is
the car, if the list has one element (i.e. its tail is the empty list),
the greatest of the car and the maximum of the cdr, if the list is longer.
That is,
(define (max-element x y) (if (> x y) x y))
(define (max-list ls)
(if (null? (cdr ls))
(car ls)
(max-element (car ls) (max-list (cdr ls)))))
The same principle applies to the minimum.
(define (min-element x y) (if (< x y) x y))
(define (min-list ls)
(if (null? (cdr ls))
(car ls)
(min-element (car ls) (min-list (cdr ls)))))
Now you need both, so you should produce a pair (or some other structure).
The trivial method is to use both the previous functions,
(define (extrema ls) (cons (min-list ls) (max-list ls)))
but this is inefficient, since it traverses the list twice.
Let's do better.
This is the same idea applied to both values at the same time:
(define (extrema ls)
(if (null? (cdr ls))
(cons (car ls) (car ls))
(let ((cdr-extrema (extrema (cdr ls)))
(head (car ls)))
(cons (min-element head (car cdr-extrema))
(max-element head (cdr cdr-extrema)))))

Answer 2

Try this:
(define (find-extrema xs)
(if (null? xs) "Empty list."
(printf "The maximum of your list is ~a and the minimum is ~a."
(apply max xs)
(apply min xs))))
If your function expects list as argument, this list can be empty. null? returns #true, if xs is empty list. (null? '()) => #t.
If you need to compare some number with zero, use (= 0 number) instead.
Scheme has in-built functions min and max, but you can't use them on list: (max 1 2 3 4 5) => 5, (max '(1 2 3 4 5)) => error.
But there is apply, which does exactly what you need. (apply max '(1 2 3 4 5)) => (max 1 2 3 4 5) => 5.
By the way, when you name your variables, check whether that name isn't already used (for example min, max, length, first, last). Type that name into REPL and see result: max => #<procedure:max>. Scheme allows you to change value for that variable in given scope, but you will lost previous value. Compare these two functions:
(define (f1 xs first)
(first xs))
(define (f2 xs first-elem)
(first xs))
, that are called like this:
> (f1 '(1 2 3) 1)
> (f2 '(1 2 3) 1)
EDIT: Solution without built-in min and max:
(define (find-extrema-help xs min-num max-num)
(if (null? xs)
(printf "The maximum of your list is ~a and the minimum is ~a." max-num min-num)
(find-extrema-help (cdr xs)
(if (< (car xs) min-num) (car xs) min-num)
(if (> (car xs) max-num) (car xs) max-num))))
(define (find-extrema xs)
(if (null? xs) "Empty list."
(find-extrema-help (cdr xs)
(car xs)
(car xs))))
Find-extrema-sublist:
(define (drop xs number)
(cond ((null? xs) xs)
((= 0 number) xs)
(else (drop (cdr xs) (- number 1)))))
(define (take xs number)
(cond ((null? xs) '())
((= number 0) '())
(else (cons (car xs) (take (cdr xs) (- number 1))))))
(define (find-extrema-sublist xs down-index top-index)
(let ((len (- top-index down-index)))
(find-extrema (take (drop xs down-index)
len))))