Ejercicio 1

Definir un predicado sus(X,Y,L1,L2) que sea capaz de sustituir un elemento X por otro Y en la lista L1, para dar L2.

Solución

1
2
3
4

%Ejercicio 2
sus(_,_,[],[]).
sus(X,Y,[HT],[YRes]):-X=H,sus(X,Y,T,Res).
sus(X,Y,[HT],[HRes]):-X\=H,sus(X,Y,T,Res).

Ejercicio 2

Definir la relación aplanar(Lista, Aplanada), donde Lista es en general una lista de listas, tan compleja en su anidamiento como queramos imaginar, y Aplanada es la lista que resulta de reorganizar los elementos contenidos en las listas anidadas en un único nivel, i.e. una lista plana. Por ejemplo:

1
2

?- aplanar([[a, b], [c, [d, e]], f], L).
L = [a, b, c, d, e, f]

Solución

1
2
3
4

%Ejercicio 3
aplanar([],[]).
aplanar([XR],[XP]):- atomic(X),aplanar(R,P).
aplanar([XR],P):-  not(atomic(X)),aplanar(X,P_X),aplanar(R,P_R),append(P_X,P_R,P).

Ejercicio 3

Definir un predicado igualesElem(L1,L2) que compruebe que L1 y L2 son listas que
contienen los mismos elementos independientemente del orden de aparición.

Solución

1
2
3
4
5

%Ejercicio 4 
igualesElem([],[]).
igualesElem([H1T1],[H2T2]):- length([H1T1],N),length([H2T2],N),((H1==H2,igualesElem(T1,T2))
                                (algun(H1,[H2T2]),delete([H1T1],H1,AUX1),delete([H2T2],H1,AUX2),igualesElem(AUX1,AUX2))).
algun(X,[HT]):-(X==H)algun(X,T).

Ejercicio 4

Definir un predicado descomponer(N,A,B) que permita resolver el problema de descomponer un número natural N en la suma de dos pares A y B. Esto es, descomponer(N,A,B) debe tomar como entrada un natural N y devolver dos naturales A y B tales que N = A + B.

Solución

1
2
3
4

descomponer(N,A,B):-
    between(0,N,A), A mod 2=:=0, 
    between(0,N,B), B mod 2=:=0,
    A+B=:=N.

Ejercicio 5

Rompecabezas de Brandreth. El cuadrado de 45 es 2025. Notad que si partimos el número
en dos obtenemos los números 20 y 25 cuya suma es, precisamente, 45. Obtener que otros números cuyo cuadrado es un número de cuatro cifras cumplen esta propiedad. Con este fin, definir un predicado numBrandreth (N, C) que devuelva uno de estos números N y su cuadrado C.

Solución

1

numBrandreth(N,C):-between(32,99,N), C is N*N, A is C mod 100, B is C//100, A+B=:=N.

Pues bien, en muchas ocasiones la principal dificultad es encontrar la herramienta idónea para llevar a cabo estos diagramas. Existen muchas aplicaciones libres que permiten dibujar diagramas de todo tipo (una de las más destacables es DIA), pero yo os voy a presentar una herramienta muy diferente: SDEdit. Esta aplicación está diseñada para realizar diagramas de secuencia únicamente, pero de forma totalmente automática. El usuario simplemente debe especificar formalmente el diagrama de secuencia en forma de texto, y el programa automáticamente realiza el diagrama gráficamente. Los resultados son muy buenos, como podéis ver en la siguiente imagen:

Para que os hagáis una idea de cómo es el código que maneja SDEdit, a continuación podéis ver el código empleado para generar el diagrama anterior:

#![Modificar cuenta (escenario normal)]
visitante:Actor
w:Ventana de modificación
i:Gestor de usuarios
p:Persistencia
visitante:w.cambiar datos
visitante:w.pulsar botón de guardar
w:i.datos modificados
i:p.datos modificados
p:i.cambios exitosos
i:w.cambios exitosos
w:visitante.cambios realizados

Como podéis ver, no es nada complicado y el resultado es bastante bueno. Espero que os sea útil.

María del Carmen Ramírez me envió este pequeño tutorial para hacer las tablas en OpenOffice Calc y exportarlas después a LaTeX, facilitando mucho la tarea:

• En primer lugar debemos descargar e instalar la macro calc2latex para OpenOffice, que será la encargada de generar el código LaTeX. Para ello:
  • Descargamos la macro (en formato ZIP) desde la web del proyecto.
  • Abrimos Calc, el procesador de hojas de cálculo de OpenOffice, y vamos al menú Herramientas > Administrador de extensiones. Allí añadimos el ZIP que hemos descargado, mediante el botón Añadir, y seguidamente cerramos la ventana.
  • Desde este momento, la macro que hemos descargado ya está a nuestra disposición.
• Ahora ya podemos utilizar la macro. Para comprobar cómo funciona, vamos a crear una tabla de ejemplo en OpenOffice Calc.
• Una vez tengamos la tabla lista, vamos a Herramientas > Macros > Ejecutar macro, y en la sección Mis macros desplegamos Calc2LaTeX y seleccionamos la macro del mismo nombre. En el cuadro de la derecha se mostrarán las funciones disponibles. Debemos seleccionar la función Main únicamente y hacer clic sobre Ejecutar.
• Se desplegará una ventana en la que podremos personalizar algunos parámetros de la generación de código. Si no deseamos hacer ningún cambio basta con que hagamos clic sobre Convert y obtendremos el código LaTeX listo para copiar y pegar en el editor LaTeX que utilicemos.

Ya sólo nos queda probarlo. Debemos saber que el código obtenido con la macro no proporciona la tabla totalmente igual que la escribimos, es decir, es posible que nos mantenga elementos como palabras escritas en negrita o las alineaciones de los datos dentro de las celdas, pero si hemos modificado por ejemplo el color de algún dato, eso no nos lo mantiene.

Os dejo un .tex de ejemplo, así tendréis la posibilidad de ver el código y observar cómo desde una tabla escrita en OpenOffice consigo un resultado más aproximado a lo que realmente busco.

• Código LaTeX
• Documento anterior compilado a PDF

Espero que os sea de utilidad. Muchas gracias a María del Carmen por la info.

Enlace: aquí.

Pues bien, sin más preámbulos, aquí tenéis los ejercicios:

Enunciado

El siguiente programa Prolog especifica una base de datos deductiva sobre relaciones familiares. Completar el código dado, respondiendo a los diferentes apartados, mediante la lectura de estos fragmentos del Génesis.

“He aquí la descendencia de Teraj: Teraj engendró a Abram (posteriormente llamado `Abraham’, que significa `Padre de multitud’), Najor, y Harán. Harán engendró a Lot … La mujer de Abram se llamaba Sarai (o Sara) y la de Najor Melca, hija de Harán, padre de Melca y de Jesca.”

“Sarai, la mujer de Abram, no le había dado hijos, pero ella tenía una esclava egipcia de nombre Agar. … tomó a Agar y se la dio por mujer a Abram, … Agar parió un hijo a Abram y a este hijo tenido de Agar, Abram le llamó Ismael.”

Estando en la tierra de Guerar, Abram confeso que: ” es verdad que ella (Sarai) también es mi hermana, hija de mi padre pero no de mi madre, y ahora es mi mujer.”

“Sara, pues, concibió y parió un hijo en su vejez, en el tiempo predicho por Dios. Y Abraham llamó al hijo que le nació Isaac (que significa `el que ríe’).” Isaac casó con Rebeca, “hija de Batuel, el que Melca parió a Najor” y hermana de Labán. Isaac y Rebeca tuvieron dos hijos, Esaú y Jacob, pero ésta es otra historia.

El código dado por el ejercicio es:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

%%% HECHOS
 
padre(abraham,isaac).
padre(haran,lot).
padre(haran,melca).
padre(haran,jesca).
hombre(isaac).
hombre(lot).
mujer(melca).
mujer(jesca).
 
%%% REGLAS
 
ascendiente_directo(X, Y) :- (padre(X, Y) madre(X, Y)).
ascendiente(X, Z) :- ascendiente_directo(X, Z).
ascendiente(X, Z) :- ascendiente_directo(X, Y), ascendiente(Y, Z).
hijo(X,Y) :- hombre(X), ascendiente_directo(Y,X).
hija(X,Y) :- mujer(X), ascendiente_directo(Y,X).

Se pide responder a los siguientes apartados:

• Completar la base de datos con los hechos extraídos del fragmento del génesis anterior.
• Definir las relaciones: ascendente, descendente, abuelo, hermano, tío, sobrino y primo.
• Definir un predicado que nos informe de las relaciones que hoy consideramos incestuosas.

Solución

La solución que propongo es la siguiente (ya todo el código junto):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

				%HECHOS
%hombre
hombre(abraham).
hombre(isaac).
hombre(lot).
hombre(najor).
hombre(ismael).
hombre(haran).
hombre(teraj).
hombre(batuel).
hombre(laban).
hombre(esau).
hombre(jacob).
 
%mujer
mujer(rebeca).
mujer(melca).
mujer(jesca).
mujer(sara).
mujer(agar).
 
%esclava
esclava(agar).
 
%padre
padre(abraham, isaac).
padre(abraham, ismael).
padre(haran, lot).
padre(haran, melca).
padre(haran, jesca).
padre(teraj, abraham).
padre(teraj, sara).
padre(teraj, najor).
padre(teraj, haran).
padre(batuel, rebeca).
padre(batuel, laban).
padre(najor, batuel).
padre(isaac, esau).
padre(isaac, jacob).
 
%madre
madre(agar, ismael).
madre(sara, isaac).
madre(rebeca, esau).
madre(rebeca, jacob).
madre(melca, batuel).
 
%casados 
casado(abraham, sara).
casado(isaac, rebeca).
casado(najor, melca).
 
 
				%REGLAS
%hijo
hijo(X, Y) :- padre(Y, X), hombre(X).
hija(X, Y) :- padre(Y, X), mujer(X).
 
%casados
casados(X, Y) :- casado(X, Y) casado(Y, X).
 
%ascendiente_directo
ascendiente_directo(X, Y) :- padre(X, Y) madre(X, Y).
 
%abuelo
abuelo(X, Y) :- padre(X, Z), ascendiente_directo(Z, Y).
 
%abuela
abuela(X, Y) :- madre(X, Z), ascendiente_directo(Z, Y).
 
%nieto
nieto(X, Y) :- (abuelo(Y, X) abuela(Y, X)), hombre(X).
 
%nieta
nieta(X, Y) :- (abuelo(Y, X) abuela(Y, X)), mujer(X).
 
%ascendiente
ascendiente(X, Y) :- ascendiente_directo(X, Y).
ascendiente(X, Y) :- abuelo(X, Y) abuela(X, Y).
 
%hermano
hermano(X, Y) :- hombre(X), (ascendiente_directo(Z, X), ascendiente_directo(Z, Y)), X\=Y.
 
%hermana
hermana(X, Y) :- mujer(X), (ascendiente_directo(Z, X), ascendiente_directo(Z, Y)), X\=Y.
 
%hermanos
hermanos(X, Y) :- hermano(X, Y) hermana(X, Y) hermano(Y, X) hermana(Y, X).
 
%descendiente_directo
descendiente_directo(X, Y) :- ascendiente_directo(Y, X).
 
%descendiente
descendiente(X, Y) :- descendiente_directo(Y, X).
descendiente(X, Y) :- nieto(X, Y) nieta(X, Y).
 
%tio_carnal
tio_carnal(X, Y) :- hermanos(X, Z), ascendiente_directo(Z, Y), hombre(X).
tia_carnal(X, Y) :- hermanos(X, Z), ascendiente_directo(Z, Y), mujer(X).
 
%tio_no_carnal
tio_no_carnal(X, Y) :- casados(X, Z), tia_carnal(Z, Y).
tia_no_carnal(X, Y) :- casados(X, Z), tio_carnal(Z, Y).
 
%tio
tio(X, Y) :- tio_carnal(X, Y) tio_no_carnal(X, Y), not(padre(X,Y)), X\==Y.
 
%tia
tia(X, Y) :- tia_carnal(X, Y) tia_no_carnal(X, Y), not(madre(X,Y)), X\==Y.
 
%sobrino
sobrino(X, Y) :- hombre(X), (tio(Y, X) tia(Y, X)).
 
%sobrina
sobrina(X, Y) :- mujer(X), (tio(Y, X) tia(Y, X)).
 
%primo
primo(X, Y) :- hombre(X), (tio(Z, X) tia(Z, X)), ascendiente_directo(Z, Y),X\==Y.
 
%prima
prima(X, Y) :- mujer(X), (tio(Z, X) tia(Z, X)), ascendiente_directo(Z, Y),X\==Y.
 
%primos
primos(X, Y) :- primo(X, Y) primo(Y, X) prima(X, Y) prima(Y, X).
 
%incestuosos
incestuosos(X, Y) :- casados(X, Y), hombre(X), mujer(Y),(hermanos(X, Y) primos(X, Y) ascendiente_directo(X, Y) descendiente_directo(X, Y) abuelo(X, Y) nieto(X, Y) abuela(X, Y) nieta(X, Y) tio(X, Y) tia(X, Y) sobrino(X, Y) sobrina(X, Y)).

Espero que os sirva. Y si quereis aprender Programación Declarativa y Prolog, os recomiendo el libro “Programación lógica. Teoría y Práctica”, de Pascual Julián Iranzo y María Alpuente Frasnedo, que está muy bien escrito y completamente en español.

Bueno, aquí os dejo unas prácticas resueltas de Simulación. No implica que este todo bien, es más se hicieron de una forma muy muy rápida, así que seguro que contiene algunos errores, pero viene muy bien como ayuda para empezar.

Viendo el código en Matlab me da vergüenza como está programado (no intentéis programar en Matlab como lo hacéis en Java o C, porque entonces estaréis perdiendo mucho potencial). Creo que toda la parte que implica sólo la programación en Matlab es compatible con Octave (sólo habrá que cambiar en ciertos lugares un poco de la sintaxis), pero para la parte de Simulink es imprescindible Matlab.

Espero que podáis utilizarlo, lo mejoréis y nos lo enviéis para que podamos volver a colgarlo para los siguientes que lo necesiten.

Si tienes otros apuntes, prácticas, o lo que sea y quieres compartirlo dinoslo y lo publicamos.

PD: Hay algunos datos “sospechosos” a quién los encuentre, le doy un premio.

Mario AI Competition es un concurso de desarrolladores de IA (inteligencia artificial) para juegos donde la finalidad es generar un Mario inteligente capaz de sortear a sus enemigos, en la cual, en su edición del concurso (2008-09), el algoritmo A* (a estrella) de Robin Baumgarten ganó la convocatoria.

Se trata de calcular sobre el modelo de Mario en Java un agente o entidad inteligente capaz de hacer que Mario llegue lo más rápido y lejos posible.

Pd: las lineas rojas que vemos son las estimaciones de posición futura.

Si quereis probar, teneis que instalar el programa en cuestión (se llama PI):

sudo apt-get install pi

Después bastará con ejecutarlo indicándole el número de decimales que queremos que calcule:

pi 5000

calcularía los 5000 primeros decimales.

Podeis utilizar esto también como un benchmark entre amigos, si lo combinais con el comando time:

time pi 50000 > /dev/null

Espero que os entretenga un rato.

Beneficiados:

• Apple: no cabe duda de que cualquier pequeño golpe que sufra Android puede suponer una alegría para la empresa de la manzana, que ve cómo el sistema operativo de Google se está convirtiendo cada vez en un rival más fuerte para su iPhone.
• Microsoft: con la salida de Windows Phone 7, Microsoft intenta reparar muchos errores que cometió con Windows Mobile. Windows Phone 7 sale al mercado en una época dura, en la que el iPhone –con su enorme éxito–, Android –con su apabullante crecimiento– y Blackberry –con su gran importancia en empresas– reinan en un mundo donde el resto de alternativas no proyectan la suficiente sombra.
• Intel y Nokia: ambas empresas unieron sus fuerzas no hace mucho para conseguir hacer llegar MeeGoo –un nuevo sistema operativo móvil basado en Linux– a una buena posición. Es evidente que cualquier dificultad para Android, el gran sistema operativo móvil Linux, pueda ser buena para MeeGoo.
• El software privativo y los abogados de patentes: patentar software es algo con lo que mucha gente no está de acuerdo, pero las patentes sirven para estas cosas: sacarle pasta al adversario.

Perjudicados:

• Usuarios y desarrolladores de software libre: cualquier golpe a un proyecto “abierto” tan grande como Android, es un duro golpe contra la gran comunidad del software libre. Aunque Google amortigua la “hostia” y veo difícil que usuarios y desarrolladores notemos algo.
• Oracle: sí, señores, creo que Oracle sale más perjudicada de lo que cree. No digo que económicamente sienta en algún momento el gran error que está cometiendo –no sólo con esta demanda, sino con las puñaladas que está asestando al software libre–, pero la mala publicidad que está consiguiendo entre blogs y foros no es buena para ninguna empresa. Están tirando por la borda muchos de importantes pilares que Sun consiguió erguir.