Eliminación de triplicados

6 Comentarios

1. Haskell

   import Data.List sinTriplicados :: Eq a => [a] -> [a] sinTriplicados xs = aux xs [] where aux [] ys = reverse ys aux (x:xs) ys | x `elem` ys && x `elem` ys\\[x] = aux xs ys | otherwise = aux xs (x:ys)

   1 2 3 4 5 6 7

   import Data.List   sinTriplicados :: Eq a => [a] -> [a] sinTriplicados xs = aux xs []   where aux []     ys = reverse ys         aux (x:xs) ys | x `elem` ys && x `elem` ys\\[x] = aux xs ys                       | otherwise                       = aux xs (x:ys)

   Responder

2. Haskell

   sinTriplicados :: Eq a => [a] -> [a] sinTriplicados cs = aux [] [] cs where aux _ _ [] = [] aux pri seg (c:cs) | c `elem` seg = aux pri seg cs | c `elem` pri = c : aux pri (c:seg) cs | otherwise = c : aux (c:pri) seg cs

   1 2 3 4 5 6 7 8

   sinTriplicados :: Eq a => [a] -> [a] sinTriplicados cs = aux [] [] cs   where     aux _   _   []   = []     aux pri seg (c:cs)       | c `elem` seg =     aux pri     seg     cs       | c `elem` pri = c : aux pri     (c:seg) cs       | otherwise    = c : aux (c:pri) seg     cs

   Responder

3. Haskell

   sinTriplicados xs = aux xs [] [] where aux [] ys _ = reverse ys aux (x:xs) ys zs | q = aux xs ys zs | p = aux xs (x:ys) (x:zs) | otherwise = aux xs (x:ys) zs where p = elem x ys q = elem x zs

   1 2 3 4 5 6 7

   sinTriplicados xs = aux xs [] []   where aux [] ys _ = reverse ys         aux (x:xs) ys zs | q = aux xs ys zs                          | p = aux xs (x:ys) (x:zs)                          | otherwise = aux xs (x:ys) zs                   where p = elem x ys                         q = elem x zs

   Responder

4. Haskell

   sinTriplicados :: Eq a => [a] -> [a] sinTriplicados = soloKDuplicados 2 soloKDuplicados :: Eq a => Int -> [a] -> [a] soloKDuplicados k xs = f [] (concat . replicate k $ nub xs) xs where f as ds@(_:_) (y:ys) | y `elem` ds = f (y:as) (delete y ds) ys | otherwise = f as ds ys f as _ _ = reverse as

   1 2 3 4 5 6 7 8 9

   sinTriplicados :: Eq a => [a] -> [a] sinTriplicados = soloKDuplicados 2   soloKDuplicados :: Eq a => Int -> [a] -> [a] soloKDuplicados k xs = f [] (concat . replicate k $ nub xs) xs   where     f as ds@(_:_) (y:ys) | y `elem` ds  = f (y:as) (delete y ds) ys                          | otherwise    = f as ds ys     f as _ _  = reverse as

   Responder

5. Haskell

   sinTriplicados :: Eq a => [a] -> [a] sinTriplicados xs = aux xs [] where aux [] _ = [] aux (x:xs) ys | x `elem` ys = x : aux (elimina xs x) ys | otherwise = x : aux xs (x:ys) elimina :: Eq a => [a] -> a -> [a] elimina [] _ = [] elimina (x:xs) n | x == n = elimina xs n | otherwise = x : elimina xs n

   1 2 3 4 5 6 7 8 9 10 11

   sinTriplicados :: Eq a => [a] -> [a] sinTriplicados xs = aux xs []   where     aux []     _  = []     aux (x:xs) ys | x `elem` ys = x : aux (elimina xs x) ys                   | otherwise   = x : aux xs (x:ys)   elimina :: Eq a => [a] -> a -> [a] elimina []     _ = [] elimina (x:xs) n | x == n    = elimina xs n                  | otherwise = x : elimina xs n

   Responder

6. Haskell

   sinTriplicados :: (Eq a,Ord a) => [a] -> [a] sinTriplicados xs = [x | (x,y) <- bs] where bs = [(x,y) | (x,y) <- cs, y <= 2] cs = order ds xs ds = concatMap (`zip` [1..]) $ (group . sort) xs order :: Eq a => [(a,b)] -> [a] -> [(a,b)] order [] [] = [] order (x:xs) (y:ys) | fst x == y = x : order xs ys | otherwise = order (xs ++ [x]) (y:ys) -- La función no es lo suficientemente eficiente como para llegar al último caso

   1 2 3 4 5 6 7 8 9 10 11 12

   sinTriplicados :: (Eq a,Ord a) => [a] -> [a] sinTriplicados xs = [x | (x,y) <- bs]   where bs = [(x,y) | (x,y) <- cs, y <= 2]         cs = order ds xs         ds = concatMap (`zip` [1..]) $ (group . sort) xs   order :: Eq a => [(a,b)] -> [a] -> [(a,b)] order [] []         = [] order (x:xs) (y:ys) | fst x == y  =  x : order xs ys                     | otherwise   =  order (xs ++ [x]) (y:ys)   -- La función no es lo suficientemente eficiente como para llegar al último caso

   Responder