Menu Close

Sin ceros consecutivos

Definir la función

   sinDobleCero :: Int -> [[Int]]

tal que (sinDobleCero n) es la lista de las listas de longitud n formadas por el 0 y el 1 tales que no contiene dos ceros consecutivos. Por ejemplo,

   ghci> sinDobleCero 2
   [[1,0],[1,1],[0,1]]
   ghci> sinDobleCero 3
   [[1,1,0],[1,1,1],[1,0,1],[0,1,0],[0,1,1]]
   ghci> sinDobleCero 4
   [[1,1,1,0],[1,1,1,1],[1,1,0,1],[1,0,1,0],[1,0,1,1],
    [0,1,1,0],[0,1,1,1],[0,1,0,1]]

Soluciones

sinDobleCero :: Int -> [[Int]]
sinDobleCero 0 = [[]]
sinDobleCero 1 = [[0],[1]]
sinDobleCero n = [1:xs | xs <- sinDobleCero (n-1)] ++
                 [0:1:ys | ys <- sinDobleCero (n-2)]

5 soluciones de “Sin ceros consecutivos

  1. melgonaco
    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)
  2. fercarnav
    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
  3. juasuator1
    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
  4. Enrique Zubiría
    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)
  5. rebgongor
    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

Leave a Reply

Este sitio usa Akismet para reducir el spam. Aprende cómo se procesan los datos de tus comentarios.