Ejercicios con listas en Scheme

En esta entrada resolveremos algunos ejercicios con listas en Scheme.

Contenido

1. Concatenar dos listas
2. Invertir una lista
3. Elementos comunes de dos listas
4. Eliminar un numero de una lista
5. Diferencia de dos listas
6. Intercalar elementos de dos listas
7. Reemplazar elementos en una lista
8. Colocar un elemento al final de una lista

Concatenar dos listas

Implemente una funcion que dadas dos listas, devuelva su concatenacion. No utilice la funcion append.

(define concatena (lambda (X Y)
                    (if (null? X)
                        Y
                        (cons (car X) (concatena (cdr X) Y))
                    )
                    ))

Invertir una lista

Hacer una funcion que invierta una lista

(define invierte (lambda (L1 L2)
  (if (null? L1)
   L2
   (invierte (cdr L1) (cons (car L1) L2)
  )
))

Elementos comunes de dos listas

Dada dos listas, devolver una lista con sus elementos comunes.

(define comunes (lambda (L1 L2)
                  (if (null? L1)
                      '()
                      (if (null? (busca (car L1) L2))
                          (comunes (cdr L1) L2)
                          (cons (car L1) (comunes (cdr L1) (cdr L2)))
                      )
                  )
                  ))

(define busca (lambda (x L)
                (if (null? L)
                    '()
                    (if (= (car L) x)
                        (cons x (busca x (cdr L)))
                        (busca x (cdr L))
                    )
                )
                ))

Eliminar un numero de una lista

Elimine un numero de una lista

(define elimina (lambda (L x)
                  (if (null? L)
                      '()
                      (if (= (car L) x)
                          (elimina (cdr L) x)
                          (cons (car L) (elimina (cdr L) x))
                      )
                  )
              ))

Diferencia de dos listas

Hacer un programa que dada dos listas A y B devuelve la diferencia en el sentido de conjuntos (A-B).(A-B) son todos los elementos de A que no tiene B

(define diferencia (lambda (A B)
                     (if (null? A)
                         '()
                         (if (null? (busca (car A) B))
                             (cons (car A) (diferencia (cdr A) B))
                             (diferencia (cdr A) B)
                         )
                     )
                 ))

Intercalar elementos de dos listas

Hacer un programa que dadas dos listas intercale sus elementos.

(define intercala (lambda (A B)
                    (if (AND (null? A) (null? B))
                        '()
                        (if (null? A)
                            (cons (car B) (intercala A (cdr B)))
                            (cons (car A) (intercala B (cdr A)))
                        )
                    )
                ))

Reemplazar elementos en una lista

Dada una lista y dos numeros x e y, Reemplace todos las ocurrencias de x en la lista por y.

(define reemplaza (lambda (L x y)
                    (if (null? L)
                        '()
                        (if(= (car L) x)
                           (cons y (reemplaza (cdr L) x y))
                           (cons (car L) (reemplaza (cdr L) x y))
                        )
                    )
                    ))

Colocar un elemento al final de una lista

Dada una lista y un numero x, colocar x al final de la lista.

(define poninicio (lambda (L y)
                    (if (null? L)
                        (cons y L)
                        (cons (car L) (poninicio (cdr L) y))
                    )
                    ))