INSTITUTO TECNOLOGICO SUPERIOR DE LA

HUERTA
Carrera:
Ing. En sistemas computacionales
Materia:
Programacin lgica funcional
Trabajo:
Antologa
Profesor:
Jos Luis Gonzlez Ortiz
Alumno:
Abraham Maximiliano Murillo Aguilar

12101040

16/06/2016

Programacin Lgica Antologa

Unidad 1.- Conceptos Fundamentales
Estilos de Programacin
Concepto de un lenguaje de programacin:
Lenguaje artificial que se utiliza para expresar programas de computadora. Cada
computadora segn su diseo entiende un conjunto de instrucciones elementales (Lenguaje
Maquina) pero para facilitar la tarea del programador se dispone tambin de lenguajes de
alto nivel ms fciles de manejar y no dependen del diseo especfico de cada
computadora.

Para definir un lenguaje de programacin es necesario especificar: Conjunto de

smbolos y palabras claves utilizables

Reglas gramaticales para construir sentencias sintctica y semnticamente correctas
A) Sintaxis: Conjunto de normas que determinan como escribir la sentencia del
lenguaje
B) Semntica: Interpretacin de las sentencias indica el significado de las mismas.
Caractersticas de un buen estilo de programacin

Extensibilidad: La facilidad con que se adapta el software a cambio de

especificacin, hacen que un buen estilo de cdigo fomente programas que no solo
resuelvan el problema si no que tambin reflejen claramente la relacin problema

solucin.
Verificabilidad: La facilidad con que pueden comprobarse las propiedades de un
sistema. Si el estilo de cdigo hace obvia la estructura esa ayuda a verificar que el

comportamiento sea el esperado.

Reparabilidad: La posibilidad de corregir errores sin demasiado esfuerzo.
Evolucin: Es la capacidad de adaptarse a nuevas necesidades.
Comprensibilidad: La facilidad con el que programada puede ser comprendido

Estilo K&R:

Utilizado por Kernighan y Ritchie en su libro El lenguaje de programacin C

Abre las llaves al finalizar una sentencia de control
En el caso de las funciones la llave es abierta en la lnea siguiente.
El tamao de las tabulaciones es de 4 espacios.

[C]
void main()
{
while (1) {
printf("Hello World!");
}
}
[/C]
Estilo BSD KNF (Kernel Normal Form):

La forma ms difundida en cdigo basado en Sistemas Operativos que heredan de

BSD.
Estilo de cdigo del Kernel de Linux (Linux kernel coding style)
Utiliza dos tabuladores (Hard tab y Soft tab) de 8 y 4 columnas respectivamente
El hard tab es utilizado para indentar bloques de cdigo
El soft tab se utiliza para indetacion adicional en aquellos casos que una lnea
continue en varias lneas

[C]
static void
shrek(void *cx, char *obj, int arg,
void *argv, void *rval)
{
if (CheckProperty(cx, o, "data",

CONTS_LIMIT,
NULL, NULL, ) != 0) {
fprintf(stderr,"Cannot check property\n");
fflush(stderr);
}
free(data);
return (NO_ERROR);
}
[/C]
Estilo Allman

Tambin conocido como ANSI style

Ubica las llaves en la siguiente lnea a una sentencia de control
Las sentencias son indentadas al siguiente nivel de las llaves

[C]
//for (int i=0; i < x; i++) //while (x == y) if (x == y) { something(); somethingelse(); } [/C]
GNU style

Ubica las llaves en una lnea para si mismo

Las llaves son indentadas con dos espacios y el cdigo es indentado con dos

espacios ms
Popularizado por Richard Stallman
El comando reformat del editor Emacs reformatea el cdigo, por defecto, con este
estilo (como no poda ser de otra manera)

[C]
while (x == y)

{
something ();
somethingelse ();
}
finalthing ();
[/C]
Estilo Whitesmith

(uno de los primeros compiladores de C)

if(condicion)
{
sentencia0;
sentencia1;
}
Evaluacin de expresiones
Son el mtodo fundamental que tiene el programador de expresar computacionales
Las expresiones estn compuestas por operadores, operandos, parntesis y llamadas
funciones. Los operadores pueden ser:
-

Unarios: cuando tan solo tienen un operando. Son operadores prefijos

Binarios: tienen 2 operandos, son operadores infijos
Ternarios: tienen 3 operandos

Expresiones
3+6*14
-4*7+2+3/4-5
(33+3*4)/5
2+2*3
8+7*3+4*6
16*6-3*2
4/2*3/6
6/2/1/5-2/4*2
3+3*2
(((B+C)/2*A+10)*3*B)-6

resultado
87
-30.25
9
8
53
90
1
-4.0
9
324

A=4
B=5
C=1

Jerarqua en los operadores de java

Tipos Primitivos. Los cuales se definen abajo.

Referencias. Las cuales corresponden a clases y objetos que se tratarn

posteriormente.
Tipos primitivos
Los tipos primitivos son los que permiten manipular valores numricos (con distintos
grados de precisin), caracteres y valores bolanos (verdadero / falso). Los Tipos Primitivos
son:

boolean: Puede contener los valores true o false.

byte: Enteros. Tamao 8-bits. Valores entre -128 y 127.

short: Enteros. Tamao 16-bits. Entre -32768 y 32767.

int: Enteros. Tamao 32-bits. Entre -2147483648 y 2147483647.

long:

Enteros.

Tamao

64-bits.

Entre

9223372036854775807.

float: Nmeros en coma flotante. Tamao 32-bits.

double: Nmeros en coma flotante. Tamao 64-bits.

-9223372036854775808

char: Caracteres. Tamao 16-bits. Unicode. Desde '\u0000' a '\uffff' inclusive. Esto
es desde 0 a 65535
Variables
Una variable es un rea en memoria que tiene un nombre y un Tipo asociado. El Tipo es o
bien un Tipo primitivo o una Referencia.
Es obligatorio declarar las variables antes de usarlas. Para declararlas se indica su nombre y
su Tipo, de la siguiente forma:
tipo_variable nombre ;
Ejemplos:
int i;

// Declaracion

char letra;

de

// Declaracion

de

un

entero

un

caracter

boolean flag; // Declaracion de un booleano

El; es el separador de instrucciones en Java.

El smbolo // indica comentarios de lnea, se ponen despus de una instruccin para

comentarla, el compilador no las toma al detectarlas.
En Java las maysculas y minsculas son significativas. No es lo mismo el nombre

letra

que Letra.

Todas las palabras reservadas del lenguaje van en minsculas.

Se pueden asignar valores a las variables mediante la instruccin de asignacin (=). Por
ejemplo:
i
letra

5;
=

//
'c';

//

a
a

la
la

variable
variable

i
letra

se

le

se

le

asigna

el

valor

asigna

el

valor

'c'

flag = false; // a la variable flag se le asigna el valor false

La declaracin y la asignacin se pueden combinar en una sola expresin:
int
char

=
letra

5;
=

'c';

boolean flag = false;

Operaciones Bsicas
En java al igual que en C++ se tienen una serie de operadores que ayudan a obtener
clculos, dependiendo de los valores a utilizar, Java trabaja con los siguientes operadores:
Operadores Aritmticos

Operador en Java

Significado

suma

resta

multiplicacin

divisin
%

residuo

Otros operadores de Asignacin

En Java, como en C++, es posible abreviar algunas expresiones de asignacin como se
muestra en la siguiente tabla:
Operador
v+=e
v-=e
v*=e
v/=e
v%=e
Otros Operadores aritmticos
En Java, al igual que en C++, existen tambin los siguientes operadores aritmticos:
++

incremento

-- decremento
Jerarqua de los operadores aritmticos

Asociatividad
Empezando por los parntesis ms internos
De derecha a izquierda, ++ y -- dependiendo de la po
De izquierda a derecha
De izquierda a derecha
De derecha a izquierda

Funcin

Una funcin en matemticas, es una operacin que toma uno o ms valores

(argumentado) y devuelve un resultado (valor de una funcin para argumentos dados). Por
ejemplo
F (X)=X/ (1+X2)
Donde:
F Nombre de la funcin
X Es el argumento (tambin conocido como el parmetro formal)
Definicin de funciones: una definicin de funcin es la que presenta de la siguiente
manera:
Funcin nombre_funcion (p1, p2,..., pn)
Inicio
Bloque de instrucciones
Fin
Donde:
Funcin Es la palabra clave que nos indica una definicin de funcin
Nombre_funcin es el identificador con el cual se reconoce a la funcin en el cuerpo del
algoritmo principal
p1, p2,..., pn Es el grupo de parmetros que define a la funcin.
Llamado a una funcin
Cuando definimos una funcin solo le indicamos al algoritmo que esta funcin
existe, pero una definicin no implica la realizacin de las instrucciones que la constituyen.
Para hacer uso de una funcin el algoritmo principal debe llamar. Por ejemplo
Funcin F(x)
Inicio

F=x/ (1+x^2)
Fin
Inicio
Imprimir este es el algoritmo principal
Leer N
R=F(N) llamado de la funcin
Imprimir el resultado de la funcin es: , R
Fin
Disciplina de tipos
los tipos que ingieren es decir se comprueban de forma esttica, en tiempo de
compilacin.
En los lenguajes de programacin con disciplinas de tipos, cada tipo representa una
coleccin de valores o datos similares. El conocer los tipos de las funciones ayuda a
documentar los programas y evita errores en tiempo de ejecucin.
Un lenguaje tiene la disciplina de tipos si los errores se detectan siempre, es
necesario determinar los tipos de todos los operados, ya sea en tiempos de compilacin o
ejecucin.

C: no tiene disciplina de tipos, por que realiza comprobacin de tipos sobre las
uniones, y permite funciones con parmetros sobre los que no se realizan

comprobacin de tipos.
Java: si tiene disciplina de tipos porque no hay uniones
Haskell: tambin pose disciplinas de tipos, porque los tipos de los parmetros de las
funciones se conocen en tiempo de compilacin.

Haskell y otros lenguajes funcionales utilizan el sistema de tipos milner, que tienen 2
caractersticas fundamentales

Disciplina esttica de tipos: los programas bien tipados se pueden conocer en

tiempo de compilacin, tambin se puede utilizar sin afectar comprobaciones de

tipo en tiempo de ejecucin, est garantizado que no se producirn errores de tipo.

Polimorfismo: permite que una misma funcin se pueda aplicar a parmetros de
diferentes tipos, dependiendo del contexto en que la funcin se utiliza

Paradigmas de programacin
Un paradigma de programacin es una coleccin de patrones conceptuales que modelan la
forma de razonar sobre problemas, formular soluciones y de estructurar paradigmas de
programacin son:

Programacin imperativa

En este paradigma un programa es una secuencia finita de instrucciones que se ejecutan una
tras otra. Los datos utilizados se almacenan en memoria principal y se referencia utilizando
variables
Ejemplo
Leer (x)
Leer (y)
Resultado= x+y
Escribir (resultado)

Programacin funcional

Paradigma en que todas las sentencias son funciones en el sentido matemtico del trmino.
Un programa es una funcin que se define por composicin por funciones ms simples la
misin de la computadora ser evaluar funciones.
Ejemplo
Predecesor (x)= x-1, si x>0
Sucesor (x) = x+1
Sumar (x,0)=x
Sumar (x,y)= sucesor(suma

Programacin lgica
En este paradigma un programa consiste en declarar una serie de hechos (elementos
conocidos y relacin de objetos completos) y reglas (relacin general entre objetos

que cumple sus propiedades) y luego preguntar por el resultado.

Mujer (Martha)
Mujer (Rosa)
Mujer (Laura)
Padres (rosa, Carlos, Pilar)
Padres (Martha, Carlos, Pilar)
Padres (Laura, carlos, Pilar)
Hermanas (x,y):-mujer(x), mujer(y), padres(x,p,m), padre,(y,p,m)
? _Hermanas (Rosa, Martha)
? _Hermanas (Rosa x)
Prolog
Programacin orientada a objetos

Este paradigma puede ser tanto imperativo cmo funciona y lgico. Lo que caracteriza un
lenguaje orientado objetos es la forma de manejar la informacin qu est basada en tres
conceptos

Clase: tipos de datos con una determinada propiedad y una determinada

funcionalidad, ejemplo clase persona.

Objeto: entidad de una determinada clase con un determinado estado, capaz de

interactuar con otros objetos, ejemplo Pedro, Sonia.

Herencia: propiedad por lo que es posible construir nuevas clases a partir de clases
ya existentes, ejemplo clase persona para ser vivo
C++, Java y Smalltalk

Unidad 2 programacin funcional

Identificar los elementos de la programacin funcional y aplicarla en la resolucin de
problemas reales. Disear herramientas alternativas y complementarias de programacin.
Primer tema el tipo de dato

Puesto que haskell es un lenguaje funcional puro viene descrito a travs de evaluacin de
expresiones
Evaluacin de expresiones: para producir valores todo valor tiene asociado un tipo ejemplo,
valores de expresiones son los valores atmicos tales como entero 5 o el carcter a o la
funcin \xx+1 y los valores estructurados de la lista [1 2 3] Y por ltimo El par (b,4).
Las expresiones de tipos son trminos sintcticos que denotan tipos
Ejemplos de expresiones de tipo son los tipos atmicos:
Integer(enteros con precisin ilimitada)
Char (caracter)
Interger Integer(funciones que aplican Interger sobre Interger)
[Interger](lista homognea de enteros)
(char, Interger) par formado por un carcter y un entero
Paradigma de la programacin funcional
En un sentido estricto la programacin funcional define un programa como una funcin
matemtica qu convierte unas entradas en una salida sin ningn estado interno y ningn
efecto lateral. La no existencia de un estado interno y la ausencia de efectos laterales es
una caracterstica de la programacin clara viva. Otras caractersticas del paradigma
funcional son las siguientes:

Recursin
Funciones como tipo de datos primitivos
Uso de listas

> promp
EJEMPLO 1

EJEMPLO 2

EJEMPLO 3

EJEMPLO 4

EJEMPLO 5

quote ()
Sirve para imprimir
1)

2)

3)

Lista vaca

cons construye listas

car
cdr

Valores de verdad
List T=verdadero si es lista
Nil=falso si no es lista

Estructura de control (IF)

TEST evala y si es verdadera, si es falsa
THEN evala y si es verdadera
ELSE si es falsa

Funciones
Defun

RECURSIVIDAD

Definir una funcin llamada par recibir un nmero y deber mostrar T si es par
o NIL si no es

Entradas y Salidas

Variables

Iteracin

rboles binarios en Lisp

En lisp, todos los datos en memoria se estructuran de a pares, conocidos
como nodos:
En la notacin antigua de lisp, se escriba con puntos as:
> '(23 . 99)

> (23 . 99)

23 es el elemento de la izquierda y 99 el de la derecha
Para acceder al elemento de la izquierda usamos CAR, y para acceder al
elemento de la derecha usamos CDR.
> (car '(23 . 99))
23
> (cdr '(23 . 99))
99
De esta manera todos los tipos de datos se estructuran a partir de
nodos, solo que actualmente se omite el punto. As las listas son nodos
encadenados:
Del mismo modo las funciones, tienen estructura de lista, solo que estas
se evalan.
Revista Mundo Linux n 85 - Articulo sobre lisp
Arboles binarios
Para crear rboles usamos los nodos. La figura siguiente es un rbol
binario:
Para hacerlo mediante nodos:
Es fcil construirlo en Lisp, (voy a usar la notacion con puntos, pues me
resulta mas cmodo)
Las ramas van separadas por puntos y entre parntesis
> (set 'arbol '(1 . ((2 . nil) . (3 . nil))))
(1 (2) 3)

;;; a la variable arbol le asignamos el arbol binario

Por convencin el elemento de la izquierda del nodo tendr el valor y el
elemento de la derecha apuntar hacia otro nodo, o bien apunta a NIL.
Para acceder a la raz usamos CAR:
> (car arbol)
1

Para acceder al nodo 2, por ejemplo, primero usamos un (CDR arbol),

que nos situa en el nodo que contiene las direcciones de los nodos (2 .
nil) y (3 . nil). Luego un CAR (que lo envuelve) nos lleva al nodo (2 . nil).
Por ltimo un CAR devolver el elemento 2, si usramos CDR aca, nos
devolvera NIL.
> (car (car (cdr arbol)))
2
Dejo al lector como ejercicio, que intente acceder al elemento 3.
Debido a que los valores estn a la izquierda, siempre que queramos
acceder un dato, habr un CAR que envuelva a toda la expresin.
Veamos un rbol con mas hojas:
En Lisp, se ve as:
Se guarda as:
> (set 'arbol '(1 . ((2 . ((4 . nil) . (5 . nil))) . (3 . ((6 . nil) . (7 . nil))))))
(1 (2 (4) 5) 3 (6) 7)
Para recorrer este rbol usamos CAR y CDR, como vimos anteriormente.
Para acceder a 5 sera asi:
> (car (cdr (cdr (car (cdr arbol)))))
5
Dejo al lector que intente acceder a los dems elementos.
Bien de esta manera, podemos crear cualquier tipo de estructura que se
nos ocurra. Las funciones para recorrerlas y agregar elementos no seran
muy complicadas. Nos evitamos el hecho de tener que manejar punteros
y/o variables de tipo puntero.

Arboles de decisin en LISP

>(setq arbol (cielo

(soleado (humedad
(normal si)
(alta no)))
(nublado si)
(lluvia (viento
(fuerte no)
(dbil si)))))
(CIELO (SOLEADO (HUMEDAD (NORMAL SI) (ALTA NO))) (NUBLADO SI)
(VIENTO (FUERTE NO) (DEBIL SI))))
(defun root (tree)
(car tree))
(defun sub-tree (tree attribute-value)
(second (assoc attribute-value (cdr tree))))
Defun leaf (tree)
(atom tree))

>(root arbol)
CIELO
>(sub-tree arbol soleado)
(HUMEDAD (NORMAL SI) (ALTA NO))
>(sub-tree arbol nublado)
SI
>(leaf (sub-tree arbol soleado))
NIL
>(leaf (sub-tree arbol nublado))
T

>(defun print-tree (tree &optional (depth 0))

(mytab depth)
(format t "~A~%" (first tree))
(loop for subtree in (cdr tree) do
(mytab (+ depth 1))
(format t "- ~A" (first subtree))
(if (atom (second subtree))
(format t "-> ~A~%" (second subtree))
(progn (terpri)(print-tree (second subtree) (+ depth 5))))))

>(defun mytab (n)

(loop for i from 1 to n do (format t " ")))

A continuacin se presenta un ejemplo de un sistema experto y de Cmo

puedo llegar a diagnosticar 10 entre un frmaco y en una persona con
presin arterial

>(setq presinarterial (presionarterial

(alta (azucarenlasangre
(alto (alergiaoantibioticos
(si (otrasalergias
(si no)
(no si)))))
(media (indicedecolesterol
(alto no)
(bajo si))
(baja si)))))))

(defun root(tree)
(car tree))
(defun sub-tree(tree attribute-value)
(second (assoc attribute-value (cdr tree))))
(defun leaf (tree)
(atom tree))

(defun print-tree (tree &optional (depth 0))

(mytab depth)
(format t ~A~% (first tree))
(loop for subtree in (cdr tree) do
(mytab (+ depth 1))
(format t - ~A (first subtree))
(if (atom (second subtree))
(format t -> ~A~% (second subtree))
(progn (terpri)(print-tree (second subtree) (+ depth 5))))))
(defun mytab (n)
(loop for i from 1 to n do (format t )))

>(setq arbol (patrons?

(none no)
(some yes)
(full (hungry?
(no no)
(yes (type
(french yes)
(italian no)
(burgen yes)
(thai (fri/sat?
(no no)
(yes yes)))))))))

(defun print-tree (tree &optional (depth 0))

(mytab depth)
(format t ~A~% (first tree))
(loop for subtree in (cdr tree) do
(mytab (+ depth 1))
(format t - ~A (first subtree))
(if (atom (second subtree))
(format t -> ~A~% (second subtree))
(progn (terpri)(print-tree (second subtree) (+ depth 5))))))
(defun mytab (n)
(loop for i from 1 to n do (format t )))

Evaluacin perezosa
3.1 estrategias de la evaluacin perezosa
Una estrategia de evaluacin es un conjunto de reglas para evaluar expresiones es un
lenguaje de programacin.
Una estrategia de evaluacin define cundo y en qu orden los argumentos a una funcin
son evaluados, cuando se sustituyen en la funcin y lo que la sustitucin se forma.
Estrategias de evaluacin
- Para los ejemplos se considera la funcin
Mult :: (Int, Int) Int
mult (x, y) = x * y

- Evaluacin mediante paso de parmetros por valor ( O por ms internos)

mult (1+2, 2+3)

= mult (3, 5)

[por def. de +]

= 3*5

[por def. de mult]

= 15

[por def. de *]

Evaluacin mediante paso de parmetros por nombra por mas externos

mult (1+2, 2+3)

= (1+2)*(2+3) [por def. de mult]
= 3*5

[por def. de +]

Evaluacin con lambda expresiones

Se considera la funcin
Mult :: Int Int Int
Mult x = \y x * y
Evaluacin
Mult (1+2)(2+3)
= mult 3 (2+3)

[por def. de +]

= ( y 3*y) (2+3) [por def. de mult]

= ( y 3*y) 5

[por def. de +]

= 3*5

[por def. de +]

= 15

[por def. de -]

Procesamiento con el infinito

Definicin de Infinito
Int :: Int
Inf = 1 + inf

 Evaluacin de infinito en Haskell:

Main > inf
C-c C-c Interrupted
Evaluacin de Infinito
Int
= 1 + inf
= 1 + (1 + inf )
= 1 + (1 + (1 + inf))

[por def. de inf]

[por def. de inf]
[por def. de inf]

Funcion: masUno x=x+1

La expresin masUno (2*3) puede ser evaluada de la siguiente forma:
masUno (2*3)
Aplicamos
masUno 6
Aplicamos masUno
6+1
Aplicamos +
7
Si tenemos la expresin n+(n:= 1) y n empieza apuntando a 0 si empezamos a evaluar de
izquierda a derecha
n+ (n: =1)
Aplicamos n
0+ (n: =1)
Aplicamos: =
0+ 1
Aplicamos +

1
Si empezamos a evaluar de derecha a izquierda
n+ (n: =1)
Programacin

lgica

tcnicas

de

programacin

funcional
funcional

perezosa

La semntica adoptada para el no determinismo es la leccin en la Innovacin (call-time

Choice), por resultar ms natural para la programacin y eficaz en la ejecucin al
corresponderse
En

el

con

el

no-determinismo

mecanismo
existen

de

varias

comparticin.

tcnicas

como

son

tcnica de backtrain (prolog) si un alternativa falla el flujo de torna hasta la ltima decisin
e

intenta

otra

Tcnica de guardias (guards) si ms de una es cierta se escoje cualquiera de ellas

Tcnica de aprendizaje reforzado (A-Lips) recordar decisiones en el contexto del estado
mutable.
Bsqueda
un

algoritmo

no
no

determinista

determinista

ofrece

muchos

posibles

resultados

emplean modelos de computacin tales como la mquina de turing probabilstica que no

son

determinista.

Pueden simularse utilizando la lista de xito como ejemplo: x=x, x candidatos vlidos
Datos

no

deterministas

Requiere tipos de datos diferentes como son Data list m a= nil (cons (m a) (m (list a))
Puede representar lista perezosa no determinista.
Cons [2] [Nil, cons [1]]:: list { } int.
Los argumentos representan computacin no determinista permute y IsSorted se pueden
adoptar a la lista de tipo permute y genera permutaciones perezosamente los rendimientos
IsSorted [true, false] es aplicada por encima de la lista (s).

Ejercicio1.hs en haskell
doble numero = 2*numero

esPositivo numero = numero > 0

media3 x y z = (x+y+z)/3

pepe = ("pepe",21)
juan = ("juan",17)
maria = ("maria",33)
pedro = ("pedro",12)
sofia = ("sofia",7)
juana = ("juana",65)

personas = [pepe,juan,maria,pedro,sofia,juana]

mayoresDe18 lista = map dameNombre(filter tieneMasDe18 lista)

tieneMasDe18 (nombre,edad) = edad > 18

dameNombre (nombre,edad) = nombre

sumaMonedas a b c d e = 1*a+2*b+5*c+10*d+20*e

volumenEsfera r = (4/3)*pi*r^3

;areaDeCoronaCircular r1 r2 = pi*(r2^2 -r1^2)

ultimaCifra x = rem x 10

xor3 x y = (x || y) && not (x && y)

bincond x y = (x && y) || not (x || y)

medianos (x,y,z) = x + y + z - minimum [x,y,z] - maximum [x y z]

Ejercicio2.hs en haskell
xor3 x y = (x || y) && not (x && y)

xor4 x y = x/= y
rotal xs = tails xs ++ [head xs]
rota n xs = drop n xs ++ take n xs
rango xs = [minium xs, maximun xs]
palindromo xs = xs == reverse xs
interior xs = tail (init xs)
finales n xs = drop (length xs - n) xs
segmento m n xs = drop (m-1) (take n xs)
extremos n xs= take n xs ++ drop (length xs -n) xs
mediano x y z = x + y + z - minimum [x,y,z] - maximum [x,y,z]
esIguales x y z = x == y && y == z

Ejercicio3.hs en haskell
funcionCociente :: Integer-> Integer-> Integer
funcionCociente a b = if (mod a b == 0) then (div a b)
else (mod a b)

Ejercicio4.hs en haskell
rango xs = [minimum xs, maximum xs]

palindromo xs = xs == reverse xs

interior xs = tail (init xs)

finales n xs = drop (length xs - n) xs

segmento m n xs = drop (m-1) (take n xs)

extremos n xs = take n xs ++ drop (length xs - n) xs

mediano x y z = x + y + z- minimum [x,y,z] - maximum [x,y,z]

tresIguales x y z = x == y && y == z

tresDiferentes x y z = x /= y && x /= z && y /= z

cuatroIguales x y z u = x == y && tresIguales y z u

triangular a b c = a < b+c && b < a+c && c < a+b

divisionSegura _ 0 = 9999 divisionSegura x y = x/y

xor1 True True = False xor1 True False = True xor1 False True = True xor1
False False = False

xor2 True y = not y xor2 False y = y

xor3 x y = (x || y) && not (x && y)

xor4 x y = x /= y

modulo (x,y) = sqrt(x^2+y^2)

mayorRectanglo (a,b) (c,d) | a*b >= c*d = (a,b) | otherwise = (c,d)

cuadrante (x,y) | x > 0 && y > 0 = 1 | x < 0 && y > 0 = 2 | x < 0 && y <
0 = 3 | x > 0 && y < 0 = 4

intercambia (x,y) = (y,x)

simetricoH (x,y) = (x,-y)

distancia (x1,y1) (x2,y2) = sqrt((x1-x2)^2+(y1-y2)^2)

puntoMedio (x1,y1) (x2,y2) = ((x1+x2)/2, (y1+y2)/2)

sumaComplejos (a,b) (c,d) = (a+c, b+d)

productoComplejos (a,b) (c,d) = (a*c-b*d, a*d+b*c)

conjugado (a,b) = (a,-b)

intercala [x1,x2] [y1,y2] = [x1,y1,x2,y2]

ciclo [] = [] ciclo xs = last xs : init xs

numeroMayor x y = a*10 + b where a = max x y b = min x y

numeroDeRaices a b c | d < 0 = 0 | d == 0 = 1 | otherwise = 2 where d

= b^2-4*a*c

raices_1 a b c = [(-b+d)/t,(-b-d)/t] where d = sqrt (b^2 - 4*a*c) t = 2*a

raices_2 a b c | d >= 0 = [(-b+e)/(2*a), (-b-e)/(2*a)] | otherwise = error

"No tine raices reales" where d = b^2-4*a*c e = sqrt d

area a b c = sqrt (s*(s-a)*(s-b)*(s-c)) where s = (a+b+c)/2

formaReducida (a,b) = (a `div` c, b `div` c) where c = gcd a b

sumaRacional (a,b) (c,d) = formaReducida (a*d+b*c, b*d)

productoRacional (a,b) (c,d) = formaReducida (a*c, b*d)

igualdadRacional (a,b) (c,d) = formaReducida (a,b) == formaReducida

(c,d)

sumaDeCuadrados :: Integer -> Integer sumaDeCuadrados n = sum

[x^2 | x <- [1..n]]

replica :: Int -> a -> [a] replica n x = [x | _ <- [1..n]]

numeroAbundante :: Int -> Bool numeroAbundante n = n < sum

(divisores n)
divisores :: Int -> [Int] divisores n = [m | m <- [1..n-1], n `mod` m == 0]

numerosAbundantesMenores :: Int -> [Int] numerosAbundantesMenores

n = [x | x <- [1..n], numeroAbundante x

todosPares :: Int -> Bool todosPares n = and [even x | x <numerosAbundantesMenores n]

primerAbundanteImpar :: Int primerAbundanteImpar = head [x | x <[1..], numeroAbundante x, odd x]

euler1 :: Integer -> Integer euler1 n = sum [x | x <- [1..n-1], multiplo x 3

|| multiplo x 5] where multiplo x y = mod x y == 0

circulo :: Int -> Int circulo n = length [(x,y) | x <- [0..n], y <- [0..n],
x^2+y^2 < n^2]

circulo' :: Int -> Int circulo' n = length [(x,y) | x <- [0..m], y <- [0..m],
x^2+y^2 < n^2] where m = raizCuadradaEntera n

raizCuadradaEntera :: Int -> Int raizCuadradaEntera n = truncate (sqrt

(fromIntegral n))

aproxE n = [(1+1/m)**m | m <- [1..n]

errorAproxE x = head [m | m <- [1..], abs((exp 1) - (1+1/m)**m) < x]

aproxE' n = 1 + sum [ 1 / factorial k | k <- [1..n]]

factorial n = product [1..n]

e = 2.71828459

errorE' x = head [n | n <- [0..], abs(aproxE' n - e) < x]

aproxLimSeno n = [sin(1/m)/(1/m) | m <- [1..n]]

errorLimSeno x = head [m | m <- [1..], abs(1 - sin(1/m)/(1/m)) < x]

calculaPi n = 4 * sum [(-1)**x/(2*x+1) | x <- [0..n]]

errorPi x = head [n | n <- [1..], abs (pi - (calculaPi n)) < x]

pitagoricas :: Int -> [(Int,Int,Int)] pitagoricas n = [(x,y,z) | x <- [1..n], y <[1..n], z <- [1..n], x^2 + y^2 == z^2]

numeroDePares :: (Int,Int,Int) -> Int numeroDePares (x,y,z) = sum [1 | n

<- [x,y,z], even n]

conjetura :: Int -> Bool conjetura n = and [odd (numeroDePares t) | t <pitagoricas n]

Ejercicios en clase de Prolog

esHombre(juan).
esHombre(pedro).
quiere(juan,maria).

quiere(juan,elena).
quiere(pedro,raquel).
quiere(pedro,belen).

quiere(x,maria).
quiere(_,maria).
quiere(maria,_).
quiere(juan,x),gusta(maria,y).
quiere(juan,x),gusta(maria,x).

padre(alberto,ana).
padre(alberto,juan).
padre(alberto,maria).
padre(alberto,carlos).
padre(ana,luis).
padre(ana,pedro).
padre(maria,juana).
padre(maria,elena).
padre(carlos,dalia).
padre(pedro,luz).
padre(pedro,peter).
padre(juana,rene).
hijo(X,Y):-padre(Y,X).
abuelo(X,Z):-padre(X,Y), padre(Y,Z).
nieto(X,Z):-abuelo(Z,X).
bisabuelo(X,W):-abuelo(X,Z),padre(Z,W).
bisnieto(W,X):-bisabuelo(X,W).
hermano(Y,Z):-padre(X,Y),padre(X,Z).

primo(X,Z):-hermano(Y,Z).

/* animal(anim)<-Anim es un animal */
animal(mono).
animal(gallina).
animal(araa).
animal(mosca).
animal(cocodrilo).
/*gusta(X,Y)<-a X le gustanY */
gusta(mono,banana).
gusta(araa,mosca).
gusta(alumno,parranda).
gusta(betty,angy).
gusta(cocodrilo,X):-animal(X).
gusta(mosca,espejo).
/*regalo(X,Y)<-a Y es un buen regalo para para X */
regalo(X,Y):-animal(X),gusta(X,Y).

pais(usa).
pais(canada).
pais(mexico).
pais(usa,washington).
pais(canada,ottawa).
pais(mexico,cdmx).

compra(X,Y):-sevende(Y),gusta(X,Y),bueno(Y).
sevende(vestido).
sevende(sombrero).

sevende(zapatos).
gusta(jaime,zapatos).
gusta(maria,vestido).
gusta(maria,sombrero).
bueno(sombrero).

nacimiento(pedro,fecha(12,ago,1970)).

/*:- IMPLICACION O CONDICIONAL

(,) AND conjucin
(;) OR disyuncin
(not) Negacion*/

compra2(X,Y):-gusta(X,Y);bueno(Y).
sevende(vestido).
sevende(sombrero).
sevende(zapatos).
gusta(jaime,zapatos).
gusta(maria,vestido).
gusta(maria,sombrero).
bueno(sombrero).
bueno(short).

/* Entradas y salidas
Para salidas se usa el comando Write para desplegar un texto o una
variable.

? write('Hola...').

saludos:-nl,tab(4),write('hola Angie'),nl,tab(20),write(X).
?saludo.

se usa el comando read para capturar desde el teclado.

name:-write('Anote su nombre:
'),read(Nombre),nl,write('Hola'),write(Nombre).
?name.
anote su nombre:Angie.
Hola Angie
*/
saludos:-nl,tab(4),write('hola Angie'),nl,tab(20),write(X).
name:-write('Anote su nombre:
'),read(Nombre),nl,write('Hola'),write(Nombre).

materiales(1,cemento,50).
materiales(2,arena,20).
materiales(3,cal,10).

equipo(1,revolvedora,1500).
equipo(2,taladro,800).

trabajo(A,B,C,D).:-materiales(X,A,B), equipo(Y,C,D):-(X==Y).
producto(X,C,X1,C1):-materiales(X,C), equipo (X1,C1).
proyectaN(Descripcion):-materiales(Descripcion,_).
seleccionar(Descripcion,Cantidad):-materiales(Descripcion,Cantidad),
Cantidad>15.

producto(X,C,X1,C1):-materiales(X,C), equipo(X1,C1).
union(X,Y):-materiales(X,Y);equipo(X,Y).

diferencia(X,Y):-union(X,Y), \+(materiales(X,Y)).

hombreymujer(X,Y):-eshombre(X);esmujer(Y).
padre(luis,pablo).
padre(luis,rosa).
madre(adela,pablo).
madre(adela,rosa).
madre(dolores,javier).
padre(pablo,javier).
madre(rosa,irene).
madre(rosa,miguel).
padre(felipe,miguel).
padre(felipe,irene).
padre(miguel,salvador).
padre(javier,david).
padre(javier,claudia).
madre(silvia,claudia).
madre(silvia,david).
eshombre(luis).
eshombre(pablo).
eshombre(felipe).
eshombre(javier).
eshombre(miguel).
eshombre(david).
eshombre(salvador).

esmujer(adela).
esmujer(dolores).
esmujer(rosa).
esmujer(silvia).
esmujer(irene).
esmujer(claudia).
hijo(X,Y):-padre(Y,X).
abuelo(X,Z):-padre(X,Y), padre(Y,Z).
abuela(X,Z):-padre(X,Y), padre(Y,Z).
nieto(X,Z):-abuelo(Z,X).
nieta(X,Z):-abuelo(Z,X).
bisabuelo(X,W):-abuelo(X,Z),padre(Z,W).
bisabuela(X,W):-abuelo(X,Z),padre(Z,W).
bisnieto(W,X):-bisabuelo(X,W).
bisnieta(W,X):-bisabuelo(X,W).
hermano(Y,Z):-padre(X,Y),padre(X,Z).
hermana(Y,Z):-padre(X,Y),padre(X,Z).
primo(X,Z):-hermano(Y,Z).
prima(X,Z):-hermano(Y,Z).
tio(X,Y):-hermano(Y,Z).
tia(X,Y):-hermano(Y,Z).

miembro(X,[X|_]). miembro(X,[_|Y]) :- miembro(X,Y).

nel([],0). nel([X|Y],N) :- nel(Y,M),

N is M+1.

es_lista([]). es_lista([_|_]).
concatena([],L,L). concatena([X|L1],L2,[X|L3]) :- concatena(L1,L2,L3).
ultimo(X,[X]). ultimo(X,[_|Y]) :- ultimo(X,Y).

inversa([],[]). inversa([X|Y],L) :- inversa(Y,Z),

concatena(Z,[X],L).

borrar(X,[X|Y],Y). borrar(X,[Z|L],[Z|M]) :- borrar(X,L,M).

subconjunto([X|Y],Z) :- miembro(X,Z),
subconjunto([],Y).

subconjunto(Y,Z).

insertar(E,L,[E|L]). insertar(E,[X|Y],[X|Z]) :- insertar(E,Y,Z).

permutacion([],[]). permutacin([X|Y],Z) :- permutacion(Y,L),
insertar(X,L,Z).