codility | My solutions for exercises from codility.com

Unless you want to use matrix A for some computation which result in numbers other than 1 or 0, you can simply treat 1 and 0 like True and False:

To execute a C program its source code has to be compiled/translated by the compiler into machine code.

Machine code is just a bunch of instruction that the CPU can execute one by one, to causing the value of registers or memory locations to change. When a part of these execution should handover a value to another section, that gets executed subsequent, it has to pass these value via a register. But when the "return value register" is not set, i may contain some random value of a prior instruction result. Your CPU does not care about missing hand-overs between two code sections, because it does only care about executing instruction one by one, without knowing what the larger logic of these instructions was ment to be.

It seams that in your case that the old value in such a register is coincidentally the same value as what which should be set/returned in/from PassingCars as a result. Probably because you have code that calculated the length of your input array and that value is used during the execution often, which is actually the correct result of the function to return.

To check this you could compile your source code into assembly code and reverse engineer it:

Writing an "imperative" loop is (almost) never the "right" solution in scala. Having to write a return is usually another indication that something is wrong.

Also, sorting the list in the beginning is inefficient. Something like this would solve this in linear time:

Any integer P, such that 0 < P < N, splits this tape into two non-empty parts

The "non-empty" is crucial here. If you would try printing both parts in the second loop you would see that in the last iteration the second part is empty.

All you need to do is skip the last iteration in you loop:

If, for example, the 3 numbers you are testing are all Integer.MAX_VALUE, they represent a valid triangle. However, your myTriangleList.get(i)+ myTriangleList.get(i+1)> myTriangleList.get(i+2) test would return false, because the addition of the first two numbers will give a negative sum, due to numeric overflow.

You can check if the sum is negative, and in that case accept the 3 numbers as a triangle:

There are situations, where the number of blocks fits the criteria but none of the blocks have their sum equaling the mid value

This doesn't matter, because check will return true and a lower mid will be checked: some lower mid will eventually be one that will equal some block's sum.

One good example is A = [2, 3, 3, 5, 4, 2, 3], K = 3: the mid value eventually get's the value 10, we can have 3 blocks [2,3,3],[5,4],[2,3] but none of them are equal 10.

After mid = 10 and check returning true, this will execute:

The comparison like that is not entirely fair because in the function where you use the Set, the Array needs to be converted to a Set first, which takes some time.

Have a look at the results below if this is ignored. I have updated the solution2 function to receive a Set and changed the while loop to a for loop - for the sake of direct comparison.

You may notice that for a small array, Set might be slower. This is trivial because the time complexity only really comes into affect for a large (significant) n.

Also note, Array.includes is indeed O(n) but because it is in a for loop which in the worst case could go up to n the solution has a time complexity of O(n^2).

Try this:

According to the task, "if you take K flags, then the distance between any two flags should be greater than or equal to K." So for the covering distance, D, the minimal distance between any two flags is K. To maximise the number of flags, we use the minimal distance between them: