Ordenación por frecuencia

5 Comentarios

1. Haskell

   import Data.List import Data.Function (on) ordPorFrecuencia :: Ord a => [a] -> [a] ordPorFrecuencia = concat . sortBy (compare `on` length). group . sort

   1 2 3 4 5

   import Data.List import Data.Function (on)   ordPorFrecuencia :: Ord a => [a] -> [a] ordPorFrecuencia = concat . sortBy (compare `on` length). group . sort

   Responder

2. Haskell

   import Data.Array import Data.List ordPorFrecuencia :: (Ix a, Ord a) => [a] -> [a] ordPorFrecuencia xs = concat $ sortBy orden $ map (\(x,n) -> replicate n x) $ assocs $ accumArray (+) 0 (y,z) $ zip xs [1,1..] where y:ys = sort xs z = last ys orden :: [a] -> [a] -> Ordering orden xs ys | x > y = GT | x < y = LT | otherwise = EQ where x = length xs y = length ys

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

   import Data.Array import Data.List   ordPorFrecuencia :: (Ix a, Ord a)  => [a] -> [a] ordPorFrecuencia xs = concat $ sortBy orden $                       map (\(x,n) -> replicate n x) $                       assocs $ accumArray (+) 0 (y,z) $                       zip xs [1,1..]   where y:ys = sort xs         z    = last ys   orden :: [a] -> [a] -> Ordering orden xs ys | x > y     = GT             | x < y     = LT             | otherwise = EQ   where x = length xs         y = length ys

   Responder

3. Haskell

   import Data.List ordPorFrecuencia :: Ord a => [a] -> [a] ordPorFrecuencia [] = [] ordPorFrecuencia xs = ys ++ ordPorFrecuencia (quitarMuchos ys xs) where ys = elementosMasAparecen xs quitarMuchos [] xs = xs quitarMuchos _ [] = [] quitarMuchos (y:ys) xs = quitarMuchos ys (quitar y xs) quitar _ [] = [] quitar z (x:xs) | x == z = quitar z xs | otherwise = x : quitar z xs elementosMasAparecen xs = concat [take (vecesAparece y xs) (repeat y) | y <- ys ] where ys = (sort [ fst (x,m) | (x,m) <- (vecesLista xs), m == minimum [ vecesAparece x xs | x <- xs ] ]) vecesLista xs = nub [ (x,vecesAparece x xs) | x <- xs ] vecesAparece z xs = length $ filter (==z) xs

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

   import Data.List   ordPorFrecuencia :: Ord a => [a] -> [a] ordPorFrecuencia [] = [] ordPorFrecuencia xs = ys ++ ordPorFrecuencia (quitarMuchos ys xs)   where ys = elementosMasAparecen xs   quitarMuchos [] xs = xs quitarMuchos _ [] = [] quitarMuchos (y:ys) xs = quitarMuchos ys (quitar y xs)   quitar _ [] = [] quitar z (x:xs) | x == z = quitar z xs                 | otherwise = x : quitar z xs   elementosMasAparecen xs =   concat [take (vecesAparece y xs) (repeat y) | y <- ys ]   where ys = (sort [ fst (x,m) | (x,m) <- (vecesLista xs),               m == minimum [ vecesAparece x xs | x <- xs ] ])   vecesLista xs = nub [ (x,vecesAparece x xs) | x <- xs ]   vecesAparece z xs = length $ filter (==z) xs

   Responder

   1. Haskell

      import Data.List ordPorFrecuencia :: Ord a => [a] -> [a] ordPorFrecuencia [] = [] ordPorFrecuencia xs = ys ++ ordPorFrecuencia (quitarMuchos ys xs) where ys = elementosMasAparecen xs quitarMuchos ys xs = filter (`notElem` ys) xs elementosMenosAparecen xs = concat [ take (vecesAparece y xs) (repeat y) | y <- ys ] where ys = (sort [ fst (x,m) | (x,m) <- (vecesLista xs), m == minimum [ vecesAparece x xs | x <- xs ] ]) vecesLista xs = [ (x,vecesAparece x xs) | x <- nub xs ] vecesAparece z xs = length $ filter (==z) xs

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

      import Data.List   ordPorFrecuencia :: Ord a => [a] -> [a] ordPorFrecuencia [] = [] ordPorFrecuencia xs = ys ++ ordPorFrecuencia (quitarMuchos ys xs)               where ys = elementosMasAparecen xs   quitarMuchos ys xs = filter (`notElem` ys) xs   elementosMenosAparecen xs = concat [ take (vecesAparece y xs) (repeat y) | y <- ys ]                      where ys = (sort [ fst (x,m) | (x,m) <- (vecesLista xs), m == minimum [ vecesAparece x xs | x <- xs ] ])   vecesLista xs = [ (x,vecesAparece x xs) | x <- nub xs ]   vecesAparece z xs = length $ filter (==z) xs

      Responder

4. Haskell

   import Data.List ordPorFecuencia :: Ord a => [a] -> [a] ordPorFrecuencia xs = concat (aux xs 1) where listaGrupos xs = group (sort xs) aux xs n | n > maximum (map length (listaGrupos xs)) = [] | otherwise = concat [zs | zs <- listaGrupos xs, length zs == n] : aux xs (n+1)

   1 2 3 4 5 6 7 8

   import Data.List ordPorFecuencia :: Ord a => [a] -> [a] ordPorFrecuencia xs = concat (aux xs 1)       where listaGrupos xs = group (sort xs)             aux xs n | n > maximum (map length (listaGrupos xs)) = []                      | otherwise = concat [zs | zs <- listaGrupos xs,                                            length zs == n] : aux xs (n+1)

   Responder