Hola Alguien tiene el ultimo final de paradigma que se tomo en la fecha del Final de paradigma 22/02/2020

(23-02-2020 19:15)okks escribió:  Hola Alguien tiene el ultimo final de paradigma que se tomo en la fecha del Final de paradigma 22/02/2020

Alguna resolución para comparar?

Hola! paso lo que hice para comparar.
Parte A)
% precio(casa(ambientes, pisos), barrio, precio).
% precio(dpto(ambientes, piso, totalUnidades), barrio, precio).
% precio(ph(ambientes, pisos, totalUnidades), barrio, precio).

precio(casa(4, 3), Flores, 1400000).
precio(dpto(4, 6, 28), Palermo, 1800000).
precio(ph(4, 2, 4), Flores, 1200000).

todosAltosConPrecioEn(Precio, Barrio):- precio(casa(_, Pisos), Barrio, Precio1),
Precio1 >= Precio, Pisos > 3,
precio(dpto(_, Piso, _), Barrio, Precio2), Precio2 >= Precio, Piso > 5,
precio(ph(_, Pisosph, _), Barrio, Precio3),
Precio3 >= Precio, Pisosph > 2.


1) Falso no es correcta, no funciona
- el hecho precio de la base de conocimiento, el segundo argumento barrio esta como una variable existencial y no individual (debería ser un individuo).
- Precio esta sin lingar en ningúno los predicados, y una vez que liga no cambia su valor. No esta suficientemente instanciada.

2) falso, no aplica el concepto de polimorfimos, no crea predicados que reciban como parámetro a los los dintos tipos (casa, departamento,ph) y que los trate indistintamente.
3) Falso como esta planteado el predicado no es totalmente inversible, el predicado precio no es inversible para su segundo argumento, y la variable precio una vez que se liga no cambia de valor.
4) precio(casa(4, 3), flores, 1400000).
precio(dpto(4, 6, 28), palermo, 1800000).
precio(ph(4, 2, 4), flores, 1200000).

todosAltosConPrecioEn(Precio, Barrio):- precio(_, Barrio, Precio),
forall(precio(Propiedad, Barrio, Precio1),(altaPropiedad(Propiedad), Precio =< Precio1)).


altaPropiedad(casa(_, Pisos)):- Pisos > 3.
altaPropiedad(dpto(_, Piso, _)) :- Piso > 5.
altaPropiedad(ph(_, Pisosph, _)) :- Pisosph > 2.


Parte B)
edad :: Persona -> Float

f1 _ [] = False
f1 numero (x:xs) = 2 * x < numero || f1 numero xs

f2 e lista = length (filter (\x -> edad x < e) lista) >= 1

f3 tope palabras = any ((< tope).length) palabras

1)
F1: es una función recursiva que recibe un elemento y una lista , y comparara si el numero que recibe como argumento es mayor a 2 multiplicado por la cabeza de la lista y retorna un booleando.
F2: la función f2 recibe un valor y una lista y devuelve true, si la longitud de la lista filtrada , lo cual se filtra con la función filter la edad de la lista menores al valor que le paso como argumento a la función f2 , lo cual todo eso me devuelve un valor que se compara con >= 1.
F3: la función f3 recibe un valor y palabra, y lo que hace la función es preguntar si alguno que cumpla con la condición de ( menor al valor que recibe la función f3 comparado con la longitud de las palabras )
2)
F1 y F2:
F1: se usa el concepto de recursividad, cuenta con su caso base y una funcion que se llama asi misma
F2: usa el concepto de orden superior, filter es una función de orden superior tiene como argumento una función y utiliza la expresión landa que me permite armar a la función q se le paso como argumento
F1 en menos declarativa que F2, F2 se concentra mas en que me devuelve q en el como, f1 es menos expresiva que f2, que es algo subjetivo según el programador cuan rápido entiene mejor el código.
3) F2 y F3 :
F3: usa el concepto de composición y aplicación parcial,
Composición compone funciones (<tope.length)
Aplicación parcial : que se le pasa menos parámetros que el que espera recibier (<tope)

En f2 lo que se podría hacer es composición que es un concepto que no se aprovecha y lo usa F3.
F3 es mas declarativa tiene menos detalle algorítmico q F2.
4) el concepto de evalucion diferidad trabaja con lista infinitas, me permite ir trabajando con los argumentos a medida que me lo pida.
No hay evalucion diferida que aguante para la función f2 y f3 calcula la longitud de la lista infinita, lo cual se queda calculando y nunca termina.
Y la f1 si termina de evaluarse.

f funcion valor lista = ((<valor).funcion ) lista

f1 funcion valor lista = ((<valor).funcion ) lista || f1 numero xs
f2 funcion valor lista = ((>=).length.filter((<valor).funcion)) lista
f3 funcion valor lista = any ((<valor).funcion ) lista

Parte C)

1) Falso . se debira preguntar si tiene stock, y no tiene que arroje una excepción que diga que no tiene Stock
b) Falso. No hay buen uso de polimorfimos, por que pregunto para cada tipo de helado si es 1 o 2, lo hace para que se tome una decisión desde afuera.
c) Verdadero, Heladeria debería delegar las responsabilidades para cada tipo de helado, y que cada uno haga lo que debería hacer.
d) Verdadero, conoce lógica que no necesita saber recargoCobertura, es atributo del cucurucho y la heladeria no debería porque conocer su interfaz de la clase Cucurucho

2)


Class Heladeria {
Var facturado
Var Stock
Method vender(prod){
If (Stok > 0) {
facturado += prod.costo()
self. disminuirStock()
} else {
Self.error (“no hay stock”)
}
Method disminuirStock() = disminuirStock() – prod.Stock()
}

Class Cucurucho {
Var recargoCobertura
Method costo() {
Return 50 + recargoCobertura
Method stock{
Return 0.2
}
}
Class kgHelado {
Method costo(){
Return 200
}
Method stock{
Return 0.2
}
}

---

(28-02-2020 19:23)fakukpg escribió:  Alguna resolución para comparar?

agregue abajo lo que hice, cualquier cosa decime si hiciste algo diferente.