es.davy.ai

Preguntas y respuestas de programación confiables

¿Tienes una pregunta?

Si tienes alguna pregunta, puedes hacerla a continuación o ingresar lo que estás buscando.

Procedimiento de scheme en una lista.

07 Jun, 2023 Programación

Imaginemos que tengo una lista ”(+ (* (x) (5)) (2)), ¿cómo podría hacer un procedimiento que cambie la x por cualquier parámetro que se dé y luego evalue la función dentro de la lista? ((calcular expresión x)).

Tuve algunas ideas pero no logré hacer que funcionaran. Estos son los helpprocedures que hice:

(define (atom? x)
(not (pair? x)))

(define (deep-map f l)
(cond
((null? l) ‘())
((atom? l) (f l))
(else
(cons (deep-map f (car l))
(deep-map f (cdr l))))))

(define (deep-change e1 e2 l)
(deep-map (lambda (x) (if (eq? x e1) e2 x)) l))

(define (go-through-list list)
(if (null? list)
‘()
((car lista) (go-through-list (cdr list)))))

Aquí está el código principal:

(define (calcular expresión x)
(let ((expressie (deep-change ‘x x expression)))
(( ‘+ (deep-change ‘+ (+) expression)))
(( ‘- (deep-change ‘- (-) expression)))
(( ‘* (deep-change ‘* (*) expression)))
(( ‘/ (deep-change ‘/ (/) expression)))
(go-through-list expression)))

Logré cambiar la x por el parámetro que doy pero tengo problemas con el * y el + dentro de la lista.

Tags:  , ,

Answer

  1. Avatar for davy.ai
    davy.ai

    Para hacer un procedimiento que cambie la x por cualquier parámetro que le demos y luego evalúe la función dentro de la lista, podemos seguir los siguientes pasos:

    1. Definir un procedimiento auxiliar “deep-change” que tome tres entradas: “e1”, “e2” y “l”. Este procedimiento cambiará todas las apariciones de “e1” por “e2” en la lista “l”.
    2. Definir un procedimiento auxiliar “go-through-list” que tome una entrada “lista”. Este procedimiento aplicará recursivamente las operaciones en la lista y devolverá el resultado evaluado.
    3. Definir el procedimiento principal “calculate” que tome dos entradas: “expresión” y “x”. Se utilizará el procedimiento “deep-change” para reemplazar todas las apariciones de “x” en “expresión” con el parámetro “x” que se pasó. Luego, usaremos “go-through-list” para evaluar cada operación en la “expresión” actualizada y devolver el resultado final.

    Aquí está el código actualizado:

    (define (deep-change e1 e2 l)
  (cond
    ((null? l) '())
    ((equal? l e1) e2)
    ((pair? l)
     (cons (deep-change e1 e2 (car l))
           (deep-change e1 e2 (cdr l))))
    (else l)))

(define (go-through-list list)
  (cond
    ((null? list) 0)
    ((equal? (car list) '+)
     (+ (cadr list) (go-through-list (cddr list))))
    ((equal? (car list) '*)
     (* (cadr list) (go-through-list (cddr list))))
    ((equal? (car list) '-)
     (- (cadr list) (go-through-list (cddr list))))
    ((equal? (car list) '/')
     (/ (cadr list) (go-through-list (cddr list))))
    (else (car list))))

(define (calculate expression x)
  (let ((expresión (deep-change 'x x expression)))
    (go-through-list expresión)))

    Ahora podemos probar con “(calcular ‘(+ (* (x) 5) 2) 3)” y obtener el resultado esperado “17”.

Comments are closed.