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
,

10 soluciones de “Sin ceros consecutivos”

  1. Responder
    Álvaro Gutiérrez 
    sinDobleCero 1 = [[1],[0]]
sinDobleCero n = map (e->1:e) (sinDobleCero (n-1))
              ++ map (e->0:e) (filter ((e:_)->e/=0) (sinDobleCero (n-1)))
  2. Responder
    albcarcas1 
     
import Data.List
 
sinDobleCero :: Int -> [[Int]]
sinDobleCero n = filter (xs -> and[x /= y | (x,y) <- zip xs (tail xs), x == 0]) ps
  where ps = (nub.concat)[permutations((replicate x 0)++(replicate (n-x) 1)) | x <- [0..(div (n+1) 2)]]
  3. Responder
    jaibengue 
    sinDobleCero :: Int -> [[Int]]
sinDobleCero n = (aux [0] (n-1)) ++ (aux [] n)
  where aux xs 0 = [xs]
        aux xs 1 = [(1:xs)]
        aux xs m = ((aux (1:xs) (m-1))++(aux (0:1:xs) (m-2)))
  4. Responder
    jaibengue 
    import Data.Array
 
sinDobleCero :: Int -> [[Int]]
sinDobleCero n = aux ! n
  where aux = array (0,n) [(i,f i) | i <- [0..n]]
        f 0 = [[]]
        f 1 = [[0],[1]]
        f n = map (0:) (map (1:) (f (n-2))) ++ map (1:) (f (n-1))
  5. Responder
    anadebla 
     
import Data.List
import Data.Set as S
 
sinDobleCero :: Int -> [[Int]]
 
 
sinDobleCero n = [xs | xs <- (sinDobleCero1 n), notElem 0 (sumaConsecutivos xs)]
 
sinDobleCero1 n =  nub [ xs | xs <-subsecuencias n , length xs == n]
 
subsecuencias x = concat [subsequences xs | xs <- repite x ]
 
repite x  =  permutations (take x (repeat 1) ++ take x (repeat 0))
 
sumaConsecutivos :: [Int] -> [Int]
sumaConsecutivos xs = [x+y | (x,y) <- zip xs (tail xs)]
  6. Responder
    menvealer 
    import Data.List
 
sinDobleCero :: Int -> [[Int]]
sinDobleCero 0 = []
sinDobleCero 1 = [[0],[1]]
sinDobleCero n = elimi0Dobles $ nub $ xs ++ [aux (head xs)] ++ map reverse xs 
  where xs = [1:ys | ys <- sinDobleCero (n-1)]
        aux (x:xs) = 0 : xs
        f xs = length xs == 2
        tieneDobles xs = [0,0] `elem` (filter (f) (group xs))
        elimi0Dobles [] = []
        elimi0Dobles (xs:xss) | tieneDobles xs = elimi0Dobles xss
                              | otherwise = xs : elimi0Dobles xss
  7. Responder
    josmoncos

    El orden no es el mismo que en los ejemplos, pero los ejemplos dan igual:

    sinDobleCero :: Int -> [[Int]]
sinDobleCero 1 = [[1],[0]]
sinDobleCero n = aux (sinDobleCero (n-1))
  where aux [] = []
        aux ((x:xs):xss) | x == 0 = (1:x:xs):(aux xss)
                         | otherwise = (1:x:xs):(0:x:xs):aux xss
  8. Responder
    pabhueacu 
    sinDobleCero :: Int -> [[Int]]
sinDobleCero 1 = [[0],[1]]
sinDobleCero n = [(i:xs)| xs <- sinDobleCero (n-1), i <- [0,1], f i xs]
  where f i (x:xs) = not (x == 0 && i == 0)
  9. Responder
    rocruimon 
     
-- Es otra definición, aunque no tiene el mismo orden que los ejemplos
sinDobleCero :: Int -> [[Int]]
sinDobleCero 0 = []
sinDobleCero 1 = [[0],[1]]
sinDobleCero n =  filter notieneCerosConsecutivos
       (concat[[(0:xs),(1:xs)] | xs<-sinDobleCero (n-1)])
 
 
notieneCerosConsecutivos xs = (head xs: take 1 (drop 1 xs)) /= [0,0]
  10. Responder
    alvblamol 
    sinDobleCero :: Int -> [[Int]]
sinDobleCero 1= [[0], [1]]
sinDobleCero n = [1:xs | xs<-sinDobleCero (n-1)] ++ [0:xs | xs<-sinDobleCero (n-1), (head xs)/=0]

Escribe tu solución

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