Comment puis-je prendre une tranche d'une liste (une sous-liste) dans le schéma?

Question

À partir d’une liste, comment sélectionner une nouvelle liste contenant une partie de la liste originale (décalage et nombre d’éléments donnés?

EDIT:

Bonnes suggestions jusqu'à présent. N'y a-t-il pas quelque chose de spécifié dans l'une des SRFI? Cela semble être une chose très fondamentale, alors je suis surpris de devoir l’appliquer à l’utilisateur.

Answer 1

Le code suivant fera ce que vous voulez:

(define get-n-items
    (lambda (lst num)
        (if (> num 0)
            (cons (car lst) (get-n-items (cdr lst) (- num 1)))
            '()))) ;'

(define slice
    (lambda (lst start count)
        (if (> start 1)
            (slice (cdr lst) (- start 1) count)
            (get-n-items lst count))))

Exemple:

> (define l '(2 3 4 5 6 7 8 9)) ;'
()
> l
(2 3 4 5 6 7 8 9)
> (slice l 2 4)
(3 4 5 6)
> 

Answer 2

Étrangement, la tranche n'est pas fournie avec SRFI- 1 mais vous pouvez le raccourcir en utilisant < code> prendre et déposer :

(define (slice l offset n)
  (take (drop l offset) n))

Je pensais que l'une des extensions que j'avais utilisées avec Scheme, comme la bibliothèque de schémas PLT ou Swindle, aurait cette fonctionnalité intégrée, mais cela ne semble pas être le cas. Ce n'est même pas défini dans les nouvelles bibliothèques R6RS.

Answer 3

Vous pouvez essayer cette fonction:

  

sousq début de séquence et fin optionnelle

Le paramètre start correspond à votre décalage. Le paramètre end peut être facilement transformé en nombre d'éléments à saisir en ajoutant simplement début + nombre d'éléments.

Un petit avantage supplémentaire est que subtq fonctionne sur toutes les séquences. Cela inclut non seulement les listes, mais également les chaînes et les vecteurs.

Éditer: Il semble que toutes les implémentations de Lisp n’ont pas de sous-programme, bien que cela fonctionne très bien si vous l’avez.

Answer 4

(define (sublist list start number)
  (cond ((> start 0) (sublist (cdr list) (- start 1) number))
        ((> number 0) (cons (car list)
                      (sublist (cdr list) 0 (- number 1))))
        (else '())))

Answer 5

Voici mon implémentation de la tranche qui utilise un appel de fin approprié

(define (slice a b xs (ys null))
  (cond ((> a 0) (slice (- a 1) b (cdr xs) ys))
        ((> b 0) (slice a (- b 1) (cdr xs) (cons (car xs) ys)))
        (else (reverse ys))))

(slice 0 3 '(A B C D E F G)) ;=> '(A B C)
(slice 2 4 '(A B C D E F G)) ;=> '(C D E F)

Answer 6

Essayez quelque chose comme ça:

    (define (slice l offset length)
      (if (null? l)
        l
        (if (> offset 0)
            (slice (cdr l) (- offset 1) length)
            (if (> length 0)
                (cons (car l) (slice (cdr l) 0 (- length 1)))
                '()))))