Subsucesiones crecientes de elementos consecutivos

7 Comentarios

1. Haskell

   subsucesiones :: [Integer] -> [[Integer]] subsucesiones = map reverse . aux [] where aux xs (x:y:zs) | x < y = aux (x:xs) (y:zs) | otherwise = (x:xs) : aux [] (y:zs) aux (x:xs) [y] | x < y = [y:x:xs] | otherwise = (x:xs) : [[y]] aux _ [y] = [[y]] aux _ _ = []

   1 2 3 4 5 6 7 8

   subsucesiones :: [Integer] -> [[Integer]] subsucesiones = map reverse . aux []   where aux xs (x:y:zs) | x < y     = aux (x:xs) (y:zs)                         | otherwise = (x:xs) : aux [] (y:zs)         aux (x:xs) [y]  | x < y     = [y:x:xs]                         | otherwise = (x:xs) : [[y]]         aux _      [y]  = [[y]]         aux _      _    = []

   Responder

2. Haskell

   import Data.List(groupBy) subsucesiones :: [Integer] -> [[Integer]] subsucesiones = groupBy (\a b -> a<b)

   1 2 3 4

   import Data.List(groupBy)   subsucesiones :: [Integer] -> [[Integer]] subsucesiones = groupBy (\a b -> a<b)

   Responder

   1. No es correcto, la definición de groupBy es:

      Haskell

      groupBy :: (a -> a -> Bool) -> [a] -> [[a]] groupBy _ [] = [] groupBy eq (x:xs) = (x:ys) : groupBy eq zs where (ys,zs) = span (eq x) xs

      1 2 3 4

      groupBy                 :: (a -> a -> Bool) -> [a] -> [[a]] groupBy _  []           =  [] groupBy eq (x:xs)       =  (x:ys) : groupBy eq zs                            where (ys,zs) = span (eq x) xs

      Responder

3. Haskell

   subsucesiones :: [Integer] -> [[Integer]] subsucesiones = groupBy2 (\a b -> a<b) groupBy2 :: (a -> a -> Bool) -> [a] -> [[a]] groupBy2 eq (x:y:xs) | x `eq` y = (x : head u) : tail u | otherwise = [x]:u where u = groupBy2 eq (y:xs) groupBy2 _ [e] = [[e]] groupBy2 _ [] = []

   1 2 3 4 5 6 7 8 9

   subsucesiones :: [Integer] -> [[Integer]] subsucesiones = groupBy2 (\a b -> a<b)   groupBy2                 :: (a -> a -> Bool) -> [a] -> [[a]] groupBy2 eq (x:y:xs)     | x `eq` y  = (x : head u) : tail u                          | otherwise = [x]:u   where u = groupBy2 eq (y:xs) groupBy2 _  [e]          = [[e]] groupBy2 _  []           =  []

   Responder

4. Haskell

   subsucesiones :: [Integer] -> [[Integer]] subsucesiones = takeWhile (/= []) . separa separa :: [Integer] -> [[Integer]] separa [] = [[]] separa [x] = [[x]] separa (x:y:xs) | x < y = ts : subsucesiones (drop l (x:y:xs)) | otherwise = [x] : subsucesiones (y:xs) where ts = [x,y] ++ (takeWhile (> y) xs) l = length ts

   1 2 3 4 5 6 7 8 9 10

   subsucesiones :: [Integer] -> [[Integer]] subsucesiones = takeWhile (/= []) . separa   separa :: [Integer] -> [[Integer]] separa [] = [[]] separa [x] = [[x]] separa (x:y:xs) | x < y = ts : subsucesiones (drop l (x:y:xs))                 | otherwise = [x] : subsucesiones (y:xs)   where ts = [x,y] ++ (takeWhile (> y) xs)         l  = length ts

   Responder

   1. Haskell

      En las lineas 6 y 7 se usa la funcion "separa", no la de "subsucesiones". subsucesiones :: [Integer] -> [[Integer]] subsucesiones = takeWhile (/= []) . separa separa :: [Integer] -> [[Integer]] separa [] = [[]] separa [x] = [[x]] separa (x:y:xs) | x < y = ts : separa (drop l (x:y:xs)) | otherwise = [x] : separa (y:xs) where ts = [x,y] ++ (takeWhile (> y) xs) l = length ts

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

      En las lineas 6 y 7 se usa la funcion "separa", no la de "subsucesiones".   subsucesiones :: [Integer] -> [[Integer]] subsucesiones = takeWhile (/= []) . separa   separa :: [Integer] -> [[Integer]] separa [] = [[]] separa [x] = [[x]] separa (x:y:xs) | x < y = ts : separa (drop l (x:y:xs))                 | otherwise = [x] : separa (y:xs)   where ts = [x,y] ++ (takeWhile (> y) xs)         l  = length ts

      Responder

      1. Contraejemplo:

         Haskell

         -- λ> subsucesiones [1,2,4,3] -- [[1,2,4,3]]

         1 2	-- λ> subsucesiones [1,2,4,3] -- [[1,2,4,3]]

         En lugar de:

         Haskell

         -- λ> subsucesiones [1,2,4,3] -- [[1,2,4],[3]]

         1 2	-- λ> subsucesiones [1,2,4,3] -- [[1,2,4],[3]]

         Responder