;;; INTELIGENCIA ARTIFICIAL II.                                    CURSO 99-00.
;;; EXAMEN PR\'ACTICO                                           DICIEMBRE 2000.
;;;****************************************************************************

;;; Apellidos:
;;; Nombre:

;;;****************************************************************************
;;; ENUNCIADO:
;;;****************************************************************************

;;; El programa DEBE SER HECHO SIGUIENDO LAS INSTRUCCIONES DE LOS EJERCICIOS
;;; SIGUIENTES, en los que se desarrollar\'an cuatro m\'odulos:

;;; - M\'odulo MAIN: control del programa.
;;; - M\'odulo DIVISION: reconoce si una lista est\'a o no ordenada, en cuyo
;;;   caso la divide (seg\'un el algotritmo). 
;;; - M\'odulo UNION: une dos listas ordenadas (seg\'un el algoritmo). 
;;; - M\'odulo FINAL: imprime por pantalla mensajes con la soluci\'on del
;;;   problema.

;;; NOTA: El examen ha de resolverse sin el uso de bucles, condicionales,
;;;   definici\'on de nuevas funciones ni declaraci\'on de prioridades.

;;; AVISOS:
;;;  - Antes de enviar la soluci\'on no te olvides de rellenar los datos
;;;    pedidos en la cabecera.
;;;  - Se recomienda leer el contenido completo de este fichero antes de
;;;    comenzar a resolver el ejercicio.
;;;  - El c\'odigo comentado se puede utilizar libremente en la resoluci\'on
;;;    del examen. 

;;; Como ejemplo de funcionamiento pueden considerarse las siguientes listas:

;;; A: (5 8 1 3 4 1 5 9 3 8 6 3 2 6 9 2 1 0)
;;; B: (8 7 3 9 2 7 4 8 5 2 1 0 8 4 3 3 7)
;;; C: (1 3 5 7 9)

;;;============================================================================
;;; (Re)definir el m\'odulo MAIN
;;;============================================================================

(defmodule MAIN
  (export deftemplate lista))

;;; Definir una plantilla "lista" que sirva para almacenar los datos relativos
;;; a las diferentes listas: nombre de la misma, elementos que la constituyen y
;;; estado en que se encuentra (ordenada, division o desordenada).










;;; Para hacer pruebas se recomienda incluir un "deffacts" con las listas que
;;; pretendemos ordenar.

; (deffacts comienzo
;   (lista (nombre A)
; 	 (elementos 5 8 1 3 4 1 5 9 3 8 6 3 2 6 9 2 1 0))
;   (lista (nombre B)
; 	 (elementos 8 7 3 9 2 7 4 8 5 2 1 0 8 4 3 3 7))
;   (lista (nombre C)
; 	 (elementos 1 3 5 7 9)))

;;; La siguiente regla permite ejecutar los m\'odulos DIVISION, UNION Y FINAL
;;; en dicho orden. 

(defrule MAIN::cambia
  =>
  (focus DIVISION UNION FINAL))

;;;============================================================================
;;; Definir el m\'odulo DIVISION
;;;============================================================================

(defmodule DIVISION
  (import MAIN deftemplate lista))

;;; Definir las reglas que sean necesarias para que dada una lista, si está
;;; desordenada, se creen: la lista de los elementos mayores que el primero y
;;; la de los menores. (Diremos que estas nuevas listas están asociadas a la
;;; primera). Durante el proceso la lista original debe tener como valor del
;;; campo estado, division.

;;; Nota: Recuerda que el nombre de la lista de los elementos mayores que el
;;; primero se obtiene añadiendo un 1 al nombre de la lista original y que el
;;; nombre de la de los menores, añadiendo un 2.













;;;============================================================================
;;; Definir el m\'odulo UNION
;;;============================================================================

(defmodule UNION
  (import MAIN deftemplate lista))

;;; Definir una regla que reconozca listas ordenadas e indicar que lo están
;;; (usando el campo que guarda información sobre el estado de la lista)







;;; Definir las reglas que sean necesesarias para unir listas asociadas
;;; (seg\'un lo dicho en el m\'odulo DIVISION) una vez ordenadas.










;;;============================================================================
;;; Definir el m\'odulo FINAL
;;;============================================================================

(defmodule FINAL
  (import MAIN deftemplate lista))

;;; Definir una regla que imprima en pantalla los mensajes de salida

(defrule FINAL::final
  (lista (nombre ?x)
	 (elementos $?e)
	 (estado ordenada))
  =>
  (printout t ?x " ordenada es " ?e crlf))

;;;****************************************************************************