Guía de ejercicios LISP

Dada la expresión que define a la función FNC

(DEFUN FNC (X)        
	(COND
		((ATOM X)X)       
		(T(FNC (CAR(CDR X)))))
) 

Evaluar:

1. (FNC ' A )
2. (FNC ' ( A B ) )
3. (FNC ' ( ( X Y ) ( X Z) ) )
4. (FNC ' ( A B C ) )
5. (FNC ' ( A ( C E ) ) )
6. (FNC ' ( ( C D ) A ) )
7. (FNC ' FNC )
8. (FNC FNC )

Dada la expresión que define a la función CHEQ

(DEFUN CHEQ (X M)
	(COND 
		((NULL X) NIL)
		((NULL M)NIL)
		((EQ (CAR X)(CAR M))(CAR X))
		(T (CHEQ(CDR X)(CDR M)))
	)
)

Evaluar:

1. (CHEQ ' (X) '(X) )
2. (CHEQ ' ( A B C) '(E D C ))
3. (CHEQ ' ( A B ) ( E D) )
4. (CHEQ ' ( A B ) ' ( E B F ) )
5. (CHEQ ' ( A ( C E ) ) )
6. (CHEQ ' ( A B ) '( Z (B) ) )

Definir una función para determinar si un átomo es componente de una lista ( a primer nivel y a todo nivel).

(DEFUN PERTENECE (X L)
	(COND
		((NULL L)NIL)
		((IF (ATOM (CAR L))
			(EQ X (CAR L))
			(PERTENECE X (CAR L))
		))
		(T(PERTENECE X (CDR L)))
	)
)

Definir una función para determinar si dos listas son iguales ( resolver para el caso de listas simples y para el caso de listas no simples a todo nivel).

(DEFUN L_IGUALES (L1 L2)
	(COND
		((AND(NULL L1)(NULL L2)) T)
		((IF (ATOM (CAR L1)) (AND(EQ (CAR L1)(CAR L2)) (L_IGUALES (CDR L1)(CDR L2)))
						(AND(L_IGUALES(CAR L1)(CAR L2))(L_IGUALES (CDR L1)(CDR L2)))
		))
		(T NIL)
	)
)

Dadas dos listas de igual longitud definir una función para producir una lista de los elementos en las posiciones pares.

(DEFUN PARES (L)
	(IF(NOT (NULL(CDR L)))
		(CONS (CADR L)(PARES (CDDR L)))
	)
)

Definir una función para eliminar las ocurrencias de un átomo en una lista a todo nivel.

(DEFUN ELIMINAR (X L)
	(IF (NOT (NULL L))
		(IF (ATOM (CAR L))
			(IF (EQ X (CAR L))
				(ELIMINAR X (CDR L))
				(CONS (CAR L) (ELIMINAR X (CDR L)))
			)
			(APPEND (LIST(ELIMINAR X (CAR L)))(ELIMINAR X (CDR L)))
		)
	)
)

Dadas dos listas simples que representan conjuntos definir : la unión, la intersección y diferencia simétrica.

	(DEFUN UNION (L1 L2)
		(COND
			((NULL L1) L2)
			((PERTENECE (CAR L1) L2)(UNION (CDR L1) L2))
			(T(UNION (CDR L1)(CONS (CAR L1) L2)))
		)
	)
	
	(DEFUN INTERSECCION (L1 L2)
		(IF(NOT(NULL L1))
			(COND
				((PERTENECE (CAR L1)L2) (CONS (CAR L1)(INTERSECCION (CDR L1) L2)))
				(T(INTERSECCION (CDR L1) L2))
			)
		)
	)
	
	(DEFUN DIFERENCIA (L1 L2)
		(IF(NOT(NULL L1))
			(DIFERENCIA (CDR L1)(ELIMINAR (CAR L1) L2))
			L2
		)
	)
	
	(DEFUN DIFERENCIA_SIMETRICA( L1 L2)
		(APPEND (DIFERENCIA L1 L2)(DIFERENCIA L2 L1))
	)
	

Definir una función para obtener el último átomo de una lista a todo nivel.

(DEFUN ULTIMO (L)
	(IF (NOT(NULL(CDR L)))
		(ULTIMO(CDR L))
		(COND
			((ATOM (CAR L)) (CAR L))
			(T(ULTIMO (CAR L)))
		)
	)
)

Definir una función para determinar si una estructura es componente de otra.

(DEFUN CONT  (L1 L2)
	(COND
		((NULL L1) T)
		((NULL L2) NIL)
		((EQ (CAR L1)(CAR L2))(CONT (CDR L1)(CDR L2)))
		(T (CONT L1 (CDR L2)))
	)
)

Definir una función para obtener el elemento central de una lista. ( la lista tiene longitud impar).

;elimina n elementos de L que tiene TOTAL elementos
(DEFUN ELIMINAR_N (N L TOT)
	(IF (=(LENGTH L)(- TOT N))
		L
		(ELIMINAR_N N (CDR L) TOT )
	)
)
(DEFUN CENTRAL (L)
		(CAR(ELIMINAR_N(/(-(LENGTH L)1)2) L (LENGTH L)))
)

Definir una función para eliminar los elementos repetidos de una lista simple.

(DEFUN ELI_REP (L)
	(COND
		((NULL  L) NIL)
		((PERTENECE (CAR L) (CDR L))(ELI_REP (CDR L)))
		(T(CONS (CAR L)(ELI_REP (CDR L))))
	)
)

;FUNCIONES QUE SIRVEN PARA ORDENAR UNA LISTA

(DEFUN ORDENAR (L)
	(IF (NULL(CDR L))
		L
		(CONS (SEL_MENOR L)(ORDENAR(ELIMINAR (SEL_MENOR L) L)))
	)
)

;EVUELVE EL MENOR ELEMENTO DE L
(DEFUN SEL_MENOR (L)
	(IF (NULL (CDR L))
		(CAR L)
		(IF (< (CAR L)(CADR L))
			(SEL_MENOR (CONS(CAR L)(CDDR L)))
			(SEL_MENOR (CDR L))
		)
	)
)

Definir una función para ordenar una lista de listas por longitud creciente.

(DEFUN ORDENAR_LONG (L)
	(IF (NULL(CDR L))
		(LIST(CAR L))
		(APPEND
			(LIST(SEL_MENOR_LONG L))
			(ORDENAR_LONG(ELIMINAR_SUBL (SEL_MENOR_LONG L) L))
		)
	)
)

;ME DEVUELVE LA SUBLISTA DE L QUE TIENE MENOR LONGITUD
(DEFUN SEL_MENOR_LONG (L)
	(IF (NULL (CDR L))
		(CAR L)
		(IF (< (LENGTH(CAR L))(LENGTH(CADR L)))
			(SEL_MENOR_LONG (APPEND(LIST(CAR L))(CDDR L)))
			(SEL_MENOR_LONG (CDR L))
		)
	)
)


;ELIMINA LA SUBLISTA L1 DE LA LISTA DE LISTAS L
(DEFUN ELIMINAR_SUBL (L1 L)
	(IF (NOT (NULL L))
		(IF (NOT(ATOM (CAR L)))
			(IF (L_IGUALES L1 (CAR L))
				(ELIMINAR_SUBL L1 (CDR L))
				(APPEND (LIST(CAR L)) (ELIMINAR_SUBL L1 (CDR L)))
			)
			(CONS(CAR L)(ELIMINAR_SUBL L1 (CDR L)))
		)
	)
)

Definir una función F que aplicada a una operación diádica asociativa Y y a una lista L obtenga el resultado de aplicar Y entre cada dos componentes sucesivas de L.

(DEFUN F (Y L)
	(IF (NULL (CDR L))
		L
		(APPEND 
			(LIST(FUNCALL Y (CAR L)(CADR L)))
			(F Y (CDDR L))
		)
	)
) 

Definir una función B que aplicada a una lista de funciones F y a un argumento X obtenga la lista de resultados de aplicar cada función F a X.

(DEFUN B (LF X)
	(IF (NULL LF)
		LF
		(APPEND 
			(LIST(FUNCALL (CAR LF) X))
			(B (CDR LF) X)
		)
	)
)

Definir una función C que aplicada a una lista de funciones F y a un argumento X obtenga la compuesta de aplicar todas las funciones F a X.

(DEFUN C (LF X)
	(IF (NULL LF)
		X
		(C (CDR LF)(FUNCALL (CAR LF) X))
	)
)


;FUNCION ALFA de FP
(DEFUN ALFA (OP L)
	(COND
		((NULL L)NIL)
		(T(APPEND (LIST(FUNCALL OP (CAR L)))(ALFA OP(CDR L))))
	)
)

;FUNCION IOTA (desde el n0)

(DEFUN IOTA(N n0)
	(IF(EQ N n0)
		(LIST n0)
		(CONS n0 (IOTA N (+ n0 1)))
	)
)

Representando una matriz cuadrada como la lista de listas obtener la matriz triangular derecha incluyendo la diagonal principal.

(DEFUN TRIG_DER  (M)
	(CEROS_M (IOTA (LENGTH M) 0) M)
	
)

;pone la cantidad de 0 q dice cada elemento de L0 en la lista correspondiente de la matriz M
(DEFUN CEROS_M (L0 M)
	(IF (NULL (CAR M))
		(CAR M)
		(APPEND (LIST(CEROS_L (CAR L0)(CAR M)))(CEROS_M (CDR L0)(CDR M)))
	)
)

;funcion q pone N 0 al principio de L
(DEFUN CEROS_L (N L)
	(IF (EQ 0 N)
		L
		(CONS 0 (CEROS_L (- N 1)(CDR L)))
	)
) 

Representando una matriz cuadrada como la lista de listas obtener la diagonal principal.

(DEFUN DIAGONAL (M)
	(IF (NULL (CAR M))
		NIL
		(CONS (CAAR M)(DIAGONAL (ALFA 'CDR (CDR M))))
	)
)

Escribir una función que aplicada a una lista de listas dé como resultado la lista de las combinaciones simples de a 2 de sus elementos.
Ej: ( A B C ) —> ( ( A B ) ( A C ) ( B C ) )

(DEFUN COMB (L)
	(IF (NULL (CDR L))	
		NIL
		(APPEND (ENLISTAR (CAR L)(CDR L))(COMB (CDR L)))
	)
)

;devuelve una lista q esta formada con lista que tiene las comb de x con lo q hay en L
(DEFUN ENLISTAR (X L)
	(IF (NULL (CAR L))
		NIL
		(APPEND(LIST(LIST X (CAR L)))(ENLISTAR X (CDR L )))
	)
)

Definir una función para trasponer una lista de listas.

(DEFUN TRASPUESTA (M)
	(IF (NULL (CAR M))
		NIL
		(APPEND (LIST(ALFA 'CAR M))(TRASPUESTA (ALFA 'CDR M)))
	)
)