February 14, 2017
Let’s begin with some sample data; the maximum occurs when you buy at 65 and sell at 150:
(define xs '(100 80 70 65 95 120 150 75 95 100 110 120 90 80 85 90))
The obvious solution is to compute all possible buy/sell pairs:
(define (buy-sell-quadratic xs) (let ((buy 0) (sell 0)) (do ((xs xs (cdr xs))) ((null? xs) (values buy sell)) (do ((ys (cdr xs) (cdr ys))) ((null? ys)) (let ((diff (- (car ys) (car xs)))) (when (< (- sell buy) diff) (set! buy (car xs)) (set! sell (car ys))))))))
> (buy-sell-quadratic xs) 65 150
That takes quadratic time. A better solution is a divide-and-conquer algorithm; split the array in two, then the solution is either in the first half of the array, or in the second half of the array, or is the low point of the first half and the high point of the second half. That takes time O(n log n) and space O(log n) for the recursion stack. We won’t write that code, because I always manage to get it wrong, and because there’s a still better solution.
The best solution is a linear scan over the input. We keep track of two values; the minimum value seen so far, which is initially the first value in the list, and the maximum profit, which is initially zero. Then at each step we make two computations;
(define (buy-sell-linear xs) (let ((buy (car xs)) (profit 0)) (do ((xs (cdr xs) (cdr xs))) ((null? xs) (values buy (+ profit buy))) (set! buy (min (car xs) buy)) (set! profit (max (- (car xs) buy) profit)))))
> (buy-sell-linear xs) 65 150
To test our program, we generate a thousand sample cases and compare the results of the two algorithms:
> (do ((k 1000 (- k 1))) ((zero? k)) (let ((xs (take 20 (shuffle (range 1000))))) (assert (call-with-values (lambda () (buy-sell-linear xs)) (lambda (buy sell) (- sell buy))) (call-with-values (lambda () (buy-sell-quadratic xs)) (lambda (buy sell) (- sell buy))))))
That will produce no output. You can run the program at http://ideone.com/R8ukSG, where you will also see the contributions from the Standard Prelude.
This exercise is a twist on the maxumum sum subsequence problem that we studied in a previous exercise. All you have to do is preprocess the input to a list of differences from one day to the next, then find the maximum sum subsequence.
EDIT: Thomas kindly pointed out in a comment below that I incorrectly reset the buy price when it was below the current minimum buy price, even when the new buy price didn’t lead to a new maximum difference. Here is the corrected code, which you can run at http://ideone.com/UvcdJ9:
(define (buy-sell xs) (let loop ((xs (cdr xs)) (lo (car xs)) (hi (car xs)) (min-lo (car xs)) (max-d 0)) (if (null? xs) (values lo hi max-d) (let* ((min-lo (if (< (car xs) min-lo) (car xs) min-lo)) (d (- (car xs) min-lo))) (if (< max-d d) (loop (cdr xs) min-lo (car xs) min-lo d) (loop (cdr xs) lo hi min-lo max-d))))))
Pages: 1 2