我为这个hackerrank测试编写的代码有效，但资源太多，现在我没有想法了。 我究竟做错了什么？

Question

New Year Chaos Problem: Hackerrank

This is the program I wrote and it tells me that my code didn't finish in time (and that I need to optimize it for it to finish in less time). I have tried everything I could and I am out of ideas, what should I do?

fun minimumBribes(q: Array<Int>) {
    var bribeCount = 0
    for ((i, x) in q.withIndex()) {

        val last = q.lastIndex - i + 1
        val first = i + 1


        // Checks if any of the elements have more than 2 elements smaller than them behind them in the queue and returns out of the function if so (because no element can bribe more than 2 elements)
        // Drops all the elements in the queue before x and counts the number of smaller elements after x in the queue
        if (q.drop(first).count { it < x } > 2) {
            println("Too chaotic")
            return
        }

        // Adds the number of elements bigger than x that are in the queue standing ahead of x to bribeCount (since the number of bribes taken by all elements will be equal to the total number of bribes given in total and no element can get past ahead of a smaller element without bribing it)
        bribeCount += q.dropLast(last).count { it > x }

    }
    println(bribeCount)
}

Read the problem first linked at the top of the page. You probably won't understand anything below this line before reading the problem statement.

As you can see, to check the number of people that have bribed an element, I count the number of elements that have a bigger value from that element and are standing before it in the queue. By summing the number of bribes each element has recieved, we can count the number of bribes given in total. But before that, I calculate the number of elements smaller than an elements standing after it in the queue and if that number is greater than 2, it means said element has bribed more than 2 people which is "Too chaotic" and I return.

And this is the error message I get: Screenshot

Answer 1

The problem with your code is that it uses too many loops.

1. Both Array.drop(Int) and Array.dropLast(Int) use a loop to construct a List , which they return.
2. Iterable<T>.count((T) -> Boolean) uses a loop to count the number of times the condition specified is true.

To optimize your code, drop these extension functions that use loop.

fun minimumBribes(queue: Array<Int>): Unit {
    var bribeCount = 0

    for ((index, initialPosition) in queue.withIndex()) {
        val currentPosition = index + 1

        if ((initialPosition - currentPosition) > 2) {
            println("Too chaotic")
            return
        }

        val startingCheckIndex = max(0, initialPosition - 2)

        for (checkIndex in startingCheckIndex until index) {
            val hasBribed = queue[checkIndex] > initialPosition
            if (hasBribed) bribeCount++
        }
    }

    println(bribeCount)
}

Clarification:

For each number in the queue:

1: We check how far a person has moved up in the queue ie initialPosition - currentPosition . If he/she has moved up more than 2 positions then we print "Too chaotic" and return control because it is not possible for the person to bribe more than 2 people ahead of him/her.

For example, if the person's sticker says 6 and his current position is 3 then the person has moved up 3 positions, which is not possible.

2: You mentioned in the question, I count the number of elements that have a bigger value from that element and are standing before it in the queue .

This is correct as we are counting how many bribes a person has taken but we cannot check right up to the first position. As a person that bribes another person can only move one position ahead of him, we will only check up to 1 position ahead of the initial position of the person. I have called the index for this position startingCheckIndex in my code.

For example: If the person's sticker says 5 and the current position is 10. then we will check only from position 4 up to 10.

Note that I have used max(0, initialPosition - 2) .
-2 because the array index starts from 0 and initialPosition starts from 1.
max(0,..) because for initialPosition 1, 1 - 2 = -1 so we need to maintain minimum value of 0.