UTNianos

Hola gente, alguien me daria una mano, resulta que tengo esta consigna:

sinRepetidos/1, que dada una lista devuelve la misma sin elementos repetidos. Los elementos tienen que aparecer en el mismo orden que en la lista original (la primera ocurrencia de la lista de izquierda a derecha).

y mi resolucion (pd: funciona) pero por la menor fucking idea no la toman como valida, me dijeron de usar un filter, ayuda?

sinRepetidos lista = (reverse.(sacarRepetidos.reverse)) lista
sacarRepetidos [] = []
sacarRepetidos (x:xs)| elem x xs = sacarRepetidos xs
| otherwise = x:sacarRepetidos xs

Hola, mira, yo use esta en un tp y esta aprobado

sinRepetidos [] = []
sinRepetidos (x:xs)
| any (== x) (xs) = sinRepetidos xs
| otherwise = (x):sinRepetidos xs

sinRepetidos (x:xs) = filter (not (seRepiteEn xs)) (x:xs)

seRepiteEn lista elemento = elem elemento lista

Creo que eso debería funcar, no tengo un haskell para probarlo asique decime si te sirve xD

(14-08-2015 09:08)aaajfabio escribió: [ -> ]sinRepetidos (x:xs) = filter (not (seRepiteEn xs)) (x:xs)

seRepiteEn (x:xs) elem = elem x xs

Creo que eso debería funcar, no tengo un haskell para probarlo asique decime si te sirve xD

Funciona Que genio!! Era mas sencillo del que hice jaja

sinRepetidos lista = invertir (sacarRepetidos lista)

sacarRepetidos [] = []
sacarRepetidos lista | not(elem (last lista) (init lista)) = (last lista):sacarRepetidos (init lista)
| otherwise = sacarRepetidos (init lista)

invertir [ ] = [ ]
invertir (x:xs) = (invertir xs)++[x]

La función seRepiteEn, estaba mal asique la arreglé xD

Lo que hace el filter es decir "de la lista unaLista, dejame los que cumplan unCriterio".
Y para este caso, se traduce como "déjame los que no se repiten --> not(seRepiteEn xs)"

La función seRepiteEn es lo mismo que elem, y le di vuelta los argumentos para aplicar parcialmente con la cola de la lista original en el filter. Además es más declarativo porque está más claro QUÉ es lo que querés que la función haga y no te concentrás tanto en el cómo (cosa que si ocurre en la solución recursiva)

Entonces si vos lo que querés hacer es partir de una lista y REDUCIRLA, eso es sinónimo de filter. Fijate que la implementación de la función filter sería algo como:

filter :: (a -> Bool) -> [a] -> [a]
filter _ [] = []
filter p (x:xs)
| p x = x : filter p xs
| otherwise = filter p xs

Acá se aplica recursividad, que es lo que vos aplicaste justamente en tu primer solución.

Off-topic:

Lo que quiero decir con esto en realidad es que tu código no era feliz, o no nanuiit ??

(14-08-2015 15:15)aaajfabio escribió: [ -> ]La función seRepiteEn, estaba mal asique la arreglé xD

Lo que hace el filter es decir "de la lista unaLista, dejame los que cumplan unCriterio".
Y para este caso, se traduce como "déjame los que no se repiten --> not(seRepiteEn xs)"

La función seRepiteEn es lo mismo que elem, y le di vuelta los argumentos para aplicar parcialmente con la cola de la lista original en el filter. Además es más declarativo porque está más claro QUÉ es lo que querés que la función haga y no te concentrás tanto en el cómo (cosa que si ocurre en la solución recursiva)

Entonces si vos lo que querés hacer es partir de una lista y REDUCIRLA, eso es sinónimo de filter. Fijate que la implementación de la función filter sería algo como:

filter :: (a -> Bool) -> [a] -> [a]
filter _ [] = []
filter p (x:xs)
| p x = x : filter p xs
| otherwise = filter p xs

Acá se aplica recursividad, que es lo que vos aplicaste justamente en tu primer solución.

Off-topic:

Lo que quiero decir con esto en realidad es que tu código no era feliz, o no nanuiit ??

jajajajaj no tengo codigos felices xP

che te hago una pregunta mas?

ordenar f [] = []
ordenar f (x:xs) | (f == >) = ordenar ">" [ y | y <- xs, y > x ] ++ [x] ++ ordenar f [ y | y <- xs, y <= x ]
| (f == <) = ordenar "<" [ y | y <- xs, y < x ] ++ [x] ++ ordenar f [ y | y <- xs, y >= x ]

tengo que ordenar, pero no puedo pasarle strings y no se como comparar para saber como ordenar segun criterio

Ale, creo haber entendido que la idea de tu función ordenar es que si la función es <, ordenar usando <, y si la función fuera >, ordenar usando >. ¿Entendí bien?


> y < son funciones que ya están definidas en Haskell, y que sólo comparan cosas que Haskell sabe comparar (creo que con :t > podés ver el prototipo de la función para ver bien qué cosas puede comparar esa función, supongo que los Ord o algo así).


Pero, por ejemplo, si vas a implementar una función ordenar que recibe por parámetro el criterio de comparación, estaría bueno también que, por ejemplo, puedas ordenar una lista de, no se, Personas. O Autos. O Golondrinas. Y cada una con un criterio que vos quieras.


No se trata tanto de pensar en qué criterios uno podría querer usar para ordenar una lista, si no pensar qué significa ordenar una lista.

Si tuvieras un duende al que le pasás dos cosas y él te sabe contestar cuál de las dos cosas tiene que aparecer antes para estar ordenado, ¿no podrías hacer una función que delege a ese duende todo lo necesario y se encargue estrictamente de ordenar la lista siguiendo el criterio del duende?

Ese es el punto acá: ya hay una función, que te pasan por parámetro (y que en tu caso se llama f) que sabe decirte cuál de dos cosas que le pases va antes. Esa función podría ser <, o podría ser >. Pero también podría ser una función así (hace *años* no escribo Haskell, espero que sea bastante válido mi código):

 

menorEnergia :: Golondrina -> Golondrina -> Bool

menorEnergia anterior siguiente = (energia anterior) < (energia siguiente) -- aca seguro sobran parentesis, pero bleh

Y entonces, si esa función estuviera definida (y estuvieran definidas las Golondrinas, y la función energia), podría querer hacer una invocación así:

 

ordenar menorEnergia [(pepita, 50), (pepona, 20), (juanSalvador, 73)]

Y debería obtener la lista ordenada como corresponde.

Y otro podría implementar que existan Satelites, y una función que los compare según la altitud de su órbita, y otra función que compare según el peso del satélite, y lo que quiera.. Y tu función debería seguir sirviendo. Porque mientras te pasen una función que sepa comparar los elementos de la lista que te pasan, tu función ordenar debería funcionar.

Ordenar una lista es siempre igual: lo que cambia según el tipo de cosa que haya adentro de la lista es la forma de comparar a los elementos de esa lista. Por eso lo extraemos a una función aparte, y delegamos en ella esos detalles.


¿Recordás cómo aplicar una función que te pasaron por parámetro? Quizá te puedan servir un poco las páginas de Aplicación y Orden superior de la wiki de Uqbar.

¡Un abrazo!