You can use java classes in kotlin, see how i use java's tokenizer in kotlin link

All contestants who solved at least one task will have a chance to win a t-shirt.

This is advertised in other sites as well, so it is possible that some Kotlin developers registered just for this. Let's hope, that there aren't many people who will "compete" with multiple accounts...

But not java :(

We have another set of tasks, so everyone is welcome to join. T-shirts are in the same series, but not the same.

IntArray maps to Java's int[], and IntArray.sort() maps to Java's Array.sort(), so yes, it does use the unfortunately hack-vulnerable quicksort. Better to use Array<Int> or MutableList<Int> for sortings. (Same goes for LongArray and DoubleArray.) Kotlin also supports List<T>.sorted() for read-only lists, which will return a new list with the sorting applied.

IntArray.sort() is the same as Arrays.sort(). Java uses quick sort for array of primitive types, and merge sort for array of objects. As we all know quick sort runs in O(N^2) in the worst case when the array is sorted or almost sorted. I guess that's the reason why you get TLE. Try writing your own version of merge sort that sorts primitive types.

Pure coincidence.

Something like this, off the top of my head:

val mp = mutableMapOf<Int, Int>()
mp[2] = 3
mp[2] = mp[2]!! - 1 // !! is non-null assertion operator, will throw exception if value is null;
                    // but we know it can't be null here as we just set it
if((mp[2]?:0) > 0) println("yes") // ?: is null-coalescing operator
else println("no")

Kotlin can be slightly annoying with nullability checking when dealing with maps, since the behavior is to return null when the key doesn't exist. Usually, with variables, a feature called "smart-casting" will handle it within an if-block that tests for nullability, but, with maps, the compiler can't guarantee that successive invocations to Map.get() did not change its value.

BTW, if anyone was wondering you can just type the problem name into google and get the actual problem.

Quick sort can be $$$O(n^2)$$$ , make sure you use Kotlin's sorting algorithms. For example, after reading the variables into array,or list $$$a$$$, use $$$a.sorted()$$$ to get a sorted copy of it.

Lol. How many times have greens and grays run into this problem? For your own good, learn some Computer Science and read the documentation of programming libraries before you use them. Competitive Programming may be a fun sport. But it kinda teaches people bad habits here and there, like treating stuff you don’t understand/don’t wish to understand as a black box. Now that’s BAD. If you really want to be good, you need to study some formal academic material in detail and not blindly use code/algorithms which you don’t understand (spoiler: CP sites are BAD for learning specific domains (like math or algos) because they are not formal academic websites and some smarty pants who write tutorials think that everything is trivial. So they omit important details and assumptions and leave everything as exercise to the reader.)

Int? is a class similar to java.lang.Integer whereas Int corresponds to primitive type int. So you get an indirection for Int? but not for Int.

It's unrated due to the Kotlin-only restriction.

Yes, it is unrated.

What part of it is slow?

I am waiting for the day when "CUSTOM INVOCATION" button will outperform all these slow IDEs))

Buy a modern computer

So, I guess part of the problem was the fact that code files for all problems were in the same module, thus it has to compile multiple files module. When I made one module per project it started to be a bit faster.

In Episode 1 https://codeforces.com/blog/entry/67162?#comment-514253

#include "testlib.h"
#include <iostream>

using namespace std;

int main(int argc, char *argv[]) {
    int seed = atoi(argv[1]);
    int len = atoi(argv[2]);
    int nwinners = 50;
    rnd.setSeed(seed);
    
    set<int> winners;
    while (winners.size() < nwinners)
        winners.insert(50 + rnd.next(1, len));
    
    for (auto winner: winners)
        cout << winner << " ";
    cout << endl;
}

Here first argument will be 300 and second argument will be 496. (penalty of winner as seed and total participants except first 50).

Assuming 300 = penalty and 546 = total participants, winners are

52 60 62 69 99 101 113 119 127 130 135 138 159 170 173 178 179 187 193 200 209 215 221 235 264 269 281 296 298 303 341 343 347 354 370 384 387 390 410 415 424 430 454 464 468 469 508 517 529 545

a

When loading the page, I am at 112th place. After several page updates, I am at 113th place. T-shirt gets a competitor in 113th place. Can I get a small T-shirt? :)

How do we know more about getting the shirt?

I mean, where do we put our ship-address?

I filled in a form with all the needed information as soon as I got the notification. Time passed, I forgot to double-check on this website but it turns out that 2 weeks after that there was a yet-another urgent question regarding my T-shirt size because T-Shirt sizes differ by a whole lot of 5cm from what I specified. This form is no longer available and I guess this is the reason why I'll get no T-shirt. Not that I needed it or anything, but this situation is absurd.

See this: https://discuss.kotlinlang.org/t/is-the-main-function-must-be-a-standalone-function/877

TLDR: Kotlin doesn't natively support static functions in classes, thus the easiest way to define a static function, as the main function is required to be, is to put it in the top level of the file, outside any class declarations. (To the JVM, this is treated as a static function within a static wrapper class called e.g. "ContestKt" if your filename is "contest.kt") There is a way to expose a class function as static to the JVM, but it's kinda ugly, looking something like:

class Solution {
    companion object {
        @JvmStatic fun main(args: Array<String>) {
            // code goes here
        }
    }
}

I won't recommend doing this for anything beyond academic purposes.

No, and we're really sorry about that. T-shirts are still on production stage. :(