Test results - Codility

Code: 16:55:01 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) {
        // Implement your solution here
    }
}

Code: 16:55:11 UTC, swift4, autosave

1 2 3 4 5 6 7 8 9

import Foundation
import Glibc

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

public func solution(_ A : inout [Int]) -> Int {
    // Implement your solution here
}

Code: 16:55:59 UTC, swift4, 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

import Foundation
import Glibc

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

public func solution(_ A : inout [Int]) -> Int {
    A = A.sorted()
    A = A.filter({ $0 >= 1 })
    
    if A.isEmpty { return 1 }
    
    var preInteger = 0
    
    for i in A {
        if i - preInteger > 1 {
            return preInteger + 1
        } else {
            preInteger = i
        }
    }
    
    return Set(A).count + 1
}

Code: 16:56:00 UTC, swift4, 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

import Foundation
import Glibc

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

public func solution(_ A : inout [Int]) -> Int {
    A = A.sorted()
    A = A.filter({ $0 >= 1 })
    
    if A.isEmpty { return 1 }
    
    var preInteger = 0
    
    for i in A {
        if i - preInteger > 1 {
            return preInteger + 1
        } else {
            preInteger = i
        }
    }
    
    return Set(A).count + 1
}

Analysis

▶

example1
first example test

✔

OK

▶

example2
second example test

✔

OK

▶

example3
third example test

✔

OK

Code: 16:56:33 UTC, swift4, 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

import Foundation
import Glibc

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

public func solution(_ A : inout [Int]) -> Int {
    A = A.sorted()
    A = A.filter({ $0 >= 1 })
    
    if A.isEmpty { return 1 }
    
    var preInteger = 0
    
    for i in A {
        if i - preInteger > 1 {
            return preInteger + 1
        } else {
            preInteger = i
        }
    }
    
    return Set(A).count + 1
}

Analysis

▶

example1
first example test

✔

OK

▶

example2
second example test

✔

OK

▶

example3
third example test

✔

OK

Code: 16:56:43 UTC, swift4, 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

import Foundation
import Glibc

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

public func solution(_ A : inout [Int]) -> Int {
    A = A.sorted()
    A = A.filter({ $0 >= 1 })
    
    if A.isEmpty { return 1 }
    
    var preInteger = 0
    
    for i in A {
        if i - preInteger > 1 {
            return preInteger + 1
        } else {
            preInteger = i
        }
    }
    
    return Set(A).count + 1
}

Analysis summary

The solution obtained perfect score.

Analysis

Detected time complexity:

O(N) or O(N * log(N))

▶

example1
first example test

✔

OK

▶

example2
second example test

✔

OK

▶

example3
third example test

✔

OK

▶

extreme_single
a single element

✔

OK

▶

simple
simple test

✔

OK

▶

extreme_min_max_value
minimal and maximal values

✔

OK

▶

positive_only
shuffled sequence of 0...100 and then 102...200

✔

OK

▶

negative_only
shuffled sequence -100 ... -1

✔

OK

▶

medium
chaotic sequences length=10005 (with minus)

✔

OK

▶

large_1
chaotic + sequence 1, 2, ..., 40000 (without minus)

✔

OK

▶

large_2
shuffled sequence 1, 2, ..., 100000 (without minus)

✔

OK

▶

large_3
chaotic + many -1, 1, 2, 3 (with minus)

✔

OK