```mylist.zip(mylist.drop(1)) { a, b -> myfunct...

# getting-started

[Daniele B]

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

[Ruckus]

I think you want the windowed function

[Daniele B]

ok, I get the meaning of windowed now:

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

correct?

[ephemient]

yes, though feel free to use the operator

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

[Ruckus]

Or destructure

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

[Daniele B]

@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

[Daniele B]

on the documentation is written that windowed() is returning a list for each window:
https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/windowed.html
I wonder if that ends up being too expensive, and whether it’s more efficient to just use an imperative loop

[Ruckus]

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

[ephemient]

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

[Daniele B]

what is random access actually?

[ephemient]

array, arraylist, not linkedlist

[Ruckus]

A list when list[n] is constant time, not linear

[ephemient]

https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/-random-access.html

[Daniele B]

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

[Daniele B]

I don’t even understand the difference to be honest

[ephemient]

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

[Daniele B]

I guess Roman was referring to the Kotlin/JVM

[Daniele B]

but I am doing multiplatform, so it would make a difference for me

[ephemient]

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

[ephemient]

List actually fits into the iterable/collection type hierarchy and works like everything else you'd expect

[ephemient]

the default implementation is ArrayList which does use Array internally, but as a user all you care about is that it is amortized O(1) access

[Daniele B]

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]) }

[ephemient]

it will work. listOf() is backed by an ArrayList (implementation detail, but even if it changes in the future it will still work)

[Daniele B]

so would you say the above is more efficient than?

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

[ephemient]

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

[ephemient]

but it's almost certainly a smaller difference that you should care about

[ephemient]

... and I realized it's slightly wrong; it should be List(mylist.size - 7) to get the last window. that's what happens easily when working without the abstractions

[Vampire]

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