Maybe this hint will be useful? https://www.codewars.com/kata/5ce399e0047a45001c853c2b/discuss#5f29266f664ae7001042a4d7

You could also find some hints in comments below, for example this one: https://www.codewars.com/kata/5ce399e0047a45001c853c2b/discuss#5f29266f664ae7001042a4d7

It depends on language, but values do not mattr much for this kata, array length is much more important and arrays can be long. Like, 100_000 elements.
Try to generate a couple of arrays with gradually increasing length, let's say 100 lements, 1000 elements, 10_000 and 100_000 elements and see if your solution can handle these.

In Python, there are 5 tests where max array length can go up to 150_000.

l2.pop(0) is potentially expensive, because it modifies the whole list by removing first element from it. It depends how exactly it is implemented, but in most obvious approach, removing first element is costly, because all elements have to be moved one step to the left to fill the resulting "hole". Solution with pop can effectively have complexity of O(n^2). OTOH, l2[i] simply reads ith value without modifying anything. It does not incur any additional cost. That's why this solution seems to be faster, its complexity is O(n).

Attempting to solve this in Kotlin and getting the time out error :(

I am not the Scala translator but the tests in Scala are less difficult than in other languages (because Scala as all languages derived from Java is rather slow at CW). I tried many solutions and several run under 10500 ms. 65 guys passed the kata so I think it is doable. If you want to use recursion think of import scala.annotation.tailrec.
Note: the only difficulty of the kata is about performance...

thanks you @hobovsky probably right

Now I look at that, I think I am wrong about timeout. I believe your recursive solution fails with stack overflow error, that's why it does not show anything in output panel.

Your solution does not pass all the tests, it times out crashes. Strange thing is, output panel does not tell you that :(

EDIT: I think my suspicion of timeout was incorrect.

In Scala, there are 75 tests and they are unfortunately running in time close to timeout, so if your solution is for some reason not close to "intended approach", you risk running out of time.

Your solution passes ~65 tests, so you are probably rather good with your general idea, unfortunately I am afraid you will have to tweak it somehow to squeeze these additional 10 test cases. You might try some approach without recursion, if you can come up with any.

I will think about raising an issue to decrease amount of test cases to allow other valid approaches.

Your solution is O(n^2), it contains a loop (implicit one, in your sum and append calls), inside of your while loop.
This kata requires O(n) solution, what means you may have more than one (implicit or explicit) loop in your solution, but not one inside of another.

Scala version is close to timeout on O(n) solutions, but consistently passes for me. With O(n^2) solution though, no chance.

Time: 6133ms Passed: 312 Failed: 0

Well, performance tester fcks up your slow solution, that's what happens ;)

Spoiler flag!

Am getting(max buffer size 1.5 Mib)

That's because you're printing too much stuff into console. Get rid of it.