Ejercicios Grupo 1

1. Defina una funcion que permita sumar los n primeros nmeros

(deffunction suma(?n)
(bind ?su (+ 0 0))
(while(> ?n 0)
(bind ?su (+ ?su ?n))
(bind ?n (- ?n 1))
)
return ?su
)
2.

Definir una funcin que asigne a los das de la semana los nmeros 1,2,3,4,5,6,7
respectivamente

(deffunction
semana(?n)
(if(= ?n 1)then
(printout t "lunes" crlf)
)
(if(= ?n 2)then
(printout t "martes" crlf)
)
(if(= ?n 3)then
(printout t "miercoles" crlf)
)
(if(= ?n 4)then
(printout t "jueves" crlf)
)
(if(= ?n 5)then
(printout t "viernes" crlf)
)
(if(= ?n 6)then
(printout t "sabado" crlf)
)
(if(= ?n 7)then
(printout t "domingo" crlf)
)
)
3. Leda una fecha ,decir el da de la semana, suponiendo que el dia 1 de dicho
mes fue lunes
(deffunction dia(?n)
(bind ?resto (mod ?n 7))
(switch ?resto
(case 1 then
(printout t "lunes" crlf)
)
(case 2 then
(printout t "martes" crlf)

)
(case 3 then
(printout t "miercoles" crlf)
)
(case 4 then
(printout t "jueves" crlf)
)
(case 5 then
(printout t "viernes" crlf)
)
(case 6 then
(printout t "sabado" crlf)
)
(case 7 then
(printout t "domingo" crlf)
)
(default domingo)
)
)

4. Define una plantilla denominada curso que represente una relacin de cursos
con los siguientes campos simples: nombre del curso, cdigo del curso, numero
de crditos, nombre del profesor e ingresar 1 hecho en la memoria de trabajo
(deftemplate curso
(slot nombre)
(slot codigo)
(slot num_creditos)
(slot nombre_profesor)
)
(assert (curso
(nombre inteligencia)
(codigo 001)
(num_creditos 4)
(nombre_profesor mauricio)
))
5. Mostrar los hechos almacenados en memoria de trabajo con los siguientes
parmetros
Mostrar todos los hechos
Mostrar primer hecho almacenado

 Mostrar todos los hechos desde el primero hasta el nmero 1.

(facts)
(facts 1)
(facts 0 1)
6. Eliminar y modificar el hecho de la plantilla curso
(retract 1)
(modyfi 1 (nombre sistemas))

7. defina una funcion que permita definir el promedio de notas

(deffunction promedio(?a ?b)
(bind ?pr (+ 0 0))
(bind ?p (+ ?a ?b))
(bind ?pr (/ ?p 2))
reurn ?pr
)
8. defina una funcion que demuestre si un alumno esta aprobado de acuerdo a su
nota
(deffunction calificacion(?n)
(if(> ?n 10.5)then
(printout t "aprobado" crlf)
)
(if(< ?n 10.5)then
(printout t "desaprobado" crlf)
)
(if(= ?n 10.5)then
(printout t "aprobado" crlf)
)
)
9. dado un monto calcular el descuento considerando de que por encima de 100 el
dsct es 10% y por debajo el 2%
(deffunction monto(?n)
(if(> ?n 100)then
(bind ?ds (/ (* ?n 10) 100))
)
(if(< ?n 100)then
(bind ?ds (/ (* ?n 2) 100))
)
return ?ds
)
10. dado un numero determinar la suma de sus digitos
(deffunction digitos(?n)
(bind ?s (+ 0 0))

(while(!= ?n 0)
(bind ?r (mod ?n 10))
(bind ?s (+ ?s ?r))
(bind ?s (/ ?n 10))
)
return ?s
)
11. Define una plantilla denominada profesor que represente una relacin de
profesores
con los siguientes campos simples:
nombre del profesor, cdigo del profesor, dni, asigmnatura e ingresar 1 hecho en la
memoria de hecho
(deftemplate profesor
(slot nombre)
(slot codigo)
(slot dni)
(slot asignatura)
)
(assert (profesor
(nombre mauricio)
(dni 44158963)
(asignatura inteligencia artificial)
))
12. leer dos numeros y ver en panltalla si estan en orden creciente o decreciente
(deffunction orden(?a ?b)
(if(< ?a ?b)then
(printout t "orden creciente")
else
(printout t "orden creciente")
)
)
13. Dado una lista de nmeros encuentra el mayo de ellos, para ello Ud. Debe
implementar una regla en CLIPS ms no una funcin.
Solucin:
(defrule maximo
(vector $? ?x $?)
(not (vector $? ?y&:(> ?y ?x) $?))
=>
(printout t "El maximo es " ?x crlf))

14. En una caja existen diferentes tipos de objetos con un color especfico tales como
esferas (azul), cubos (rojo), pirmides (verde) y cilindros (blanco). Escribe una serie
de reglas de manera que en base a un hecho que indique el color del objeto
identifique que clase de objeto es. Por ejemplo, si se afirma un hecho como
(color rojo). Al ejecutar el programa debera imprimirse por pantalla un
mensaje como Se trata de un cubo.
Solucin:
Para el desarrollo de este ejercicio, hemos creado un
deffacts con hechos de objetos, es decir el hecho
(objeto cubo rojo), significa que ese tipo objeto es
de ese color, para ver luego a que tipo de objeto
estamos buscando introducimos un hecho como (color
rojo) y nos muestra el tipo de objeto que es.
(deffacts Introducir_objetos "Introduccion de objetos y colores"
(objeto cubo rojo)
(objeto esfera azul)
(objeto pirmide verde)
(objeto cilindro blanco)
)
(defrule colores
(color ?x)
(objeto ?objeto ?x)
=>
(printout t "Se trata de un " ?objeto crlf)
)

15. Teniendo el siguiente razonamiento lgico, construya en CLIPS los hechos y reglas
que sean necesarias para llegar a la conclusin de que Carmen es peruana y Carmen
es americana.
Carmen es una persona
Carmen vive en Lima
Toda persona que vive en Lima es peruana
Toda persona que vive en Per es Americana
Solucin.
;hechos
(assert (persona carmen))
(assert (limena carmen))
;reglas

(defrule peruana
(persona ?x)
(limena ?x)
=>
(assert (peruana ?x))
(printout t ?x "es peruana" crlf))
(defrule americana
(persona ?x)
(peruana ?x)
=>
(assert (americana ?x))
(printout t ?x "es americana" crlf))

16. Dada una lista de nmeros obtener la lista ordenada de menor a mayor. Para ello
debes usar reglas no funciones.
Solucin:
(assert (vector 3 2 1 4))
(defrule inicial
(vector $?x)
=>
(assert (vector-aux ?x))
)
(defrule ordena
?f <- (vector-aux $?b ?m1 ?m2&:(< ?m2 ?m1) $?e)
=>
(retract ?f)
(assert (vector-aux $?b ?m2 ?m1 $?e))
)
(defrule final
(not (vector-aux $?b ?m1 ?m2&:(< ?m2 ?m1) $?e))
(vector $?x)
(vector-aux $?y)
=>
(printout t "La ordenacion de " ?x " es " ?y crlf)
)

17. Si se dispone de una serie de hechos que almacenan informacin acerca del nombre
de personas y el da de su cumpleaos, escribe una regla que dado un hecho como
(comprobar-cumple (dia 21-7)) muestre por pantalla el nombre de las personas
que cumplen aos ese da.
Solucin:
Construimos la plantilla personas, con los slots nombre y dia.
(deftemplate personas
(slot nombre)
(slot dia)
)

Construimos la plantilla comprobar-cumple, que contendr el slot dia. Esta

plantilla se usa para buscar a las personas que cumplan aos el dia que contenga
el slot dia.
(deftemplate comprobar-cumple
(slot dia)
)

Construimos un deffacts para introducir hechos de tipo personas, para que el

usuario no lo tenga que introducir. Tambin introducimos un hecho de tipo
comprobar cumple para realizar las pruebas oportunas.
(deffacts Introducir_personas "Introducir hechos a
personas"
(personas (nombre "Eduardo Javier Rodriguez Lopera")
(dia 07/05))
(personas (nombre "Mercedes Granados Rodriguez")
(dia 22/11))
(personas (nombre "Inmaculada Rodriguez Lopera")
(dia 31/12))
(personas (nombre "Benito Rodriguez")
(dia 13/09))
(personas (nombre "Josefa Lopera Fernandez")
(dia 26/10))
(personas (nombre "Inventado")
(dia 07/05))
(comprobar-cumple (dia 07/05))
)

plantilla

Construimos la regla comprobar_cumple, que se encargar de comprobar que un

hecho persona cumple aos el mismo dia que el hecho comprobar-cumple, y
muestra un mensaje de Felicidades <nombre>.
(defrule comprobar_cumple
(personas (nombre ?nomb) (dia ?ddia))
(comprobar-cumple (dia ?ddia))
=>
(printout t " Felicidades " ?nomb crlf)
)

18. Se tiene dos conjuntos A={a, b} y B={b, c}, defina las reglas necesarias en CLIPS,
para obtener la unin de dichos conjuntos C={a, b, c}.
Solucin:
Para obtener la unin necesitamos definir primero los hechos sobre las que
tienen que operar las reglas.
Definicin de hechos
(deffacts conjuntos
(A a b)
(B b c)
)

El siguiente paso es definir las reglas necesarias para la manipulacin de estos

hechos y lograr el objetivo.
(defrule unir
=>
(assert (union)))
(defrule union-base
?union <- (union $?u)
?A <- (A $?e-1)
?B <- (B)
=>
(retract ?A ?B ?union)
(assert (union ?e-1 ?u))
(assert (mostrar)))
(defrule mostrar
(mostrar)
(union $?u)
=>
(printout t "La union es " ?u crlf))
(defrule union-compartido
(union $?)
?B <- (B ?e $?r-2)
(A $? ?e $?)
=>
(retract ?B)
(assert (B ?r-2)))
(defrule union-no-compartido
?union <- (union $?u)
?B <- (B ?e $?r-2)
(not (A $? ?e $?))
=>
(retract ?B ?union)
(assert (B ?r-2)
(union ?u ?e)))

19. Escribe un programa para ayudar a una persona a decidir qu plantas podra plantar.
La siguiente tabla indica las caractersticas de una serie de plantas (tolerancia al fro,
tolerancia a la sombra, tolerancia al clima seco, tolerancia al suelo hmedo,
tolerancia al suelo cido, si puede vivir en la ciudad, si puede vivir en una maceta, si
es fcil de cuidar y si es de crecimiento rpido). La entrada al programa debe
consistir en un conjunto de hechos del tipo (caracteristica-deseada <caracterstica>)
que indiquen caractersticas que se desee que tenga una planta. El programa debe
mostrar por pantalla el nombre de las plantas que cuenten exactamente con las
caractersticas indicadas, ni ms ni menos.
Solucin:
Construimos la plantilla plantas, la cual est formada por el slot nombre y el
multislot tolerancia.
(deftemplate plantas
(slot nombre (type STRING))
(multislot tolerancia (type SYMBOL))
)

Indica que una planta puede plantarse si cumple las caracteristicas deseadas que
se hallan afirmado
(deftemplate puede-plantarse
(slot planta)
)

Construimos un deffacts para introducir hechos relativos a las plantas, sin

necesidad de que los tenga que introducir el usuario.
(deffacts Insertar-plantas "Insertar
plantas"
(plantas (nombre "Hortensia")

plantas

en

la

plantilla

(tolerancia sombra ciudad maceta crece-rapido))

(plantas (nombre "Adelfa")
(tolerancia ciudad maceta cuidado-facil crece-rapido))
(plantas (nombre "Laurel")
(tolerancia frio sombra sequedad suelo-humedo ciudad cuidadofacil crece-rapido))
(plantas (nombre "Madreselva")
(tolerancia ciudad maceta cuidado-facil crece-rapido))
(plantas (nombre "Gardenia")
(tolerancia sombra suelo-acido maceta))
(plantas (nombre "Enebro")
(tolerancia frio sequedad suelo-acido ciudad cuidado-facil))
(plantas (nombre "Pimentero")
(tolerancia frio sombra suelo-humedo suelo-acido cuidad cuidadofacil)) (plantas (nombre "Escaramujo")
(tolerancia frio sombra suelo-humedo ciudad cuidado-facil))
(plantas (nombre "Aucuba")
(tolerancia sombra sequedad maceta cuidado-facil))
(plantas (nombre "Azalea")
(tolerancia sombra suelo-humedo suelo-acido maceta))
(caracteristica-deseada sombra)
(caracteristica-deseada ciudad)
(caracteristica-deseada maceta)
(caracteristica-deseada crece-rapido))

Construimos la regla plantar, la cual se va a encargar de verificar si una planta

dispone de la caracterstica que estamos buscando y de ir insertando en la
plantilla puede-plantarse el nombre de la planta.
(defrule plantar
(plantas (nombre ?nombre))
(forall
(caracteristica-deseada ?c1)
(plantas (nombre ?nombre) (tolerancia $? ?c1 $?)))
(forall (plantas (nombre ?nombre) (tolerancia $? ?c2 $?))
(caracteristica-deseada ?c2))
=>
(assert (puede-plantarse (planta ?nombre))))

Construimos la regla imprimir, la cual se va a encargar de ir mostrando por

pantalla todas las plantas de la plantilla puede-plantarse, las cuales cumplen con
todas las caractersticas.
(defrule imprimir
(puede-plantarse (planta ?p))
=>
(printout t "La planta " ?p " puede plantarse"crlf)
)

20. Haz un programa que calcule el factorial de un nmero, de manera que ante un
hecho como (factorial 3) muestre por pantalla el siguiente mensaje.
El factorial de 3 es 6, usando reglas.
Solucin:
Construimos un deffacts para introducir un hecho relativo a factorial, para
realizar el factorial de un nmero, tenemos que introducir 3 hechos, el hecho
factorial con el nmero, un hecho para ir almacenado el resultado y un hecho

numero para saber luego cual es el nmero que hemos factorizado, ya que en
este ejercicio sigo la estrategia de ir disminuyendo factorial en uno, y sigo
realizando factorial hasta que sea 0, con lo cual no s al final que nmero he
factorizado.
(deffacts Introducir_factorial
(factorial 5)
(resultado 1)
(numero 5)
)

Construimos una regla calcular_factorial, es la que se encarga de realizar el

factorial, si el nmero que hay en factorial es > 0 sigo calculando el factorial,
retracto los hechos factorial y resultado para insertarlo con el nuevo nmero a
factorizar y realizando los clculos oportunos guardndolos en resultado.
(defrule calcular_factorial
?f1<-(factorial ?numero)
?f2<-(resultado ?resultado)
(test( > ?numero 0))
=>
(retract ?f1)
(retract ?f2)
(assert (factorial (- ?numero 1)))
(assert (resultado (* ?resultado ?numero)))
)

Construimos una regla muestra_resultado, es la que se encarga de visualizar por

pantalla el factorial del nmero, esta regla se va a disparar cuando haya un hecho
en la bases de hechos como (factorial 0), habiendo as llegado a la finalizacin
del factorial.
(defrule muestra_resultado
(factorial ?numero)
(resultado ?resultado)
(numero ?x)
(test(= ?numero 0))
=>
(printout t "El factorial de " ?x " es:" ?resultado crlf)
)