mylist.zip(mylist.drop(1)) { a, b -> myfunction(a,b) }

is there a way to zip 3 lists instead of 2? something equivalent to this?

zip(mylist, mylist.drop(1), mylist.drop(2)) { a, b, c -> myfunction(a,b,c) }

I would like to create a new list of values, which are calculated based on the latest 3 values

I think you want the

windowed

function

ok, I get the meaning of windowed now:

mylist.windowed(2).map {
    myfunction(it.get(0),it.get(1),it.get(2))
}

correct?

yes, though feel free to use the operator

mylist.windowed(2).map {
    myFunction(it[0], it[1], it[2])
}

Or destructure

mylist.windowed(2).map { (a, b, c) ->
    myFunction(a, b, c)
}

@ephemient thanks! @Ruckus actually in my case, I need something like this:

mylist.windowed(8).map {
    myFunction(it[0], it[1], it[7])
}

because I need to calculate differences by the day and by the week, so I need to take the value 1 index later and 7 indexes later

An imperative loop would be more efficient, but whether it matters is a matter of testing.

if

mylist

has random access then

List(mylist.size - 8) { myFunction(mylist[it], mylist[it + 1], mylist[it + 7]) }

would inline to the same as an imperative loop

what is

random access

actually?

array, arraylist, not linkedlist

A list when

list[n]

is constant time, not linear

I watched the Kotlin online event this week, and I heard Roman Elizarov saying to always prefer Lists to Arrays

the distinction comes from java (there is no difference in representation on kotlin/js)

I guess Roman was referring to the Kotlin/JVM

Array comes from a time before generics, and as such has some unique and special treatment by the JVM, like built-in primitive types

so this would not work if I created my list with

listOf

?

List(mylist.size - 8) { myFunction(mylist[it], mylist[it + 1], mylist[it + 7]) }

it will work.

listOf()

is backed by an

ArrayList

(implementation detail, but even if it changes in the future it will still work)

so would you say the above is more efficient than?

mylist.windowed(8).map {
    myFunction(it[0], it[1], it[7])
}

yes, it doesn't need to be indirected through the window list view

Don't try to micro-optimize up front. 80% of the time your program is running is spent in 20% of the code (rough thumb rule). There is no real point in optimizing the other 80%. 1. Make your code working correctly 2. Make your code pretty (refactoring) 3. Optimize your code, but only where you actually have a performance problem according to testing or profiling