Test results - Codility

Code: 16:18:17 UTC, java, autosave

1 2 3 4 5 6 7 8 9 10 11

// you can also use imports, for example:
// import java.util.*;

// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");

class Solution {
    public int solution(int[] A) {
        // write your code in Java SE 8
    }
}

Code: 16:18:20 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9

// you can use includes, for example:
// #include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)
}

Code: 16:18:24 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55

void sort_Arr(int* arr){
    for(int i = 0; i < 2; i++)
        if(arr[i] > arr[i + 1])
            arr[i] ^= arr[i + 1] ^= arr[i] ^= arr[i + 1];
    
    if(arr[0] > arr[1])
        arr[0] ^= arr[1] ^= arr[0] ^= arr[1];
}

int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)
    int arr[3] = {A.at(0), A.at(1), A.at(2)};
    int M_min = A.at(0), M_max = A.at(1);
    int count = 0;
    
    if(A.size() == 3)
        return A.at(0) * A.at(1) * A.at(2);
    else
        sort_Arr(arr);
    
    if(M_max > M_min)
        M_min ^= M_max ^= M_min ^= M_max; 
        
    if(M_min > A.at(2))
        M_min = A.at(2);
    
    if(M_max > M_min)
        M_min ^= M_max ^= M_min ^= M_max; 
        

    for(int i = 3; i < A.size(); i++){
        if(arr[0] < A.at(i)){
            arr[0] = A.at(i);
            sort_Arr(arr);
        }

        if(M_min > A.at(i)){
            M_min = A.at(i);

            if(M_min < M_max)
                M_min ^= M_max ^= M_min ^= M_max;
        }
    }

    for(int i = 0; i < A.size(); i++)
        if(A.at(i) < 0)
            count++;
    
        
    
    if(M_min * M_max > arr[0] * arr[1] && count == A.size())
        return M_min * M_max * arr[2];
    else
        return arr[0] * arr[1] * arr[2];
}

Code: 16:18:45 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55

void sort_Arr(int* arr){
    for(int i = 0; i < 2; i++)
        if(arr[i] > arr[i + 1])
            arr[i] ^= arr[i + 1] ^= arr[i] ^= arr[i + 1];
    
    if(arr[0] > arr[1])
        arr[0] ^= arr[1] ^= arr[0] ^= arr[1];
}

int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)
    int arr[3] = {A.at(0), A.at(1), A.at(2)};
    int M_min = A.at(0), M_max = A.at(1);
    int count = 0;
    
    if(A.size() == 3)
        return A.at(0) * A.at(1) * A.at(2);
    else
        sort_Arr(arr);
    
    if(M_max > M_min)
        M_min ^= M_max ^= M_min ^= M_max; 
        
    if(M_min > A.at(2))
        M_min = A.at(2);
    
    if(M_max > M_min)
        M_min ^= M_max ^= M_min ^= M_max; 
        

    for(int i = 3; i < A.size(); i++){
        if(arr[0] < A.at(i)){
            arr[0] = A.at(i);
            sort_Arr(arr);
        }

        if(M_min > A.at(i)){
            M_min = A.at(i);

            if(M_min < M_max)
                M_min ^= M_max ^= M_min ^= M_max;
        }
    }

    for(int i = 0; i < A.size(); i++)
        if(A.at(i) < 0)
            count++;
    
        
    
    if(M_min * M_max > arr[0] * arr[1])
        return M_min * M_max * arr[2];
    else
        return arr[0] * arr[1] * arr[2];
}

Code: 16:19:15 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56

void sort_Arr(int* arr){
    for(int i = 0; i < 2; i++)
        if(arr[i] > arr[i + 1])
            arr[i] ^= arr[i + 1] ^= arr[i] ^= arr[i + 1];
    
    if(arr[0] > arr[1])
        arr[0] ^= arr[1] ^= arr[0] ^= arr[1];
}

int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)
    int arr[3] = {A.at(0), A.at(1), A.at(2)};
    int M_min = A.at(0), M_max = A.at(1);
    int count = 0;
    
    if(A.size() == 3)
        return A.at(0) * A.at(1) * A.at(2);
    else
        sort_Arr(arr);
    
    if(M_max > M_min)
        M_min ^= M_max ^= M_min ^= M_max; 
        
    if(M_min > A.at(2))
        M_min = A.at(2);
    
    if(M_max > M_min)
        M_min ^= M_max ^= M_min ^= M_max; 
        

    for(int i = 3; i < A.size(); i++){
        if(arr[0] < A.at(i)){
            arr[0] = A.at(i);
            sort_Arr(arr);
        }

        if(M_min > A.at(i)){
            M_min = A.at(i);

            if(M_min < M_max)
                M_min ^= M_max ^= M_min ^= M_max;
        }
    }

    for(int i = 0; i < A.size(); i++)
        if(A.at(i) < 0)
            count++;
    
        
    
    if(M_min * M_max > arr[0] * arr[1])
        if(count == A.size())
        return M_min * M_max * arr[2];
    else
        return arr[0] * arr[1] * arr[2];
}

Code: 16:19:34 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58

void sort_Arr(int* arr){
    for(int i = 0; i < 2; i++)
        if(arr[i] > arr[i + 1])
            arr[i] ^= arr[i + 1] ^= arr[i] ^= arr[i + 1];
    
    if(arr[0] > arr[1])
        arr[0] ^= arr[1] ^= arr[0] ^= arr[1];
}

int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)
    int arr[3] = {A.at(0), A.at(1), A.at(2)};
    int M_min = A.at(0), M_max = A.at(1);
    int count = 0;
    
    if(A.size() == 3)
        return A.at(0) * A.at(1) * A.at(2);
    else
        sort_Arr(arr);
    
    if(M_max > M_min)
        M_min ^= M_max ^= M_min ^= M_max; 
        
    if(M_min > A.at(2))
        M_min = A.at(2);
    
    if(M_max > M_min)
        M_min ^= M_max ^= M_min ^= M_max; 
        

    for(int i = 3; i < A.size(); i++){
        if(arr[0] < A.at(i)){
            arr[0] = A.at(i);
            sort_Arr(arr);
        }

        if(M_min > A.at(i)){
            M_min = A.at(i);

            if(M_min < M_max)
                M_min ^= M_max ^= M_min ^= M_max;
        }
    }

    for(int i = 0; i < A.size(); i++)
        if(A.at(i) < 0)
            count++;
    
        
    
    if(M_min * M_max > arr[0] * arr[1])
        if(count == A.size())
            return arr[0] * arr[1] * arr[2];

            return M_min * M_max * arr[2];
    else
        return arr[0] * arr[1] * arr[2];
}

Code: 16:19:40 UTC, cpp, verify, result: Passed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58

void sort_Arr(int* arr){
    for(int i = 0; i < 2; i++)
        if(arr[i] > arr[i + 1])
            arr[i] ^= arr[i + 1] ^= arr[i] ^= arr[i + 1];
    
    if(arr[0] > arr[1])
        arr[0] ^= arr[1] ^= arr[0] ^= arr[1];
}

int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)
    int arr[3] = {A.at(0), A.at(1), A.at(2)};
    int M_min = A.at(0), M_max = A.at(1);
    int count = 0;
    
    if(A.size() == 3)
        return A.at(0) * A.at(1) * A.at(2);
    else
        sort_Arr(arr);
    
    if(M_max > M_min)
        M_min ^= M_max ^= M_min ^= M_max; 
        
    if(M_min > A.at(2))
        M_min = A.at(2);
    
    if(M_max > M_min)
        M_min ^= M_max ^= M_min ^= M_max; 
        

    for(int i = 3; i < A.size(); i++){
        if(arr[0] < A.at(i)){
            arr[0] = A.at(i);
            sort_Arr(arr);
        }

        if(M_min > A.at(i)){
            M_min = A.at(i);

            if(M_min < M_max)
                M_min ^= M_max ^= M_min ^= M_max;
        }
    }

    for(int i = 0; i < A.size(); i++)
        if(A.at(i) < 0)
            count++;
    
        
    
    if(M_min * M_max > arr[0] * arr[1])
        if(count == A.size())
            return arr[0] * arr[1] * arr[2];
        else
            return M_min * M_max * arr[2];
    else
        return arr[0] * arr[1] * arr[2];
}

Analysis

▶

example
example test

✔

OK

Code: 16:19:46 UTC, cpp, verify, result: Passed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58

void sort_Arr(int* arr){
    for(int i = 0; i < 2; i++)
        if(arr[i] > arr[i + 1])
            arr[i] ^= arr[i + 1] ^= arr[i] ^= arr[i + 1];
    
    if(arr[0] > arr[1])
        arr[0] ^= arr[1] ^= arr[0] ^= arr[1];
}

int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)
    int arr[3] = {A.at(0), A.at(1), A.at(2)};
    int M_min = A.at(0), M_max = A.at(1);
    int count = 0;
    
    if(A.size() == 3)
        return A.at(0) * A.at(1) * A.at(2);
    else
        sort_Arr(arr);
    
    if(M_max > M_min)
        M_min ^= M_max ^= M_min ^= M_max; 
        
    if(M_min > A.at(2))
        M_min = A.at(2);
    
    if(M_max > M_min)
        M_min ^= M_max ^= M_min ^= M_max; 
        

    for(int i = 3; i < A.size(); i++){
        if(arr[0] < A.at(i)){
            arr[0] = A.at(i);
            sort_Arr(arr);
        }

        if(M_min > A.at(i)){
            M_min = A.at(i);

            if(M_min < M_max)
                M_min ^= M_max ^= M_min ^= M_max;
        }
    }

    for(int i = 0; i < A.size(); i++)
        if(A.at(i) < 0)
            count++;
    
        
    
    if(M_min * M_max > arr[0] * arr[1])
        if(count == A.size())
            return arr[0] * arr[1] * arr[2];
        else
            return M_min * M_max * arr[2];
    else
        return arr[0] * arr[1] * arr[2];
}

Analysis

▶

example
example test

✔

OK

Code: 16:19:49 UTC, cpp, final, score: 100

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58

void sort_Arr(int* arr){
    for(int i = 0; i < 2; i++)
        if(arr[i] > arr[i + 1])
            arr[i] ^= arr[i + 1] ^= arr[i] ^= arr[i + 1];
    
    if(arr[0] > arr[1])
        arr[0] ^= arr[1] ^= arr[0] ^= arr[1];
}

int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)
    int arr[3] = {A.at(0), A.at(1), A.at(2)};
    int M_min = A.at(0), M_max = A.at(1);
    int count = 0;
    
    if(A.size() == 3)
        return A.at(0) * A.at(1) * A.at(2);
    else
        sort_Arr(arr);
    
    if(M_max > M_min)
        M_min ^= M_max ^= M_min ^= M_max; 
        
    if(M_min > A.at(2))
        M_min = A.at(2);
    
    if(M_max > M_min)
        M_min ^= M_max ^= M_min ^= M_max; 
        

    for(int i = 3; i < A.size(); i++){
        if(arr[0] < A.at(i)){
            arr[0] = A.at(i);
            sort_Arr(arr);
        }

        if(M_min > A.at(i)){
            M_min = A.at(i);

            if(M_min < M_max)
                M_min ^= M_max ^= M_min ^= M_max;
        }
    }

    for(int i = 0; i < A.size(); i++)
        if(A.at(i) < 0)
            count++;
    
        
    
    if(M_min * M_max > arr[0] * arr[1])
        if(count == A.size())
            return arr[0] * arr[1] * arr[2];
        else
            return M_min * M_max * arr[2];
    else
        return arr[0] * arr[1] * arr[2];
}

Analysis summary

The solution obtained perfect score.

Analysis

Detected time complexity:

O(N * log(N))

▶

example
example test

✔

OK

▶

one_triple
three elements

✔

OK

▶

simple1
simple tests

✔

OK

▶

simple2
simple tests

✔

OK

▶

small_random
random small, length = 100

✔

OK

▶

medium_range
-1000, -999, ... 1000, length = ~1,000

✔

OK

▶

medium_random
random medium, length = ~10,000

✔

OK

▶

large_random
random large, length = ~100,000

✔

OK

▶

large_range
2000 * (-10..10) + [-1000, 500, -1]

✔

OK

▶

extreme_large
(-2, .., -2, 1, .., 1) and (MAX_INT)..(MAX_INT), length = ~100,000

✔

OK