分区帮助方案

Question

我有以下代码，但是当我运行这个例子时：

(partition 12 '(4 9 18 6 19 10 18 11 5 5 7 2 4 19 1 9 10 18 12))

我明白了

((4 9 6 10 11 5 5 7 2 4 1 9 10 12) (18 19 18 19 18)) 

作为回报。

我想要它如下

((4 9 6 10 11 5 5 7 2 4 1 9 10 12) 18 19 18 19 18)

我应该怎么做才能改变这一点？谢谢支持

      (require (lib "trace.ss"))
        (define (partition pivot lon)
          (if (null? lon)
              '(()())
              (let ((split-of-rest (partition pivot (cdr lon))))
                (if (<= (car lon) pivot)
                    (list (cons (car lon) (car split-of-rest))
                          (cadr split-of-rest))
                    (list (car split-of-rest) (cons (car lon)
                                                    (car (cdr split-of-rest))))))))

Answer 1

我就是这样解决的：

(define (partition pivot lon)
  (define (partition pivot lon less more)
    (if (null? lon)
      (cons less more)
      (if (<= (car lon) pivot)
        (partition pivot (cdr lon) (append less (list (car lon))) more)
        (partition pivot (cdr lon) less (append more (list (car lon)))))))
  (partition pivot lon '() '()))

不知道这是不是您正在寻找的解决方案。

Answer 2

在某些 Scheme 解释器（例如 Racket）中，有一个内置的 partition 过程。或者，它也包含在SRFI 1 中。如果可以使用它，它将简化您的代码：

(define (my-partition val lst)
  (let-values (((low high) (partition (lambda (x) (<= x val)) lst)))
    (cons low high)))

partition 返回两个值，第一个是满足谓词的元素的列表，第二个是不满足谓词的元素的列表。使用cons 将它们组合起来很容易，以获得所需格式的结果。

或者，我们可以使用call-with-values，正如@leppie 所建议的那样：

(define (my-partition val lst)
  (call-with-values
   (thunk (partition (lambda (x) (<= x val)) lst))
   cons))

不管怎样，结果如预期：

(my-partition 12 '(4 9 18 6 19 10 18 11 5 5 7 2 4 19 1 9 10 18 12))
=> '((4 9 6 10 11 5 5 7 2 4 1 9 10 12) 18 19 18 19 18)

Answer 3

我发现递归方法很困难，这里有一个更简单的迭代方法：

(define (partition pivot lst)
  (let loop ((a '()) (b '()) (lst lst))
    (cond
      ((null? lst)          (cons (reverse a) (reverse b)))
      ((<= (car lst) pivot) (loop (cons (car lst) a) b (cdr lst)))
      (else                 (loop a (cons (car lst) b) (cdr lst))))))

(partition 12 '(4 9 18 6 19 10 18 11 5 5 7 2 4 19 1 9 10 18 12))
=> '((4 9 6 10 11 5 5 7 2 4 1 9 10 12) 18 19 18 19 18)