用特定票据表示金额

Question

我想在 Racket 中编写一个函数，它接受一定数量的钱和一个特定账单值的列表，然后返回一个列表，其中包含每种类型的账单数量，以使总金额达到给定。例如(calc 415 (list 100 10 5 2 1)) 应该返回'(4 1 1 0 0)。

我尝试过这种方式，但这不起作用：/ 老实说，我想我还没有完全理解在 Racket 中使用 set! 可以/不能做什么。

(define (calc n xs)
  (cond ((null? xs) (list))
        ((not (pair? xs)) 
          (define y n) 
          (begin (set! n (- n (* xs (floor (/ n xs)))))
                 (list (floor (/ y xs))) ))
        (else (append (calc n (car xs))
                      (calc n (cdr xs))))))

Answer 1

您的程序做的太多，并且您使用了不必要的突变。如果你把问题分开。

(define (calc-one-bill n bill)
  ...)

;; test 
(calc-one-bill 450 100) ; ==> 4
(calc-one-bill 450 50)  ; ==> 9

然后你可以制作：

(define (calc-new-n n bill amount)
  ...)

(calc-new-n 450 100 4) ; ==> 50
(calc-new-n 450 50 9)  ; ==> 0

然后你可以像这样减少你原来的实现：

(define (calc n bills)
  (if (null? bills)
      (if (zero? n)
          '()
          (error "The unit needs to be the last element in the bills list"))
      (let* ((bill (car bills))
             (amount (calc-one-bill n bill)))
        (cons amount
              (calc (calc-new-n n bill amount)
                    (cdr bills))))))

这将始终选择费用最少的解决方案，就像您的版本似乎所做的那样。两个版本都要求传递的bill 中的最后一个元素是单位1。对于更复杂的方法，它适用于(calc 406 (list 100 10 5 2))，并且可能找到所有解决方案的组合，请参阅Will's answer。

Answer 2

这个问题需要一些简单的递归非确定性编程。

• 我们从给定的金额和给定的面额列表开始，显然每张钞票的数量不受限制（否则，这将是一个不同的问题）。
• 在每个时间点，我们都可以使用最大的账单，也可以不使用。
• 如果我们使用它，总金额会减少帐单的价值。
• 如果总数为 0，我们就有了解决方案！
• 如果总数为负数，则无效，所以我们应该放弃这条路。

此处的代码将遵循我的another answer，它找出解决方案的总数（对于您的示例， 不止一个）。我们只需要考虑解决方案本身，而上面提到的代码只计算了它们。

我们可以将此编码为recursive-backtracking 过程，调用一个回调，每个成功找到的解决方案都从最深级递归内部（相当于最深使用递归创建的嵌套循环结构中的嵌套循环，是递归回溯的本质）：

(define (change sum bills callback)
  (let loop ([sum sum] [sol '()] [bills bills])    ; "sol" for "solution"
    (cond
       ((zero? sum)   (callback sol))              ; process a solution found
       ((< sum 0)      #f)
       ((null? bills)   #f)
       (else
        (apply
          (lambda (b . bs)                         ; the "loop":
              ;; 1.                                ; either use the first
            (loop (- sum b) (cons b sol) bills)    ;   denomination,
              ;; 2.                                ;   or,
            (loop    sum            sol     bs))   ;   after backtracking, don't!
          bills)))))

它将通过例如调用之一

;; construct `the-callback` for `solve` and call 
;;       (solve ...params the-callback)
;; where `the-callback` is an exit continuation

(define (first-solution solve . params)
  (call/cc (lambda (return)
      (apply solve (append params         ; use `return` as
                     (list return))))))   ; the callback

(define (n-solutions n solve . params)    ; n assumed an integer
  (let ([res '()])                        ; n <= 0 gets ALL solutions
    (call/cc (lambda (break)
        (apply solve (append params
                       (list (lambda (sol)
                               (set! res (cons sol res))
                               (set! n (- n 1))
                               (cond ((zero? n) (break)))))))))
    (reverse res)))

测试，

> (first-solution change 406 (list 100 10 5 2))

'(2 2 2 100 100 100 100)

> (n-solutions 7 change 415 (list 100 10 5 2 1))

'((5 10 100 100 100 100)
  (1 2 2 10 100 100 100 100)
  (1 1 1 2 10 100 100 100 100)
  (1 1 1 1 1 10 100 100 100 100)
  (5 5 5 100 100 100 100)
  (1 2 2 5 5 100 100 100 100)
  (1 1 1 2 5 5 100 100 100 100))

---

关于此代码的结构，请参阅。 How to generate all the permutations of elements in a list one at a time in Lisp? 它创建嵌套循环，解决方案可以在最里面的循环体中访问。

关于如何以适当的功能方式编写非确定性算法（一次做出所有可能的选择），请参阅How to do a powerset in DrRacket? 和How to find partitions of a list in Scheme。

Answer 3

我现在就是这样解决的:)

(define (calc n xs)
  (define (calcAssist n xs usedBills)
    (cond ((null? xs) usedBills)
          ((pair? xs) 
            (calcAssist (- n (* (car xs) (floor (/ n (car xs))))) 
                        (cdr xs) 
                        (append usedBills 
                                (list (floor (/ n (car xs)))))))
          (else 
            (if ((= (- n (* xs (floor (/ n xs)))) 0)) 
               (append usedBills (list (floor (/ n xs))))
               (display "No solution")))))

  (calcAssist n xs (list)))

测试：

> (calc 415 (list 100 10 5 2 1))
'(4 1 1 0 0)

Answer 4

我想这是我学习FORTRAN时写的第一个程序！这是一个版本，它毫不犹豫地使用了 Racket 提供的所有东西（或者，至少，我所知道的一切）。因此，它可能是一个糟糕的家庭作业解决方案，而且它肯定比我在 1984 年写的 FORTRAN 更漂亮。

请注意，此版本不搜索，因此即使不需要，它也会得到余数。当然，如果最小面额是 1，它永远不会得到余数。

(define/contract (denominations-of amount denominations)
  ;; split amount into units of denominations, returning the split
  ;; in descending order of denomination, and any remainder (if there is
  ;; no 1 denomination there will generally be a remainder).
  (-> natural-number/c (listof (integer-in 1 #f))
      (values (listof natural-number/c) natural-number/c))
  (let handle-one-denomination ([current amount]
                                [remaining-denominations (sort denominations >)]
                                [so-far '()])
    ;; handle a single denomination: current is the balance,
    ;; remaining-denominations is the denominations left (descending order)
    ;; so-far is the list of amounts of each denomination we've accumulated
    ;; so far, which is in ascending order of denomination
    (if (null? remaining-denominations)
        ;; we are done: return the reversed accumulator and anything left over
        (values (reverse so-far) current)
        (match-let ([(cons first-denomination rest-of-the-denominations)
                     remaining-denominations])
          (if (> first-denomination current)
              ;; if the first denomination is more than the balance, just
              ;; accumulate a 0 for it and loop on the rest
              (handle-one-denomination current rest-of-the-denominations
                                       (cons 0 so-far))
              ;; otherwise work out how much of it we need and how much is left
              (let-values ([(q r)
                            (quotient/remainder current first-denomination)])
                ;; and loop on the remainder accumulating the number of bills
                ;; we needed
                (handle-one-denomination r rest-of-the-denominations
                                         (cons q so-far))))))))