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

Ответ 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))))))))))

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