(08-12-2014 14:43)facundoaita escribió:  5) a.
f h m p z | h `elem` z = (head.filter (m h)) z
| otherwise = fst p

f es una funcion claro;
z es una lista, por ser el segundo parámetro de la funciones elem y filter;
h es del mismo tipo que los elementos de z, así puedo hacer el elem, ej: elem 'a' "hola", elem 1 [1,2,3,4];
* ademas h debe ser igualable, ya que elem se fija si los elementos de una lista son iguales al primer parámetro;
p es una tupla de 2 componentes por poder hacerle fst;
m es una funcion a la que pasada como parámetro h, queda aplicada parcialmente, ej: filter (==3) [2,3,4], filter (=='a') "hola" en ambos casos m es (==)

Si h se encuentra en z = la funcion devuelve el primer elemento de z que cumpla con (m h), osea que devuelve un elemento del tipo de los elementos de la lista z.
En cualquier otro caso = devuelve el primer elemento de la tupla p.

El tipo de dato que devuelve f siempre debe ser el mismo, osea que "el primer elemento de la tupla p" es del mismo tipo que "los elementos de la lista z"

Por tanto:
f:: Eq a => a -> ( a -> a -> Bool ) -> ( a , b ) -> [a] -> a

Te hago una pregunta como dedujiste el tipo de h? El ejercicio dice h `elem` z y vos lo trataste como elem h z, se debe a las comillas simples? Saludos.

PD: Se puede usar la guiá de lenguajes en el final ?

Se puede usar la guía de lenguajes.

elem 1 [1,2] = 1 `elem` [1,2]
div 1 2 = 1 `div` 2
mod 1 2 = ...
y asi con varios mas,
son una forma mas parecida al castellano de usar las funciones.

Son los acentos al revez, la verdad que no tengo idea para que se usan en el lenguaje castellano.
Pero en el parcial son comillas simples.

Hola, estoy practicando para mañana sabado, te paso como lo hice yo:

3) lo pensé igual que vos,

4) No tengo mucha idea, pero lo que veo es que la función de la derecha no es inversible (le falta un generador), la de la izquierda es inversible pero para el segundo parámetro.
La primera es menos declarativa y menos expresiva que la segunda.
No se si falta algo mas

5 c) no estoy del todo de acuerdo, porque la funcion m puede hacer una evaluación que para cualquier numero definido de la lista infinita sea falso, con lo cual entra en bucle infinito, con lo cual se podría usar para listas infinitas siempre y cuando la función m no sea false para toda la lista infinita.

Ejemplo que tira bucle infinito (y me colgó el programa):

f 4 (\x y -> x<4 || y <4) (53,54) [5..]

Si pones el ejemplo de arriba se te cuelga.

Saludos.

(08-12-2014 14:43)Droven escribió:  Me podrías ayudar a revisar mi resolución, la hice sin ver la tuya, creo que tarde 2 horas. Cuanto tiempo estan dando para rendir?2:30hs?

--------------------------------------------------------------------------------------------------------------------------------------------------

final 6/12/14

1) En la solucion actual se deberia modificar el valor de la entrada normal, se debería
modificar la clase Entrada, y ademas sería necesario modificar las subclases "entradaConmitarjeta"
y "entradamiercoles", ya que estas ya tiene el valor con el descuento, y no lo calcula.

Una solucion posible sería hacer que cada Subclase le pregunta a la clase "Entrada por el valor de la entrada"
normal, y que estas subclase realicen el calculo, de esa manera si cambia el valor
de la entrada solo seria necesario modificar el clase "Entrada" y nos sus subclases.

ejemplo:

#Entrada
>>precio

^110.

#EntradaConMiTarjeta

>>precio

^ super precio - 25

{aqui la pregunta a su superclase el valor de la entrada normal}

#EntradaMiercoles

>>precio

^ super precio*0.5

2)

a) Estas nuevas subclases calculan su precio usando el metodo "precio3D", y en la implementacion
de la clase "Pelicula" el metodo "recaudacion" recorren la coleccion preguntando "precio",
lo cual estas subclases van a devolver el valor del metodo "precio" y no el correcto
que debería ser "precio3D", por lo cual el metodo "recaudacion" estaría calculando
mal la recaudacion de las entradas vendidas.
La ausencia de poliformismo enlas subclases, generan este inconveniente, la clase
"pelicula" deber tratar a cada entrada como si fueron todas iguales.

b)
La logica repetida se puede apreciar en cada metodo "precio3D", en cada instante
consulta el metodo "precio", cuando podía consulta direcmaente a la superclase, tambien
se repite el codigo con las otras clases "EntradaConmiTarjeta" y "EntradaMiercoles"
todas realizar el descuentor por si solas, cuandor podrian todas estas subclases
pregunta a una sola clase el descuento.

c)

Cree una clase llamada "Descuento" con sus respectivas subclases " DescuentoMitarjeta"
y "DescuentoMiercoles", estas se van a encargar de calcular los decuentos, ademas
si necesito agregar algun descuento, solo seria necesario modificar la clase
descuento, y todos las demas clases no serían afectadas, tampoco se enterarian.

#Entrada (Vi precio, midescuento)

>>precio

^ miescuento descuento:precio.

#Entrada3D (Vi valor3D, midescuento)

>>precio
^ valor3D + midescuento descuento:super precio.

#DescuentoCero
>>descuento:UnPrecio
^Unprecio

#DescuentoMiercoles
>>descuento:unPrecio
^unPrecio*0.5

#DescuetoMitarjeta
>>descuento:unPrecio
^unPrecio + 25

{aca se puede ver que agregando cualquier otro descuento, como subclase}

Diagrama de Clases {no lo dibujar, pero es puede armar en base a la relaciones y clases}


[PELICULA] ------*-> [ENTRADA] <--Subclase-- [[Entrada3d]]

{Esta clase se relaciona con ENTRADA}
[DESCUENTO]<--3subclases-- [[DescuentoMitarjeta]]
[[DescuentoCero]]
[[DecuentoMiercoles]]


d)Funcional solo acepta listas del mismo tipo, en cambio en objetos las colecciones
no necesitan ser del mismo tipo.
Si la lista de entradas es de diferentes tipo, no se podra implemntar dicha solucion
en FUNCIONAL (haskell), fuera esa detalla, la ventaja que podemos notar entre funcioal
y objtos, en los que respecta listas y colecciones,es que es haskell las listas puende
ser infinitas (gracias a evaluacion diferida) y esto no es posible en objetos.
Ademas en haskell no hay asignacion, ni efecto colateral, por lo cual no podríamos
guardar las peliculas vendidas y las No. En objeto existe la asignacion y efecto de lado.

3) Propongo crear una relacion llamada precioTotal(Pelicula,PrecioTotal), esta misma
acepta tanto "entrada(Pelicula,Tipo)" como "entrada(Pelicula,Tipo,Descuento)", lo cual la
hace poliformica gracias al patternmatchin, aceptando cualquier tipo de pelicula, y evitando repetir codigo.


precioTotal(Pelicula, PrecioTotal):-

entrada(Pelicula, Tipo),
precio(Tipo,Precio),
Preciototal is Precio

precioTotal(Pelicula, PrecioTotal):-

entrada(Pelicula, Tipo, Descuento),
precioDescontado(Tipo,Descuento,Precio),
PrecioTotal is Precio.

recaudacion(Pelicula, Recaudacion):-

pelicula(Pelicula),
findall(Precio, precioTotal(Peli,Precio), ListaDeprecios),
sumlist(ListaDeprecios, Racaudacion).

4)
La solucion de lista recursiva tiene mas detalle de codigo, lo cual la hace menos declarativa,
tambien eso afecta a su expresividad, ya que es mas dificil de entenderla al leer, la solucion
2 emplea mas logica realacional, ya que utiliza los predicados existentes,

la solucion 1 devuelve la Pelicula que mas recaudo, en cambio la solucion 2 solo devuelva si
la pelicula Evaluada es la Mas recaudadora o NO.

En la solucion 2 busca peliculas con mayor recaudacion, mientras que en la solucion1 se
contempla recaudaciones mayores o iguales.


5)
a) Tipo d ela funcion
f :: a ->(a->a->bool)->(a,b)->[a]-> a

b)
Orden superior: Se ven reflejados a pasar la funcion "m", como parametro,
tambien el uso del filter, simplica la funcion y evita repetir codigo.


composicion: se ve en Head.filter , componer funciones permite unir funcionalidades
, reducir codigo, hacer que sea mas expresiva y declarativo, evitando tanto detalles de codigo.

aplicacion parcial:


c) Si es posible, gracias a que funcional utiliza evalucion diferida,

ejemplo1:

f 5 max (100,"tv") [1...]

>> 6

ejemplo2:


f 5 min (100,"tv") [100...]

>> 100

(12-12-2014 12:20)facundoaita escribió:  Se puede usar la guía de lenguajes.

elem 1 [1,2] = 1 `elem` [1,2]
div 1 2 = 1 `div` 2
mod 1 2 = ...
y asi con varios mas,
son una forma mas parecida al castellano de usar las funciones.

Son los acentos al revez, la verdad que no tengo idea para que se usan en el lenguaje castellano.
Pero en el parcial son comillas simples.

Gracias, ese detalle en la cursada no lo vimos.

Saludos.

ahora Descuento que seria? una interface? una clase abstracta?

---

 

pelicula(duroDeMatar).

pelicula(iceage2).

venta(entrada(duroDeMatar,tradicional,miTarjeta)).

venta(entrada(duroDeMatar,tresde,miercoles)).

venta(entrada(duroDeMatar,tradicional)).

venta(entrada(duroDeMatar,tresde)).

venta(entrada(iceage2,tradicional,miTarjeta)).

venta(entrada(iceage2,tresde,miercoles)).

venta(entrada(iceage2,tradicional)).

venta(entrada(iceage2,tresde)).

venta(entrada(iceage2,tresde)).



precioVenta(Pelicula,entrada(Pelicula,TipoSala,Descuento),Precio):-precioDescontado(TipoSala,Descuento,Precio).

precioVenta(Pelicula,entrada(Pelicula,TipoSala),Precio):-precioBase(TipoSala,Precio).



descuento(miercoles,0.5).

descuento(miTarjeta,0.25).

precioBase(tradicional,100).

precioBase(tresde,Precio):-precioBase(tradicional,PrecioTradicional),Precio is PrecioTradicional + 30.

precioDescontado(TipoSala,Descuento,Total):-precioBase(TipoSala,Precio),descuento(Descuento,Porcentaje),Total is Precio - (Precio * Porcentaje).



recaudacion2(Pelicula,Recaudacion):-pelicula(Pelicula),findall(P,(venta(Venta),precioVenta(Pelicula,Venta,P)),Ventas),sumlist(Ventas,Recaudacion).



laQueMasRecaudo(Peli):-recaudacion2(Peli,Recaudacion),not((recaudacion2(_,OtraRecaudacion),Recaudacion < OtraRecaudacion)).



laQueMasRecaudoRec([Pelicula],Pelicula).

laQueMasRecaudoRec([Peli1, Peli2 | Pelis],Peli):-recaudacion2(Peli1,R1),recaudacion2(Peli2,R2),R1>=R2,laQueMasRecaudoRec([Peli1|Pelis],Peli).

laQueMasRecaudoRec([Peli1, Peli2 | Pelis],Peli):-recaudacion2(Peli1,R1),recaudacion2(Peli2,R2),R1<R2,laQueMasRecaudoRec([Peli2|Pelis],Peli).

yo creo que esta podria ser la modificacion en la solucion pedida en el punto 3) de prolog

uso algunas reglas que ya estaban.