Geek Answers Handbook

Edit every Nth item in the list

I want to perform an arithmetic operation (e.g. doubling a value) in a list of integers, each n places.

For example, given the list [1,2,3,4,5,6,7], I want to double the values ​​every three places. In this case, we would have [1,2,6,4,5,12,7].

How can i do this?

+4
source share
5 answers

A common way to get indexes for values ​​in a list is to ziplist in tuples (value, index).

ghci > let zipped = zip [1,2,3,4,5,6,7] [1..]
ghci > zipped
[(1,1),(2,2),(3,3),(4,4),(5,5),(6,6),(7,7)]

Then you just need to mapover this list and return a new one. If the index is divided by 3 ( index `rem` 3 == 0), we will double the value, otherwise we will return the same value:

ghci > map (\(value, index) -> if index `rem` 3 == 0 then value*2 else value) zipped
[1,2,6,4,5,12,7]

, - , zip map ..

zip, Haddocks, : "zip ". ( , https://www.stackage.org zip).

map , .

Lambdas - . map, , . , , Python, Ruby Swift.

lambdas:

(\arg1, arg2 -> functionBodyHere)

:

ghci > let myCalculation (value, index) = if index `rem` 3 == 0 then value*2 else value
ghci > map myCalculation zipped
[1,2,6,4,5,12,7]
+7
applyEvery :: Int -> (a -> a) -> [a] -> [a]
applyEvery n f = zipWith ($) (cycle (replicate (n-1) id ++ [f]))

cycle [id,id,...,id,f] ad nauseam, zipWith ($) .

, ! .

ASCII ( ASCII!):

functions : [ id, id, f  , id, id, f  , id, id, f, ... 
input list: [  1,  2,   3,  4,  5,   6,  7 ]
-----------------------------------------------------
result    : [  1,  2, f 3,  4,  5, f 6,  7 ]

, , , f ( ), , , . . , , a, "" . applyEvery :: Int -> (a -> a) -> [a] -> [a]. , doubleEveryThird = applyEvery 3 (*2) - , , . :-)

, , n-1 id s, f : replicate (n-1) id ++ [f]. replicate m x , m x, . replicate 5 'a' = "aaaaa", . f, , :, - Haskell .

cycle ( repeat, ). cycle [a] -> [a], " ". cycle [1,2,3] [1,2,3,1,2,3,1,2,3,...]

[: -y, , - repeat : , ]

zipWith ($). , zip, , , . :

    xs   : [ a  , b    , c   , d, e] 
       ys: [   x,    y ,   z ]
------------------------------
zip xs ys: [(a,x),(b,y),(c,z)]

, , ? , , ( ) . zipWith. (, ​​ !):

          xs   : [   a  ,   b  ,   c   , d, e] 
             ys: [     x,     y,     z ]
----------------------------------------
zipWith f xs ys: [ f a x, f b y, f c z ]

, zipWith ? , , (\f x -> f x) . lambdas , apply f x = f x . Prelude, $! infix , ($) ( (\f x -> f $ x))

, :

applyEvery :: Int -> (a -> a) -> [a] -> [a]
applyEvery n f xs = zipWith ($) (cycle (replicate (n-1) id ++ [f])) xs

xs , , .

+13
mapIf :: (Int -> Bool) -> (a -> a) -> [a] -> [a]
mapIf pred f l = map (\(value,index) -> if (pred index) then f value else value) $ zip l [1..]

mapEveryN :: Int -> (a -> a) -> [a] -> [a]
mapEveryN n = mapIf (\x -> x `mod` n == 0)

Live on Ideone.

+2

: .

lens Traversal. Control.Lens :

{-# LANGUAGE RankNTypes, ScopedTypeVariables #-}

type Traversal s t a b =
  forall f . Applicative f => (a -> f b) -> s -> f t

type Traversal' s a = Traversal s s a a

lens itraverse Control.Lens.Indexed:

-- everyNth :: (TraversableWithIndex i t, Integral i)
            => i -> Traversal' (t a) a
everyNth :: (TraversableWithIndex i t, Integral i, Applicative f)
         => i -> (a -> f a) -> t a -> f (t a)
everyNth n f = itraverse f where
  g i x | i `rem` n == n - 1 = f x
        | otherwise = pure x

This may be specialized for your specific purpose:

import Data.Profunctor.Unsafe
import Data.Functor.Identity

everyNthPureList :: Int -> (a -> a) -> [a] -> [a]
everyNthPureList n f = runIdentity #. everyNth n (Identity #. f)
+2
source

Simple recursive approach:

everyNth n f xs = igo n xs where
    igo 1 (y:ys) = f y : igo n     ys
    igo m (y:ys) =   y : igo (m-1) ys
    igo _ [] = []

doubleEveryThird = everyNth 3 (*2)

Basically, igo starts with n, counting down until it reaches 1where it will apply this function and return to n. doubleEveryThirdpartially applied: everyNthexpects three arguments, but we gave only two, so we dougleEveryThirdwill expect the final argument.

+1
source

More articles:


All Articles