is there a function which allows to remove last `n` elements from a MutableList? I.e. equivalent of ...

# getting-started

[Lukasz Kalnik]

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)

[CLOVIS]

repeat(4) { list.removeLast() }

?

[Sam]

It might be more efficient with a sublist:

fun MutableList<*>.removeLast(n: Int) {
    subList(size - n, size).clear()
}

[CLOVIS]

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

[ephemient]

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

[ephemient]

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

[Lukasz Kalnik]

Thanks for your answers!

[CLOVIS]

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

[ephemient]

you can't call removeRange because it is protected

[CLOVIS]

Oh :/

[Lukasz Kalnik]

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

[ephemient]

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

[Lukasz Kalnik]

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

[Lukasz Kalnik]

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

[Lukasz Kalnik]

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

[Lukasz Kalnik]

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

[Lukasz Kalnik]

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

[Lukasz Kalnik]

Both sourceStack and destinationStack are ArrayDeque<Char>

[Lukasz Kalnik]

Which implements AbstractMutableList

[Lukasz Kalnik]

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

[ephemient]

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

ListBench.kt

[Lukasz Kalnik]

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)

[Lukasz Kalnik]

Thanks for checking!