Scheme : Comment vérifier si tous les éléments d'une liste sont identiques ?

Question

J'aimerais créer une fonction Scheme qui donne vrai si on lui passe une liste composée entièrement d'éléments identiques. Une telle liste serait '(1 1 1 1 1). Elle donnerait faux avec quelque chose comme "(1 2 1 1)".

Voici ce que j'ai jusqu'à présent :

    (define (list-equal? lst)
      (define tmp (car lst))
      (for-each (lambda (x) 
                   (equal? x tmp))
                 lst)
      )

Il est clair que c'est incorrect, et je suis nouveau dans ce domaine. Je suppose que je n'arrive pas à exprimer l'étape où je suis censé retourner #t o #f .

Merci d'avance !

EDIT : J'ai bricolé un peu et j'ai trouvé une solution qui semble fonctionner très bien, et avec une quantité minimale de code :

(define (list-equal? lst)
 (andmap (lambda (x) 
        (equal? x (car lst)))
      lst))

Merci encore pour votre aide à tous.

Answer 1

Quelque chose comme ceci devrait fonctionner :

(define (list-equal? lst)
  (cond ((< (length lst) 2) #t)
        (#t (and (equal? (car lst) (cadr lst))
             (list-equal? (cdr lst))))))

Answer 2

Les autres réponses dans ce fil semblent toutes trop compliquées (je les ai toutes lues), alors voici mon point de vue :

(define (all-equal? lst)
  (define item (car lst))
  (let next ((lst (cdr lst)))
    (cond ((null? lst) #t)
          ((equal? item (car lst)) (next (cdr lst)))
          (else #f))))

(Il ne fonctionne pas avec une liste vide, à dessein. Il est facile d'ajouter un (if (null? lst) #t ...) si nécessaire).

Answer 3

Une solution courte et concise :

#lang racket
(define (all-equal? lst)
  (for/and
      ([i (in-permutations lst)])
    (equal? (first i) (second i))))

; TEST CASES

(require rackunit)

(check-false (all-equal? '(1 2 3)))
(check-true (all-equal? '(1 1 1)))
(check-true (all-equal? '()))

Notez que cela utilise racket, donc cela peut ne pas fonctionner avec votre implémentation de schéma.

Answer 4

Encore une autre solution :

(define (all-same ls)
    (cond
     ((or (null? ls)
          (null? (cdr ls))) #t)
     (else (and (equal? (car ls) (next ls))
                (all-same (cdr ls)))))))

(define (next ls)
    (cond
     ((or (null? ls)
          (null? (cdr ls))) '())
     (else (cadr ls)))))

Answer 5

For est mauvais dans ces langues. Essayez

(define list-equal?
 (lambda (lst)
   (if (= lst null)
   (true)
   (foldr = (car lst) (cdr lst))
)))