Menu Close

Sin ceros consecutivos

José A. Alonso,

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)]
Inicial
,

5 soluciones de “Sin ceros consecutivos”

  1. Responder
    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. Responder
    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. Responder
    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. Responder
    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. Responder
    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

Escribe tu solución

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