A modern programming language that makes developers happier.

kotlinlang

is there a function which allows to remove last `n` elements from a MutableList? I.e. equivalent of `dropLast(Int)` for `List`.
Something like `MutableList.removeLast(Int)`

It might be more efficient with a sublist:
```fun MutableList&lt;*&gt;.removeLast(n: Int) {
    subList(size - n, size).clear()
}```

<@U030S9809PH> depends on your list. As far as I know, all lists guarantee `O(1)` `removeLast`. Not sure how predictable `subList(...).clear()` is

for `java.util.ArrayList`, `subList(size - 1n, size).clear()` calls `removeRange(size - n, size)` which is O(1)

that is better than repeated `removeLast()` which is O(n)

Well then the best solution is just to call `removeRange(size-4, size)`. It's also the easiest to read.

you can't call `removeRange` because it is `protected`

I was kind of hoping that the standard library would just provide a single method/extension function for this.

it is also a method of `java.util.AbstractList`, not `kotlin.collections.MutableList`

Although I just tested and actually `repeat(n) { list.removeLast() }` was faster

My program does read lines from text file as well (to process them), but the results are consistent (using the same text file):
repeat removeLast(): 41-63 µs per function run
subList clear: 67-81 µs per function run

function with `repeat removeLast()`:
```private fun executeMove(move: Move) {
    with(move) {
        val sourceStack = stacks[fromStack]
        val destinationStack = stacks[toStack]

        val crates = sourceStack.takeLast(numberOfCrates)
        repeat(numberOfCrates) { sourceStack.removeLast() }
        destinationStack.addAll(crates)
    }
}```

function with `subList clear()`:
```private fun executeMove(move: Move) {
    with(move) {
        val sourceStack = stacks[fromStack]
        val destinationStack = stacks[toStack]

        val crates = sourceStack.takeLast(numberOfCrates)
        val sourceStackSize = sourceStack.size
        sourceStack.subList(sourceStackSize - numberOfCrates, sourceStackSize).clear()
        destinationStack.addAll(crates)
    }
}```

(That's part of the solution to Advent of Code 2022 day 5)

Both `sourceStack` and `destinationStack` are `ArrayDeque&lt;Char&gt;`

I also must admit, that the `repeat { removeLast() }` is a bit more readable than `subList().clear()`

ListBench.kt

I did a benchmark and it seems that for small `n`, `repeat(n) { removeLast() }` (probably due to no temporary objects) while for large `n`, `subList().clear()` is faster

Yes, I was also suspecting the temporary object creation being the overhead in my case (n is usually between 1 and 20 in my program)