How to get the cheapest fruit - list

Question

I am practicing DrRacket. Here is the task description:
Recursion is not allowed, you must use filter or map/or/andmap or foldr/foldl to loop through lists. creat a function names cheapest-fruit=bundle and receive a list of fruits as parameter. you input lists of fruit-bundles and want to get the cheapest fruit-bundle. If two fruit-bundles are both the cheapest, then chose the one with more kinds of fruit.
(define-struct fruit (name price))
(define (cheapest-fruit-bundle fruits)...)
check-expected:
giving list: (list (list (make-fruit 'apple 3) (make-fruit 'banana 4) (make-fruit 'avocado 5))
(list (make-fruit 'apple 7)(make-fruit 'avocado 5))
(list (make-fruit 'apple 7)(make-fruit 'avocado 9) (make-fruit 'banana 2)))
results: (list (make-fruit 'apple 3) (make-fruit 'banane 4) (make-fruit 'avocado 5))
I have solved this problem a bit: I can sum up the price in list and find the smallest element. But I want to get the cheapest bundle and choose the bundle with more kinds of fruits. I get stucked in this step. Furthermore, my function to choose smallest element not meet requirement, because I use recursion of list itself, and I should use map/foldr/foll.filter.
Here is what I have tried；
(define (sum-price f) (foldl + 0 (map fruit-price f)))
(define (smallest l)
(cond [(empty? (rest l)) (first l)]
[else (local ((define smallest-in-rest (smallest (rest l))))
(if (< (first l) smallest-in-rest) (first l) smallest-in-rest))]))
(define (cheap-fruit-bundle myfruit)
(smallest (map (lambda (fruit-list) (sum-price fruit-list)) myfruit)))
my code give out at end only a number. I have spent hours on this task and can't think up new ideas. Thanks for help in advance.

Answer 1

cheapest-budle-and-max-optioin function process is:
If budle-1's price less than budle-2's price we choice budle-1.
Or budle-1's price might bigger or equal to budle-2's price. If budle-1's price bigger than budle-2 we choice budle-2.
Or two budle price is the same. Than we compare options.
Notice: In here if we have many budles have same price and same option number we still choice one budle.
After finish cheapest-budle-and-max-optioin process. Using foldlr to compare each budle element in list.
(define-struct fruit (name price) #:transparent #:mutable)
(define (filter-cheapest-budle-and-max-optioin budle-list)
(local [(define (budle-price budle-list)
(foldl + 0 (map fruit-price budle-list)))
(define (budle-option-n budle-list)
(foldl (lambda (x1 x2) (+ x2 1)) 0 budle-list))
(define (budle-option<? b1 b2)
(< (budle-option-n b1) (budle-option-n b2)))
(define (budle-price<? b1 b2)
(< (budle-price b1) (budle-price b2)))
(define (cheapest-budle-and-max-optioin b1 b2)
(cond
[(budle-price<? b1 b2) b1]
[(budle-price<? b2 b1) b2]
[(budle-option<? b1 b2) b2]
[else b1]))]
(foldr cheapest-budle-and-max-optioin (first budle-list) budle-list)))
;;; TEST
(define budle-list1
(list
(list (make-fruit 'apple 0.5)
(make-fruit 'banana 0.5))
(list (make-fruit 'apple 1))
(list (make-fruit 'avocado 1))))
(define budle-list2
(list
(list (make-fruit 'apple 1)
(make-fruit 'banana 1))
(list (make-fruit 'apple 2))
(list (make-fruit 'avocado 2))))
(filter-cheapest-budle-and-max-optioin budle-list1) ; should be (list (fruit 'apple 0.5) (fruit 'banana 0.5))
(filter-cheapest-budle-and-max-optioin budle-list2) ; should be (list (fruit 'apple 1) (fruit 'banana 1))

Answer 2

When you get stuck in a programming problem, a good strategy is to break that problem down into the smallest parts that make sense. You can focus on small problems that are easier to solve, and then combine those parts into the final solution. After you have a working solution, you can refactor if you wish, combining the smaller procedures into larger ones.
Here is one way that you can break your problem down into smaller parts.
You already have a working definition for sum-price, although I am going to change the name here:
(define-struct fruit (name price))
(define fruit-bundles (list (list (make-fruit 'apple 3)
(make-fruit 'banana 4)
(make-fruit 'avocado 5))
(list (make-fruit 'apple 7)
(make-fruit 'avocado 5))
(list (make-fruit 'apple 7)
(make-fruit 'avocado 9)
(make-fruit 'banana 2))))
(define (bundle-price bundle)
(foldl + 0 (map fruit-price bundle)))
Now, we want to be able to take a list of fruit-bundles and get to the largest, cheapest fruit bundle of the list. The first part of this problem seems to be that we want to get a list of all of the cheapest bundles; after that we can worry about getting the largest bundle.
I'd like to do something like this to get a list of the cheapest bundles, using filter with an anonymous procedure that returns true when the bundle price is equal to the minimum bundle price:
;; Takes a list of fruit-bundles and returns a list of the cheapest bundles.
(define (cheapest-bundles bundles)
(filter (lambda (b) (= (bundle-price b)
(min-bundle-price bundles)))
bundles))
I already have bundle-price, so I just need to write min-bundle-price. Since I know that I can map over a list of fruits to get a list of prices, I just need to apply the min procedure to that list:
;; Takes a list of fruit-bundles and returns the minimum bundle price.
(define (min-bundle-price bundles)
(apply min (map bundle-price bundles)))
Now I have a way to get a list of the cheapest fruit bundles. Now, lets test the cheapest-bundles procedure:
scratch.rkt> (cheapest-bundles fruit-bundles)
'((#<fruit> #<fruit> #<fruit>) (#<fruit> #<fruit>))
Well, that looks ok, but we can't really see what is in the fruit structs. Let's just write a couple of utility procedures to help us see inside the structs:
;; A couple of utility functions for inspecting fruits.
(define (inspect-fruit f)
(list (fruit-name f) (fruit-price f)))
(define (inspect-fruit-bundle bundle)
(map inspect-fruit bundle))
Now let's try again:
scratch.rkt> (map inspect-fruit-bundle (cheapest-bundles fruit-bundles))
'(((apple 3) (banana 4) (avocado 5)) ((apple 7) (avocado 5)))
That is what we expected; this is a list containing the two cheapest fruit bundles.
Now we need to devise a way to get the largest fruit bundle from this list of the cheapest fruit bundles. But, it could be the case that there are multiple fruit bundles that are the same size; in that case, let's agree to take the first bundle from a list of the largest bundles. So, we plan on creating a list of largest bundles, and we want the first element from that list:
;; Takes a list of bundles and returns the largest bundle.
;; If there are multiple largest bundles, the first one in the list is returned.
(define (largest-bundle bundles)
(car (largest-bundles bundles)))
We will need to write largest-bundles, which we can write in a way similar to the cheapest-bundles procedure by using filter to create a list of bundles with counts that are equal to the maximum count for all bundles:
;; Takes a list of fruit-bundles and returns a list of the largest bundles.
(define (largest-bundles bundles)
(filter (lambda (b) (= (bundle-count b)
(max-bundle-count bundles)))
bundles))
Before, we needed to get the price for a bundle, but now we will need to get a count of the number of kinds of fruits in a bundle:
;; Takes a fruit-bundle and returns the number of fruit elements.
(define (bundle-count bundle)
(length bundle))
Now we just need to write the max-bundle-count procedure. We can do this in a way similar to what we did for the min-bundle-price procedure, by applying the max procedure to a list of bundle counts:
;; Takes a list of fruit-bundles and returns the maximum bundle count.
(define (max-bundle-count bundles)
(apply max (map bundle-count bundles)))
Now we have a procedure that will get us a list of the largest fruit bundles, and another procedure that takes the first one from this list so that multiple hits are handled. Let's test them:
scratch.rkt> (map inspect-fruit-bundle (largest-bundles fruit-bundles))
'(((apple 3) (banana 4) (avocado 5)) ((apple 7) (avocado 9) (banana 2)))
scratch.rkt> (inspect-fruit-bundle (largest-bundle fruit-bundles))
'((apple 3) (banana 4) (avocado 5))
As expected, largest-bundles returns a list of the two largest fruit bundles, and largest-bundle returns the first fruit bundle in that list.
Now we just have to combine the above to create the cheapest-fruit-bundle procedure:
;; Takes a list of fruit-bundles and returns the largest, cheapest bundle.
(define (cheapest-fruit-bundle bundles)
(largest-bundle (cheapest-bundles bundles)))
Remembering to use inspect-fruit-bundle so that we can easily read the results, here is the final result:
scratch.rkt> (inspect-fruit-bundle (cheapest-fruit-bundle fruit-bundles))
'((apple 3) (banana 4) (avocado 5))