bir dize her n eleman çıkarmanın nasıl dize

Question

gelen her n eleman kaldırılsın mı?

Sana şekilde çeşit drop işlevini kullanın tahmin ediyorum. Bu birinci n düşer gibi

, nasıl bu kadar üzerinde değil, hepsinden daha bu yüzden ancak bundan sonra nth ve sonra n'inci damla değiştirebilir ve ki? take ve drop birleştirmek

dropthem n xs = drop n xs 

Answer 1

remove_every_nth :: Int -> [a] -> [a] 
remove_every_nth n = foldr step [] . zip [1..] 
    where step (i,x) acc = if (i `mod` n) == 0 then acc else x:acc

İşte

işlevi yaptığı da budur:

zip [1..] listedeki endekse tüm öğeleri kullanılır, bu nedenle örneğin zip [1..] "foo", [(1,'f'), (2,'o'), (3,'o')] olur.

Dizinlenmiş liste daha sonra n tarafından dizinine bölünemeyen her öğeyi biriktiren bir right fold ile işlenir.

Burada aslında aynı şeyi yapan biraz daha uzun bir sürüm var, ancak zip [1..] ek bellek ayırmalarını önler ve modül hesaplaması gerekmez.

remove_every_nth :: Int -> [a] -> [a] 
remove_every_nth = recur 1 
    where recur _ _ []  = [] 
      recur i n (x:xs) = if i == n 
      then recur 1 n xs 
      else x:recur (i+1) n xs

Answer 2

deneyin bunu başarmak için.

take 3 "hello world" = "hel" 
drop 4 "hello world" = "o world" 

Answer 3

-- groups is a pretty useful function on its own! 
groups :: Int -> [a] -> [[a]] 
groups n = map (take n) . takeWhile (not . null) . iterate (drop n) 

removeEveryNth :: Int -> [a] -> [a] 
removeEveryNth n = concatMap (take (n-1)) . groups n 

Answer 4

basit. (N-1) elementlerini alın, ardından 1'i atlayın, durulayın ve tekrarlayın.

dropEvery _ [] = [] 
dropEvery n xs = take (n-1) xs ++ dropEvery n (drop n xs) 

veya verimlilik aşkına gösterir tarzda

aşağıdaki çözüm gibi

dropEvery n xs = dropEvery' n xs $ [] 
    where dropEvery' n [] = id 
      dropEvery' n xs = (take (n-1) xs ++) . dropEvery n (drop n xs) 

Answer 5

:

del_every_nth :: Int -> [a] -> [a]  
del_every_nth n = concat . map init . group n 

Sadece hangi grupların uzunluktaki bölümler halinde bir liste bir işlevi group tanımlamak zorunda n. Ama bu oldukça kolay:

group :: Int -> [a] -> [[a]] 
group n [] = [] 
group n xs = take n xs : group n (drop n xs)