0

我正在尝试编写一个在“分隔符”元素之间“封装”(即放入列表中)列表元素的过程。

(my-proc '(1 + 2))
=> ((1) (2))

(my-proc '(x * y + z ^ 2 + 1 + 5))
=> ((x * y) (z ^ 2) (1) (5))

(my-proc '((x + 1) * y + 5))
=> (((x + 1) * y) (5))

在这种情况下,可以对过程进行硬编码以将 + 符号定义为分隔符。

假设定义了 foldr (折叠右操作),我更喜欢它。

4

3 回答 3

1

我没有给出完整的解决方案,因为这看起来真的很家庭作业。

(define (split-expr expr)
   (foldr (lambda (e es)
                  (if (eq? e '+)
                      <???>    ; do split
                      (cons (cons e (car es))
                            (cdr es))))
          <???>    ; what should start be?
          es))
于 2013-04-09T06:13:55.017 回答
0

只是为了好玩,这是一个延续传递风格的版本(不foldr,可能不适合作为家庭作业的答案):

(define split/cps
  (λ (sep ls)
    (let loop ([ls ls] [k (λ (item acc)
                               (if item (cons item acc) acc))])
      (cond
        [(null? ls)
          (k #f '())]
        [(eq? sep (car ls))
          (loop (cdr ls)
                (λ (item acc)
                  (k #f (if item (cons item acc) acc))))]
        [else
          (loop (cdr ls)
                (λ (item acc)
                  (k (if item
                         (cons (car ls) item)
                         (list (car ls)))
                     acc)))]))))
于 2013-04-10T03:02:27.427 回答
0

这是另一种方法,也没有foldr

(define split/values
  (λ (sep ls)
    (let loop ([ls ls])
      (cond
        [(null? ls)
          '()]
        [else
          (let-values ([(a d) (car-to-sep sep ls)])
            (if (null? a)
                (loop d)
                (cons a (loop d))))]))))

(define car-to-sep
  (λ (sep ls)
    (let loop ([ls ls] [a '()])
      (cond
        [(null? ls)
          (values '() '())]
        [(eq? sep (car ls))
          (values '() (cdr ls))]
        [else
          (let-values ([(a d) (loop (cdr ls) a)])
            (values (cons (car ls) a) d))]))))
于 2013-04-10T13:08:09.717 回答