Particiones de una lista

5 Comentarios

1. Haskell

   import Data.List particiones :: [a] -> [[[a]]] particiones [] = [] particiones xs = [take n xs : ys | n <- [1..length xs] , ys <- particiones (drop n xs)] ++ [[xs]]

   1 2 3 4 5 6

   import Data.List   particiones :: [a] -> [[[a]]] particiones []       = [] particiones xs = [take n xs : ys | n <- [1..length xs]                                  , ys <- particiones (drop n xs)] ++ [[xs]]

   Responder

2. Haskell

   particiones :: [a] -> [[[a]]] particiones [] = [] particiones [x] = [[[x]]] particiones (x:xs) = map ([x]:) p ++ map (\ys -> (x: head ys) :tail ys) p where p = particiones xs prop_particiones :: Eq a => [a] -> Bool prop_particiones xs = all (== xs) (map concat (particiones xs)) -- *Main> quickCheckWith (stdArgs {maxSize=10}) prop_particiones -- +++ OK, passed 100 tests.

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

   particiones :: [a] -> [[[a]]] particiones []  = [] particiones [x] = [[[x]]] particiones (x:xs) =   map ([x]:) p ++ map (\ys -> (x: head ys) :tail ys) p   where p = particiones xs prop_particiones :: Eq a => [a] -> Bool prop_particiones xs =   all (== xs) (map concat (particiones xs))   -- *Main> quickCheckWith (stdArgs {maxSize=10}) prop_particiones -- +++ OK, passed 100 tests.

   Responder

3. Haskell

   particiones :: [a] -> [[[a]]] particiones [] = [[[]]] particiones [x] = [[[x]]] particiones (x:xs) = [[x]:bs | bs <- q] ++ [ add x bs | bs <- q] where q = particiones xs add x (b:bs) = (x:b):bs prop_particiones xs = all (==xs) (map (concat) (particiones xs))

   1 2 3 4 5 6 7 8

   particiones :: [a] -> [[[a]]] particiones [] = [[[]]] particiones [x] = [[[x]]] particiones (x:xs) = [[x]:bs | bs <- q] ++ [ add x bs | bs <- q]                  where q = particiones xs                        add x (b:bs) = (x:b):bs   prop_particiones xs = all (==xs) (map (concat) (particiones xs))

   Responder

4. Haskell

   import Data.List import Test.QuickCheck particiones :: [a] -> [[[a]]] particiones [] = [[]] particiones xs = concat.tail $ (zipWith f <$> inits <*> tails) xs where f ys zs = (ys:) <$> particiones zs prop_particiones :: Eq a => [a] -> Bool prop_particiones xs = all ((xs==).concat) (particiones xs)

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

   import Data.List import Test.QuickCheck   particiones :: [a] -> [[[a]]] particiones [] = [[]] particiones xs = concat.tail $ (zipWith f <$> inits <*> tails) xs   where     f ys zs = (ys:) <$> particiones zs     prop_particiones :: Eq a => [a] -> Bool prop_particiones xs = all ((xs==).concat) (particiones xs)

   Responder

5. Haskell

   particiones :: Eq a => [a] -> [[[a]]] particiones [] = [[[]]] particiones (x:xs) = aux x xs where aux :: a -> [a] -> [[[a]]] aux x [] = [[[x]]] aux x (y:xs) = [[x] `o` zs | zs <- aux y xs, o <- [(:),unidos]] unidos :: [a] -> [[a]] -> [[a]] unidos ys (xs:xss) = (ys++xs):xss prop_particiones :: Eq a => [a] -> Bool prop_particiones xs = (all (==xs).map concat.particiones) xs

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

   particiones :: Eq a => [a] -> [[[a]]] particiones [] = [[[]]] particiones (x:xs) = aux x xs   where     aux :: a -> [a] -> [[[a]]]     aux x [] = [[[x]]]     aux x (y:xs) = [[x] `o` zs | zs <- aux y xs,                                  o  <- [(:),unidos]]   unidos :: [a] -> [[a]] -> [[a]] unidos ys (xs:xss) = (ys++xs):xss   prop_particiones :: Eq a => [a] -> Bool prop_particiones xs = (all (==xs).map concat.particiones) xs

   y la comprobación es:

   Haskell

   λ> quickCheckWith (stdArgs {maxSize=10}) prop_particiones +++ OK, passed 100 tests.

   1 2	λ> quickCheckWith (stdArgs {maxSize=10}) prop_particiones +++ OK, passed 100 tests.

   Responder