O exclusivo en el Esquema

Question

¿Cuál es la exclusiva o funciones en el esquema? He intentado xor y ^, pero ambos me dan un error de variable local independiente.

Google no encontró nada.

Answer 1

le sugiero que utilice (not (equal? foo bar)) si no es igual a las obras. Tenga en cuenta que puede haber comparadores más rápidos para su ubicación como eq?

Answer 2

Si quiere decir bitwise xor de dos enteros, cada Scheme tiene su propio nombre (si corresponde) ya que no está en ningún estándar. Por ejemplo, PLT tiene these bitwise functions, que incluye bitwise-xor.

(Uh, si usted habla de booleanos, entonces sí, not & or lo son ...)

Answer 3

Por lo que puedo decir de R6RS (la última definición de esquema), no hay una operación exclusiva o predefinida. Sin embargo, xor es equivalente a not equals para valores booleanos, por lo que es bastante fácil de definir por su cuenta si no tiene una función incorporada.

Suponiendo que los argumentos están restringidos a los booleanos esquema de valores y #f#t,

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

hará el trabajo.

Answer 4

tipo de un estilo diferente de respuesta:

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

Answer 5

Desde XOR podría utilizarse con cualquier número de argumentos, el único requisito es que el número de ocurrencias verdaderos sea impar. Se podría definir más o menos de esta manera:

comprobación

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

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

Ningún argumento que hay que hacer desde cualquier número de argumentos (incluyendo ninguno) devolverá la respuesta correcta.

Sin embargo, esta implementación simple tiene problemas de eficiencia: tanto la longitud como el filtro atraviesan la lista dos veces; entonces pensé que podría eliminar ambos y también el otro procedimiento de predicado inútil "¿verdad?".

¿El valor es impar? recibe es el valor del acumulador (aka acc) cuando args no tiene miembros restantes de evaluación verdadera. Si existen miembros de evaluación verdadera, repita con acc + 1 y el resto de args comenzando en el siguiente valor verdadero o evalúe a falso, lo que hará que acc se devuelva con el último recuento.

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

Answer 6

La lectura SRFI-1 arrojó una nueva luz sobre mi respuesta. ¡Olvídese de las preocupaciones sobre la eficiencia y la simplicidad, o incluso de las pruebas! Esta belleza lo hace todo:

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

o si lo prefiere:

(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

que revisó mi código recientemente porque necesitaba 'xor en el esquema y se encontró que no era suficientemente bueno...

Primero, mi definición anterior de 'verdad? asumió que los argumentos habían sido probados bajo una operación booleana. Así que cambio:

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

... para:

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

... que es más como el "verdadero" definición de 'verdad? Sin embargo, dado que 'xor devuelve #t si sus argumentos tienen un' impar '? número de argumentos "verdaderos", la prueba para un número par de casos falsos es equivalente. Así que aquí está mi versión revisada 'xor:

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