Разбиение списка в Racket

В приложении, в котором я работаю в Racket, мне нужно взять список чисел и разбить список на под-списки последовательных номеров: (В фактическом приложении я фактически буду разбивать пары, состоящие из числа и некоторых данных, но принцип тот же.)

то есть. если моя процедура называется chunkify, то:

(chunkify '(1 2 3  5 6 7  9 10 11)) -> '((1 2 3) (5 6 7) (9 10 11))  
(chunkify '(1 2 3)) ->  '((1 2 3))  
(chunkify '(1  3 4 5  7  9 10 11 13)) -> '((1) (3 4 5) (7) (9 10 11) (13))  
(chunkify '(1)) -> '((1))  
(chunkify '()) -> '(())

и др.

В Racket появилось следующее:

#lang racket  
(define (chunkify lst)  
  (call-with-values   
   (lambda ()  
     (for/fold ([chunk '()] [tail '()]) ([cell  (reverse lst)])  
       (cond  
         [(empty? chunk)                     (values (cons cell chunk) tail)]  
         [(equal? (add1 cell) (first chunk)) (values (cons cell chunk) tail)]  
         [else (values   (list cell) (cons  chunk tail))])))  
   cons))

Это работает отлично, но мне интересно дать выразительность Racket, если нет более простого более простого способа сделать это, каким-то образом избавиться от "call-in-values" и необходимости переверните список в процедуре и т.д., возможно, каким-то образом, совершенно иным.

Моя первая попытка была очень плохо основана на шаблоне с коллекционером в "The Little Schemer" и это было еще менее прямолинейно, чем выше:

(define (chunkify-list lst)  
 (define (lambda-to-chunkify-list chunk) (list chunk))

 (let chunkify1 ([list-of-chunks '()] 
                 [lst lst]
                 [collector lambda-to-chunkify-list])
   (cond 
     [(empty? (rest lst)) (append list-of-chunks (collector (list (first lst))))]
     [(equal? (add1 (first lst)) (second lst))  
      (chunkify1 list-of-chunks (rest lst)
                 (lambda (chunk) (collector (cons (first lst) chunk))))] 
     [else
      (chunkify1 (append list-of-chunks
                         (collector (list (first lst)))) (rest lst) list)])))

То, что я ищу, - это что-то простое, краткое и понятное.

Ответ 1

Вот как бы я это сделал:

;; chunkify : (listof number) -> (listof (non-empty-listof number))
;; Split list into maximal contiguous segments.
(define (chunkify lst)
  (cond [(null? lst) null]
        [else (chunkify/chunk (cdr lst) (list (car lst)))]))

;; chunkify/chunk : (listof number) (non-empty-listof number)
;;               -> (listof (non-empty-listof number)
;; Continues chunkifying a list, given a partial chunk.
;; rchunk is the prefix of the current chunk seen so far, reversed
(define (chunkify/chunk lst rchunk)
  (cond [(and (pair? lst)
              (= (car lst) (add1 (car rchunk))))
         (chunkify/chunk (cdr lst)
                         (cons (car lst) rchunk))]
        [else (cons (reverse rchunk) (chunkify lst))]))

Однако это не согласуется с вашим окончательным тестом:

(chunkify '()) -> '()  ;; not '(()), as you have

Я считаю свой ответ более естественным; если вы действительно хотите, чтобы ответ был '(()), я бы переименовал chunkify и написал обертку, которая специально обрабатывает пустой случай.

Если вы предпочитаете избегать взаимной рекурсии, вы можете заставить вспомогательную функцию вернуть оставшийся список как второе значение вместо вызова chunkify на нем, например:

;; chunkify : (listof number) -> (listof (non-empty-listof number))
;; Split list into maximal contiguous segments.
(define (chunkify lst)
  (cond [(null? lst) null]
        [else
         (let-values ([(chunk tail) (get-chunk (cdr lst) (list (car lst)))])
           (cons chunk (chunkify tail)))]))

;; get-chunk : (listof number) (non-empty-listof number)
;;          -> (values (non-empty-listof number) (listof number))
;; Consumes a single chunk, returns chunk and unused tail.
;; rchunk is the prefix of the current chunk seen so far, reversed
(define (get-chunk lst rchunk)
  (cond [(and (pair? lst)
              (= (car lst) (add1 (car rchunk))))
         (get-chunk (cdr lst)
                    (cons (car lst) rchunk))]
        [else (values (reverse rchunk) lst)]))

Ответ 2

Я могу подумать о простом и понятном решении, используя единую процедуру с только примитивными операциями списка и хвостовой рекурсией (no values, let-values, call-with-values) - и это довольно эффективно. Он работает со всеми вашими тестовыми случаями за счет добавления пары выражений if во время инициализации для обработки пустого списка. Вам решать, насколько это кратким:

(define (chunkify lst)
  (let ((lst (reverse lst))) ; it easier if we reverse the input list first
    (let loop ((lst (if (null? lst) '() (cdr lst)))        ; list to chunkify
               (cur (if (null? lst) '() (list (car lst)))) ; current sub-list
               (acc '()))                                  ; accumulated answer
      (cond ((null? lst)                    ; is the input list empty?
             (cons cur acc))
            ((= (add1 (car lst)) (car cur)) ; is this a consecutive number?
             (loop (cdr lst) (cons (car lst) cur) acc))
            (else                           ; time to create a new sub-list
             (loop (cdr lst) (list (car lst)) (cons cur acc)))))))

Ответ 3

Еще один способ сделать это.

#lang racket

(define (split-between pred xs)
  (let loop ([xs xs]
             [ys '()]
             [xss '()])
    (match xs
      [(list)                 (reverse (cons (reverse ys) xss))]
      [(list x)               (reverse (cons (reverse (cons x ys)) xss))]
      [(list x1 x2 more ...)  (if (pred x1 x2) 
                                  (loop more (list x2) (cons (reverse (cons x1 ys)) xss))
                                  (loop (cons x2 more) (cons x1 ys) xss))])))

(define (consecutive? x y)
  (= (+ x 1) y))

(define (group-consecutives xs)
  (split-between (λ (x y) (not (consecutive? x y))) 
                 xs))


(group-consecutives '(1 2 3 5 6 7 9 10 11))
(group-consecutives '(1 2 3))
(group-consecutives '(1 3 4 5 7 9 10 11 13))
(group-consecutives '(1))
(group-consecutives '())

Ответ 4

Я хочу играть.

В основе этого не совсем то, что сильно отличается от того, что был предложен, но он поставил его в терминах цикла for/fold. Я так как, по-моему, они делают много более "видимый" (не обязательно читаемый) код. Однако (ИМО - oops) на ранних этапах racket/scheme Я думаю, что лучше всего придерживаться рекурсивных выражений.

(define (chunkify lst)  
    (define-syntax-rule (consecutive? n chunk)     
      (= (add1 (car chunk)) n))
    (if (null? lst)
        'special-case:no-chunks
        (reverse 
         (map reverse
              (for/fold  ([store    `((,(car lst)))])
                         ([n         (cdr lst)])
                 (let*([chunk   (car store)])
                   (cond 
                    [(consecutive? n chunk)
                        (cons  (cons n chunk)  (cdr store))]
                    [else
                        (cons  (list n)  (cons chunk (cdr store)))])))))))


(for-each
 (ƛ (lst)  
    (printf "input   :  ~s~n" lst)
    (printf "output  :  ~s~n~n" (chunkify lst)))
 '((1 2 3 5 6 7 9 10 11)
   (1 2 3)
   (1 3 4 5 7 9 10 11 13)
   (1)
   ()))

Ответ 5

Здесь моя версия:

(define (chunkify lst)
  (let loop ([lst lst] [last #f] [resint '()] [resall '()])
    (if (empty? lst) 
        (append resall (list (reverse resint)))
        (begin
          (let ([ca (car lst)] [cd (cdr lst)])
            (if (or (not last) (= last (sub1 ca)))
                (loop cd ca (cons ca resint) resall)
                (loop cd ca (list ca) (append resall (list (reverse resint))))))))))

Он также работает для последнего тестового примера.