closing

200

How many random test are there?

because you time out on the next section of tests, which doesn't print anything before the timeout? (edit: looks like there are only 2 groups, so dunno)

Thanks, I know this. The question was: Why the execution completion is printed out to be 8987ms and there is timeout despite the limit of 16000ms
Anyway as I wrote, I've managed to pass the tests on next execution
Thank you for your reply :)

Typically when you are printing some large lists or arrays / when you have an inefficient algorithm or infinite loop, the timeout will occur.

Ok. I see, the variables are case insensitive as the keywords...
It's noted in the description I see, I've missed it, my bad.

There is a problem with language grammar (on Kotlin at least):

For instance in this test [ FixedTest 0 | Basic 1 | Works for set, inc, dec ] the a argument at line 3 suppose to be a VarName (@see lexical syntax) so this test must fail since there is no such variable defined

1:  var A B
2:  sEt A 'a'
3:  msg a B //should be - msg 'a' B
4:  set B 50
5:  msG A b
6:  inc A 10
7:  dec B -20
8:  msg A B

In case there is an exception for [msg] keyword, then the output must be a\u00abkF and not a\u0000a2kF (@see line 5)

I've managed to pass the timeout by executing several times afterwards. But the question remains - what eactly 16000 msec timeout includes?

How come?

I can give you my logs for that test cse, hope it helps

  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
0| 1  2  ·  ·  ·  ·  ·  ·  ·Z18
1| 3  S  ·  ·  ·  ·  ·  ·  ·  ·
2| 2  S  ·  ·  ·  ·  ·  ·  ·  ·
3| 1  S  ·  ·  ·  ·  ·  ·  ·  ·
4| 2  ·  ·  ·  ·  ·  ·  ·  ·  ·
5| 3  ·  ·  ·  ·  ·  ·  ·  ·  ·

  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
0| 1  2  ·  ·  ·  ·  ·  ·Z15  ·
1| 3  S  ·  ·  ·  ·  ·  ·  ·  ·
2| 2  S  ·  ·  ·  ·  ·  ·  ·  ·
3| 1  S  ·  ·  ·  ·  ·  ·  ·  ·
4| 2  ·  ·  ·  ·  ·  ·  ·  ·  ·
5| 3  ·  ·  ·  ·  ·  ·  ·  ·  ·

  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
0| 1  2  ·  ·  ·  ·  ·Z12  ·  ·
1| 3  S  ·  ·  ·  ·  ·  ·  ·  ·
2| 2  S  ·  ·  ·  ·  ·  ·  ·  ·
3| 1  S  ·  ·  ·  ·  ·  ·  ·Z12
4| 2  ·  ·  ·  ·  ·  ·  ·  ·  ·
5| 3  ·  ·  ·  ·  ·  ·  ·  ·Z25

  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
0| 1  2  ·  ·  ·  · Z9  ·  ·  ·
1| 3  S  ·  ·  ·  ·  ·  ·  ·  ·
2| 2  S  ·  ·  ·  ·  ·  ·  ·  ·
3| 1  S  ·  ·  ·  ·  ·  ·Z10  ·
4| 2  ·  ·  ·  ·  ·  ·  ·  ·  ·
5| 3  ·  ·  ·  ·  ·  ·  ·Z22  ·

  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
0| 1  2  ·  ·  · Z6  ·  ·  ·  ·
1| 3  S  ·  ·  ·  ·  ·  ·  ·  ·
2| 2  S  ·  ·  ·  ·  ·  ·  ·Z21
3| 1  S  ·  ·  ·  ·  · Z8  ·  ·
4| 2  ·  ·  ·  ·  ·  ·  ·  ·  ·
5| 3  ·  ·  ·  ·  ·  ·Z19  ·  ·

  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
0| 1  2  ·  · Z3  ·  ·  ·  ·  ·
1| 3  S  ·  ·  ·  ·  ·  ·  ·  ·
2| 2  S  ·  ·  ·  ·  ·  ·Z18  ·
3| 1  S  ·  ·  ·  · Z6  ·  ·  ·
4| 2  ·  ·  ·  ·  ·  ·  ·  ·  ·
5| 3  ·  ·  ·  ·  ·Z16  ·  ·  ·

  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
0| 1  2  ·  ·  ·  ·  ·  ·  ·  ·
1| 3  S  ·  ·  ·  ·  ·  ·  ·Z35
2| 2  S  ·  ·  ·  ·  ·Z15  ·  ·
3| 1  S  ·  ·  · Z4  ·  ·  ·  ·
4| 2  ·  ·  ·  ·  ·  ·  ·  · Z9
5| 3  ·  ·  ·  ·Z13  ·  ·  ·  ·

  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
0| 1  2  ·  ·  ·  ·  ·  ·  ·  ·
1| 3  S  ·  ·  ·  ·  ·  ·Z31  ·
2| 2  S  ·  ·  ·  ·Z12  ·  ·  ·
3| 1  S  ·  · Z2  ·  ·  ·  ·  ·
4| 2  ·  ·  ·  ·  ·  ·  · Z7  ·
5| 3  ·  ·  · Z9  ·  ·  ·  ·  ·

  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
0| 1  2  ·  ·  ·  ·  ·  ·  ·Z22
1| 3  S  ·  ·  ·  ·  ·Z27  · Z8
2| 2  S  ·  ·  · Z9  ·  ·  ·Z17
3| 1  S  ·  ·  ·  ·  ·  ·  ·  ·
4| 2  ·  ·  ·  ·  ·  · Z5  ·  ·
5| 3  ·  · Z5  ·  ·  ·  ·  ·  ·

  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
0| 1  2  ·  ·  ·  ·  ·  ·Z19  ·
1| 3  S  ·  ·  ·  ·Z23  · Z8  ·
2| 2  S  ·  · Z6  ·  ·  ·Z17  ·
3| 1  S  ·  ·  ·  ·  ·  ·  ·  ·
4| 2  ·  ·  ·  ·  · Z3  ·  ·  ·
5| 3  · Z1  ·  ·  ·  ·  ·  ·  ·

  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
0| 1  2  ·  ·  ·  ·  ·Z16  ·  ·
1| 3  S  ·  ·  ·Z19  · Z8  ·  ·
2| 2  S  · Z3  ·  ·  ·Z17  ·  ·
3| 1  S  ·  ·  ·  ·  ·  ·  ·Z18
4| 2  ·  ·  ·  · Z1  ·  ·  ·  ·
5| 3  ·  ·  ·  ·  ·  ·  ·  ·  ·

  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
0| 1  2  ·  ·  ·  ·Z13  ·  ·Z15
1| 3  S  ·  ·Z15  · Z8  ·  ·  ·
2| 2  S  ·  ·  ·  ·Z17  ·  ·  ·
3| 1  S  ·  ·  ·  ·  ·  ·Z16  ·
4| 2  ·  ·  ·  ·  ·  ·  ·  ·  ·
5| 3  ·  ·  ·  ·  ·  ·  ·  ·  ·

  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
0| 1  2  ·  ·  ·Z10  ·  ·Z15  ·
1| 3  S  ·Z11  · Z8  ·  ·  ·  ·
2| 2  S  ·  ·  ·Z14  ·  ·  ·  ·
3| 1  S  ·  ·  ·  ·  ·Z14  ·  ·
4| 2  ·  ·  ·  ·  ·  ·  ·  ·Z21
5| 3  ·  ·  ·  ·  ·  ·  ·  ·  ·

  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
0| 1  2  ·  · Z7  ·  ·Z15  ·  ·
1| 3  S Z6  · Z8  ·  ·  ·  ·  ·
2| 2  S  ·  ·Z11  ·  ·  ·  ·  ·
3| 1  S  ·  ·  ·  ·Z12  ·  ·  ·
4| 2  ·  ·  ·  ·  ·  ·  ·Z19  ·
5| 3  ·  ·  ·  ·  ·  ·  ·  ·  ·

  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
0| 1  2  · Z3  ·  ·Z15  ·  ·  ·
1| 3 Z1  · Z8  ·  ·  ·  ·  ·  ·
2| 2  S  · Z8  ·  ·  ·  ·  ·  ·
3| 1  S  ·  ·  ·Z10  ·  ·  ·  ·
4| 2  ·  ·  ·  ·  ·  ·Z17  ·  ·
5| 3  ·  ·  ·  ·  ·  ·  ·  ·  ·

  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
0| 1  2  ·  ·  ·Z15  ·  ·  ·  ·
1| 3  x Z5  ·  ·  ·  ·  ·  ·  ·
2| 2  S Z5  ·  ·  ·  ·  ·  ·  ·
3| 1  S  ·  · Z8  ·  ·  ·  ·  ·
4| 2  ·  ·  ·  ·  ·Z15  ·  ·  ·
5| 3  ·  ·  ·  ·  ·  ·  ·  ·  ·

  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
0| 1  2  ·  ·Z12  ·  ·  ·  ·  ·
1| 3 Z1  ·  ·  ·  ·  ·  ·  ·  ·
2| 2 Z1  ·  ·  ·  ·  ·  ·  ·  ·
3| 1  S  · Z6  ·  ·  ·  ·  ·  ·
4| 2  ·  ·  ·  ·Z13  ·  ·  ·  ·
5| 3  ·  ·  ·  ·  ·  ·  ·  ·  ·

  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
0| 1  2  · Z8  ·  ·  ·  ·  ·  ·
1| 3  x  ·  ·  ·  ·  ·  ·  ·  ·
2| 2  x  ·  ·  ·  ·  ·  ·  ·  ·
3| 1  S Z4  ·  ·  ·  ·  ·  ·  ·
4| 2  ·  ·  ·Z11  ·  ·  ·  ·  ·
5| 3  ·  ·  ·  ·  ·  ·  ·  ·  ·

  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
0| 1  2 Z5  ·  ·  ·  ·  ·  ·  ·
1| 3  x  ·  ·  ·  ·  ·  ·  ·  ·
2| 2  x  ·  ·  ·  ·  ·  ·  ·  ·
3| 1 Z2  ·  ·  ·  ·  ·  ·  ·  ·
4| 2  ·  · Z9  ·  ·  ·  ·  ·  ·
5| 3  ·  ·  ·  ·  ·  ·  ·  ·  ·

  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
0| 1 Z2  ·  ·  ·  ·  ·  ·  ·  ·
1| 3  x  ·  ·  ·  ·  ·  ·  ·  ·
2| 2  x  ·  ·  ·  ·  ·  ·  ·  ·
3|Z1  x  ·  ·  ·  ·  ·  ·  ·  ·
4| 2  · Z7  ·  ·  ·  ·  ·  ·  ·
5| 3  ·  ·  ·  ·  ·  ·  ·  ·  ·

Just did it on kotlin everything is correct.

Many thanks to @docgunthrop for the kata and especially that he/she puts an examples of explicit test cases in description otherwise debugging would be frustrating

Hello everyone. Many thanks to @KenKamau for this kata.
The major difficulty of this kata is debugging, the numbers become enormous very swiftly that you are unable to follow them.
So, my advice is: writhe a brute force solution execute them in paralel for comperasion with optimized one, use random numbers for debugging purpuses

No, the solution is straight forward without any special tricks. Only optimization needed.