Exclusive OR in Schema

Question

Was ist das exklusive oder Funktionen im Schema? Ich habe versucht xor und ^, aber beide geben mir einen ungebundenen lokalen Variablenfehler.

Googeln fand nichts.

Answer 1

Ich schlage vor, Sie (not (equal? foo bar)) verwenden, wenn nicht funktioniert gleich. Bitte beachten Sie, dass es schnellere Komparatoren für Ihre Situation wie eq?

Answer 2

Wenn Sie bitweises xor von zwei Ganzzahlen meinen, dann hat jedes Schema seinen eigenen Namen (falls vorhanden), da es in keinem Standard ist. Zum Beispiel hat PLT these bitwise functions, einschließlich bitwise-xor.

(Uh, wenn Sie über booleans sprechen, dann ja, not & or sind es ...)

Answer 3

geben kann. Soweit ich aus der R6RS (die neueste Definition des Schemas) sagen kann, gibt es keine vordefinierte Exklusiv-oder Operation. Allerdings entspricht xornot equals für boolesche Werte, so dass es sehr einfach ist, selbst zu definieren, wenn es keine eingebaute Funktion dafür gibt.

die Argumente Unter der Annahme, werden auf die Regelung booleans beschränkt Werte #f und #t,

(define (xor a b) 
    (not (boolean=? a b))) 

den Job tun.

Answer 4

Art eine andere Art der Antwort:

(define xor 
    (lambda (a b) 
    (cond 
     (a (not b)) 
     (else b)))) 

Answer 5

Da xor mit einer beliebigen Anzahl von Argumenten verwendet werden könnte, ist die einzige Voraussetzung, dass die Anzahl der wahren Begebenheiten ungerade sein. Es könnte etwa auf diese Weise definiert werden:

(define (true? x) (eqv? x #t)) 

(define (xor . args) 
    (odd? (length (filter true? args)))) 

Kein Argument Prüfung muss getan werden, da eine beliebige Anzahl von Argumenten (einschließlich keine) die richtige Antwort wird zurückkehren.

Diese einfache Implementierung hat jedoch Effizienzprobleme: Länge und Filter durchlaufen die Liste zweimal; also dachte ich, ich könnte beides und auch die andere nutzlose Prädikatenprozedur "wahr?" entfernen.

Der Wert ungerade? receive ist der Wert des Akkumulators (aka ac), wenn args keine verbleibenden wahr auswertenden Mitglieder hat. Wenn echte Evaluierungselemente existieren, wiederhole mit acc + 1 und der Rest der Argumente beginnt mit dem nächsten wahren Wert oder evaluiert mit false, was bewirkt, dass acc mit der letzten Zählung zurückgegeben wird.

(define (xor . args) 
    (odd? (let count ([args (memv #t args)] 
        [acc 0]) 
      (if args 
       (count (memv #t (cdr args)) 
        (+ acc 1)) 
           acc)))) 

Answer 6

Lesen SRFI-1 warf ein neues Licht auf meine Antwort. Vergessen Sie Effizienz- und Einfachheitsprobleme oder sogar Tests! Diese Schönheit macht alles:

(define (xor . args) 
    (odd? (count (lambda (x) (eqv? x #t)) args))) 

Oder wenn Sie bevorzugen:

(define (true? x) (eqv? x #t)) 
(define (xor . args) (odd? (count true? args))) 

Answer 7

> (define (xor a b)(not (equal? (and a #t)(and b #t)))) 
> (xor 'hello 'world) 
$9 = #f 
> (xor #f #f) 
$10 = #f 
> (xor (> 1 100)(< 1 100)) 
$11 = #t 

Answer 8

(define (xor a b) 
    (and 
    (not (and a b)) 
    (or a b))) 

Answer 9

ich meinen Code vor kurzem überarbeitet, weil ich ‚xor in Schema benötigt und fand heraus, es war nicht gut genug...

Erstens, meine frühere Definition von "wahr? machte die Annahme, dass Argumente unter einer booleschen Operation getestet wurden. So ändern I:

(define (true? x) (eqv? #t)) 

... für:

(define (true? x) (not (eqv? x #f))) 

..., die mehr wie die "wahre" Definition von ‚wahr ist? Wie auch immer, da 'xor' #t zurückgibt, wenn seine Argumente 'ungerade' haben? Anzahl der "wahren" Argumente ist das Testen auf eine gerade Anzahl falscher Fälle äquivalent. Also hier ist meine überarbeitete 'xor:

(define (xor . args) 
    (even? (count (lambda (x) (eqv? x #f)) args)))