Sin ceros consecutivos

5 Comentarios

1. Haskell

   sinDobleCero :: Int -> [[Int]] sinDobleCero 1 = [[0],[1]] sinDobleCero n = [1:xs | xs <- xss] ++ [0:xs | xs <- xss, head xs /= 0] where xss = sinDobleCero (n-1)

   1 2 3 4

   sinDobleCero :: Int -> [[Int]] sinDobleCero 1 = [[0],[1]] sinDobleCero n = [1:xs | xs <- xss] ++ [0:xs | xs <- xss, head xs /= 0]     where xss = sinDobleCero (n-1)

   Responder

2. Haskell

   import Data.Array sinDobleCero :: Int -> [[Int]] sinDobleCero n = concat [q ! (i,n) | i <- [1..2]] where q = matrizSinDobleCero n matrizSinDobleCero :: Int -> Array (Int,Int) [[Int]] matrizSinDobleCero n= q where q = array ((1,1),(2,n)) [((i,j),f i j) | i <- [1..2], j<-[1..n]] f i 1 | i==1 = [[1]] | otherwise = [[0]] f i j = (map (1:) r)++ (filter (dobleCero) (map (0:) r)) where r = (q!(i,j-1)) dobleCero (x1:x2:_) | x1== x2 && x1 /= 0 = True | x1 /= x2 = True | otherwise = False

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

   import Data.Array   sinDobleCero :: Int -> [[Int]] sinDobleCero n = concat [q ! (i,n) | i <- [1..2]]   where q = matrizSinDobleCero n   matrizSinDobleCero :: Int -> Array (Int,Int) [[Int]] matrizSinDobleCero n= q where   q = array ((1,1),(2,n)) [((i,j),f i j) | i <- [1..2], j<-[1..n]]   f i 1     |  i==1 = [[1]]     | otherwise = [[0]]   f i j = (map (1:) r)++ (filter (dobleCero) (map (0:) r))       where r = (q!(i,j-1))             dobleCero (x1:x2:_)               | x1== x2 && x1 /= 0 = True               | x1 /= x2 = True               | otherwise = False

   Responder

3. Haskell

   sinDobleCero :: Int -> [[Int]] sinDobleCero n = f $ until p añadirnumero ([[1]],[[0]]) where p (xss,yss) = and $ map (all (\xs-> length xs ==n)) [xss,yss] f (xss,yss) = xss ++ yss -- p es cuando ya no se puede añadir ningún numero más y f es sumar los dos -- pares de listas para que te quede una sola lista de listas añadirnumero (xss,yss) = (p,q) where p = g yss ++ g xss q = f xss f [] = [] f (xs:xss) =(0:xs):f xss g [] = [] g (ys:yss) = (1:ys):g yss -- xss son los que empiezan por 1 y yss los que empiezan por 0 y añadirnumero -- crea un par listas de listas donde en p todos empiezan por 1 y en q -- por cero

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

   sinDobleCero :: Int -> [[Int]] sinDobleCero n =  f $ until p añadirnumero  ([[1]],[[0]])   where p (xss,yss) =  and $ map (all (\xs-> length xs ==n)) [xss,yss]         f (xss,yss) = xss ++ yss          -- p es cuando ya no se puede añadir ningún numero más y f es sumar los dos -- pares de listas para que te quede una sola lista de listas añadirnumero (xss,yss) = (p,q)   where p = g yss ++ g xss         q = f xss         f [] = []         f (xs:xss) =(0:xs):f xss         g [] = []         g (ys:yss) = (1:ys):g yss   -- xss son los que empiezan por 1 y yss los que empiezan por 0 y añadirnumero -- crea un par listas de listas donde en p todos empiezan por 1 y en q -- por cero

   Responder

4. Haskell

   import Data.List (group) import Math.Combinat.Sets (tuplesFromList) sinDobleCero :: Int -> [[Int]] sinDobleCero n = map concat (filter f (map group (tuplesFromList n [0,1]))) where f = not . any (\x -> all (==0) x && length x > 1)

   1 2 3 4 5 6

   import Data.List (group) import Math.Combinat.Sets (tuplesFromList)   sinDobleCero :: Int -> [[Int]] sinDobleCero n = map concat (filter f (map group (tuplesFromList n [0,1])))   where f = not . any (\x -> all (==0) x && length x > 1)

   Responder

5. Haskell

   import Data.List sinDobleCero :: Int -> [[Int]] sinDobleCero n = filter (noDobleCero) css where xss = subsequences ((concat (map (replicate n) [0,1])) ++ replicate n 0 ++ replicate n 1) yss = map reverse xss zss = yss ++ xss css = nub $ (filter (\xs -> length xs == n)) zss noDobleCero :: [Int] -> Bool noDobleCero [] = True noDobleCero [x] = True noDobleCero (x:xs) | all (== 0) (x:xs) = False | x == 0 && head xs == 0 = False | x == 0 && head xs /= 0 = noDobleCero (tail xs) | x /= 0 = noDobleCero xs

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

   import Data.List sinDobleCero :: Int -> [[Int]] sinDobleCero n = filter (noDobleCero) css   where xss = subsequences ((concat (map (replicate n) [0,1])) ++                             replicate n 0 ++ replicate n 1)         yss = map reverse xss         zss = yss ++ xss         css = nub $ (filter (\xs -> length xs == n)) zss    noDobleCero :: [Int] -> Bool noDobleCero [] = True noDobleCero [x] = True noDobleCero (x:xs) | all (== 0) (x:xs) = False                    | x == 0 && head xs == 0 = False                    | x == 0 && head xs /= 0 = noDobleCero (tail xs)                    | x /= 0 = noDobleCero xs

   Responder