Question

这是我的代码：


(defun count-toys (sorted budget spent num-bought)
    (cond ((> spent budget) (- num-bought 1))
          ((count-toys (cdr sorted) 
                       budget 
                       (+ spent (car sorted)) 
                       (+ num-bought 1)))))

(defun maxToys (numToys budget prices)
  (setq sorted (sort prices #'<))
  (count-toys sorted budget 0 0))

(print (maxToys numToys budget prices))

最后一行具有print语句，该语句打印由功能count-toys返回的解决方案。但是，在打印解决方案之前，lisp还会打印空白行。

如何摆脱空白行？

Answer 1

我对您的代码的看法：

(defvar *prices* '(45 87 897 565 8 57 875 59))
(defvar *budget* 1000)

(defun count-toys (sorted budget spent num-bought)
  (if (not (and sorted (>= budget (+ spent (car sorted)))))
      num-bought
      (count-toys (cdr sorted) budget (+ spent (car sorted))
          (1+ num-bought))))

(defun max-toys (budget prices)
  (let ((sorted (sort (copy-list prices) #'<)))
    (count-toys sorted budget 0 0)))

(prin1 (max-toys *budget* *prices*))

示例输出：

USER> (prin1 (max-toys 100 '(5)))
1
1
USER> (prin1 (max-toys 100 '(101)))
0
0
USER> (prin1 (max-toys 100 '(70 20)))
2
2
USER> (prin1 (max-toys 100 '(70 10 20)))
3
3
USER> (prin1 (max-toys 100 '(70 10 21)))
2
2
USER> (sort *prices* #'<)
(45 57 59 87 565 875 897)
USER> (prin1 (max-toys *budget* *prices*))
5
5

不需要变量numToys（未使用）。我写的是max-toys而不是maxToys：它更像是'Lispy'（但我对此不是教条……）而且（再次如Rainer所说）使用prin1而不是{ {1}}避免在输出之前多余的空行。

Answer 2

这是LOOP版本：

(defun spend-greedily (prices budget)
  (loop
     for spent = 0 then next-spent
     for count from 0
     for price in prices
     for next-spent = (+ spent price)
     while (< next-spent budget)
     finally (return
               (values count spent))))

请注意，当price中没有更多的prices项目时，或者当下一次支出超出预算时，迭代就会停止。除了数量外，我还返回花费的总金额。

(assert (equalp
         (loop
            for budget in '(3 10 20 28 29 100)
            collect (list budget
                          (multiple-value-list
                           (spend-greedily '(5 10 13 20) budget))))
         '((3 (0 0))
           (10 (1 5))
           (20 (2 15))
           (28 (2 15))
           (29 (3 28))
           (100 (4 48)))))

如果对序列进行排序，请注意：

SORT是破坏性的，可能会以其希望的任何方式重用原始序列存储。是否复制原始序列（copy-seq（或copy-list）是所有权的问题；如有疑问或使用文字数据，应对副本进行排序。
但是，您不能再使用原始序列了，必须使用sort的返回值。如果您将列表视为由sort允许以另一种方式链接的简而言之，那是有道理的。然后，您的第一个列表（它是原始cons链的头）实际上可能现在位于排序列表的中间。或者，可以保留链结构，但修改每个列表的CAR。但是，尚未明确序列上发生的实际副作用。
考虑使用STABLE-SORT来控制w.r.t.您的比较函数：耦合（x，y），以使 x 和 y 都不符合自定义 << / em>。在您的情况下这并不重要，因为相等的数字是无法区分的，但是对于某些对象，对于那些依赖于实现细节而不依赖于对象属性的项，您可以以任意顺序结束。

Lisp打印两行而不是一行

2 个答案: