Supprimer des éléments à l'index en haskell

Deux choses complètement différentes approches

1. Vous pouvez utiliser Liste.splitAt avec goutte:

   import Data.List (splitAt)
   f :: [a] -> [a]
   f [] = []
   f xs = let (h, t) = splitAt 5 xs in h ++ f (drop 3 t)

   Maintenant f [1..12] rendements [1,2,3,4,5,9,10,11,12]. Notez que cette fonction peut être exprimée de manière plus élégante à l'aide de uncurry et de Contrôle.Flèche.deuxième:

   import Data.List (splitAt)
   import Control.Arrow (second)
   f :: [a] -> [a]
   f [] = []
   f xs = uncurry (++) $ second (f . drop 3) $ splitAt 5 xs

   Puisque nous l'utilisons de Contrôle.Flèche de toute façon, on peut choisir de déposer splitAt et au lieu d'appeler à l'aide de de Contrôle.Flèche.(&&&), combiné avec prendre:

   import Control.Arrow ((&&&))
   f :: [a] -> [a]
   f [] = []
   f xs = uncurry (++) $ (take 5 &&& (f . drop 8)) xs

   Mais maintenant, il est clair qu'une encore plus petite solution est la suivante:

   f :: [a] -> [a] 
   f [] = []
   f xs = take 5 xs ++ (f . drop 8) xs

   Comme Chris Lutz notes, cette solution peut donc être généralisée comme suit:

   nofm :: Int -> Int -> [a] -> [a]
   nofm _ _ [] = []
   nofm n m xs = take n xs ++ (nofm n m . drop m) xs

   Maintenant nofm 5 8 les rendements de la fonction requise. Notez qu'une solution avec splitAt peut-être encore plus efficace!

2. Appliquer un peu de mathématiques à l'aide de map, snd, filtre, mod et zip:

   f :: [a] -> [a]
   f = map snd . filter (\(i, _) -> i `mod` 8 < (5 :: Int)) . zip [0..]

   L'idée ici est que nous paire chaque élément dans la liste avec son index, un nombre naturel je. Nous avons ensuite supprimer les éléments pour lesquels j' % 8 > 4. La version générale de cette solution est:

   nofm :: Int -> Int -> [a] -> [a]
   nofm n m = map snd . filter (\(i, _) -> i `mod` m < n) . zip [0..]

Depuis personne ne l'a fait une version avec "unfoldr", ici, est de mon point de vue:

drop3after5 lst = concat $ unfoldr chunk lst
  where
    chunk [] = Nothing
    chunk lst = Just (take 5 lst, drop (5+3) lst)

Semble être la plus courte jusqu'à présent

la take et drop fonctions peuvent être en mesure pour vous aider ici.

drop, take :: Int -> [a] -> [a]

de ces nous avons pu construire une fonction pour faire une étape.

takeNdropM :: Int -> Int -> [a] -> ([a], [a])
takeNdropM n m list = (take n list, drop (n+m) list)

et puis on peut l'utiliser pour réduire notre problème

takeEveryNafterEveryM :: Int -> Int -> [a] -> [a]
takeEveryNafterEveryM n m [] = []
takeEveryNafterEveryM n m list = taken ++ takeEveryNafterEveryM n m rest
    where
        (taken, rest) = takeNdropM n m list

*Main> takeEveryNafterEveryM 5 3 [1..20]
[1,2,3,4,5,9,10,11,12,13,17,18,19,20]

---

puisque ce n'est pas une forme primitive de la récursivité, il est plus difficile d'exprimer cela comme un simple pli.

donc une nouvelle fonction de pliage peut être défini pour s'adapter à vos besoins

splitReduce :: ([a] -> ([a], [a])) -> [a] -> [a]
splitReduce f []   = []
splitReduce f list = left ++ splitReduce f right
    where
        (left, right) = f list

alors, la définition de takeEveryNafterEveryM est tout simplement

takeEveryNafterEveryM2 n m = splitReduce (takeNdropM 5 3)

myRemove = map snd . filter fst . zip (cycle $ (replicate 5 True) ++ (replicate 3 False))