Schema: Wie um zu überprüfen, ob alle Elemente einer Liste sind identisch

Ich möchte erstellen Sie eine Scheme-Funktion ergibt true, wenn es übergeben wird eine Liste, die aus vollständig identischen Elemente. Eine solche Liste wäre '(1 1 1 1). Es ergäbe false mit so etwas wie '(1 2 1 1).

Dies ist, was ich habe, so weit:

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

Dies ist eindeutig falsch, und ich bin neu in diesem. Ich denke, ich bin nicht in der Lage zu äußern, der Schritt, wo ich soll zurück #t oder #f.

Vielen Dank im Voraus!

BEARBEITEN:
Ich fummelte ein wenig und fand eine Lösung, die scheint sehr gut zu funktionieren, und mit einer minimalen Menge an code:

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

Nochmals vielen Dank für die Hilfe an alle.

InformationsquelleAutor Joseph | 2011-09-06

3

Minimale Menge an code, die, wenn Sie nicht kümmern, dass es funktioniert nur für zahlen:
```
(define (list-equel? lst)
  (apply = lst))
```
Beispiele:
```
> (list-equel? '(1 1 2 1))
#f
> (list-equel? '(1 1 1 1))
#t
> (list-equel? '(1))
#t
```
- Definitiv die beste Lösung, und ich kann nicht glauben, dass ich nicht daran gedacht. Gute call.
- Wenn Sie nicht sogar brauchen, die Länge Zustand. (equal?) ohne Argumente => #t.
- Das funktioniert nur, wenn Ihre Liste besteht nur aus zahlen. 🙂
- Spaß. Wenn ich die Idee getestet, ich unterbewusst korrigiert es equal?. Ich denke, ich werde das beheben, dass für @aaz.
- Im standard-Schema, equal? ist nicht variadic den Weg = ist. 🙂 (Getestet habe ich mit Schläger, zum Beispiel: "gleich?: erwartet 2 Argumente, die 3: 1 2 3") Du gehst zu haben, um mit dem Falzen, sorry. 😛
- Jester-Junge --- Ah. Ich war irregeführt durch guile --- Guile 1.8, dass ist. Ich werde zurückkehren mit einem Kommentar.
InformationsquelleAutor andrykonchin
1

Den andmap Lösung ist schön, aber wenn andmap nicht verfügbar ist, können Sie diese verwenden. Es nutzt grundlegende Operationen (und, oder, null-check, überprüfung auf Gleichheit) und Griffe leere Listen und eine element-Listen. Ähnlich wie Sean der Umsetzung, aber kein Helfer definition ist notwendig.
```
(define (list-equal? args)
  (or (or (null? args)
          (null? (cdr args)))
      (and (eq? (car args) (cadr args))
           (list-equal? (cdr args)))))
```
- (or 1 2 3) ist auch legal.
InformationsquelleAutor Lorenz Forvang
0

Probieren Sie etwas wie dieses:
```
(define (list-equal? lst)
 (define (helper el lst)
  (or (null? lst)
      (and (eq? el (car lst))
           (helper (car lst) (cdr lst)))))
 (or (null? lst)
     (helper (car lst) (cdr lst))))
```
Dies ist vielleicht nicht die sauberste Umsetzung, aber ich denke, es wird richtig behandelt Fälle von leeren Listen und one-element-Listen.
- Dieses funktioniert gut. Vielen Dank, ich denke ich habe den Dreh diese.
InformationsquelleAutor Sean Devlin
0

In R6RS es gibt die for-all - Funktion, die nimmt ein Prädikat und eine Liste, und zurück #t wenn das Prädikat liefert true für alle Elemente in der Liste und #f sonst, das ist genau das, was Sie hier benötigen.

Also, wenn Sie mit R6RS (oder jedes andere scheme-Dialekt, der hat die for-all - Funktion), können Sie einfach ersetzen for-each mit for-all im code und es wird funktionieren.
- Es ist schade, dass für alle " ist nicht verfügbar für mich. Aber es ist gut zu wissen, dass ich auf dem richtigen Weg war.
- Das würde funktionieren, mit dem zusätzlichen Schritt, den Sie müssen noch überprüfen, dass lst ist nicht leer.
- Ja, guter Punkt. Das oder loszuwerden, die tmp variable und rufen Sie (car lst) jedes mal, wenn im Prädikat (die nie aufgerufen werden, für die leere Liste dieses problem zu vermeiden).
InformationsquelleAutor sepp2k
0
```
(define (list-equal? lst)
    (if (= (cdr lst) null)
        true
        (and (equal? (car lst) (cadr lst))
             (list-equal? (cdr lst)))))
```
- Dies scheint nicht zu funktionieren, ich denke, es wird am Ende und beschwert sich, dass es nicht verwenden können, cadr auf eine einsame element. Ich bin mit Schläger/Recht Große ob dies einen Unterschied macht.
- Dieser Schlag wird auf eine Liste mit einem element. EDIT: der Joseph hat Recht, es wird Schlag auf jeder Liste stehen, wenn Sie am Ende des es.
- Du hast Recht. Nur die kleine änderung, dass ich gerade gemacht beheben sollte.
- Dies wird auch noch die Luft zu sprengen, wenn Sie versuchen, nehmen Sie die cdr von der leeren Liste. Für Ihre Umsetzung ist, sollten Sie zuerst prüfen ob lst ist nicht null und dann (cdr lst) ist nicht null.
InformationsquelleAutor Daniel
0

Etwas wie dies funktionieren sollte:
```
(define (list-equal? lst)
  (cond ((< (length lst) 2) #t)
        (#t (and (equal? (car lst) (cadr lst))
             (list-equal? (cdr lst))))))
```
- Das ist schön, außer, dass es läuft in O(n*n) Zeit, statt der O(n) Zeit (weil für jede position in der Liste, die Länge der den Rest der Liste berechnet wird). Wenn diese angepasst wurden die base-case werden (or (null? lst) (null? (cdr lst))) wäre, hätte es viel bessere Laufzeit, als auch als schön und prägnant.
InformationsquelleAutor JasonFruit
0

Die anderen Antworten in diesem thread scheinen alle zu kompliziert (ich lese Sie alle), also hier ist mein nehmen auf Sie:
```
(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))))
```
(Es funktioniert nicht mit einer leeren Liste, von design. Es ist einfach zu fügen Sie eine (if (null? lst) #t ...) wenn nötig.)

InformationsquelleAutor Chris Jester-Young

Kurze, prägnante Lösung:

#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? '()))

Beachten Sie, dass diese Schläger verwendet, so kann dies nicht funktionieren mit Ihrem scheme-Implementierung.

InformationsquelleAutor Majora320

Noch eine andere Lösung:

(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)))))

InformationsquelleAutor mepo

-1

Ist schlecht in diesen Sprachen. Versuchen
```
(define list-equal?
 (lambda (lst)
   (if (= lst null)
   (true)
   (foldr = (car lst) (cdr lst))
)))
```
- Das wird nicht funktionieren. Sie vergleicht ein element von einer Liste zu einem boolschen Ergebnis.
InformationsquelleAutor Patrik

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.