Test results - Codility

Tasks Details

easy

1. PassingCars

Count the number of passing cars on the road.

Task Score

50%

Correctness

100%

Performance

A non-empty array A consisting of N integers is given. The consecutive elements of array A represent consecutive cars on a road.

Array A contains only 0s and/or 1s:

0 represents a car traveling east,

1 represents a car traveling west.

The goal is to count passing cars. We say that a pair of cars (P, Q), where 0 ≤ P < Q < N, is passing when P is traveling to the east and Q is traveling to the west.

For example, consider array A such that:

A[0] = 0 A[1] = 1 A[2] = 0 A[3] = 1 A[4] = 1

We have five pairs of passing cars: (0, 1), (0, 3), (0, 4), (2, 3), (2, 4).

Write a function:

class Solution { public int solution(int[] A); }

that, given a non-empty array A of N integers, returns the number of pairs of passing cars.

The function should return −1 if the number of pairs of passing cars exceeds 1,000,000,000.

For example, given:

A[0] = 0 A[1] = 1 A[2] = 0 A[3] = 1 A[4] = 1

the function should return 5, as explained above.

Write an efficient algorithm for the following assumptions:

N is an integer within the range [1..100,000];

each element of array A is an integer that can have one of the following values: 0, 1.

Solution

Programming language used Java 8

Time spent on task 48 minutes

Notes

not defined yet

Task timeline

Code: 15:53:05 UTC, java, autosave

show code in pop-up

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: 15:53:24 UTC, swift4, verify, result: Failed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13

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 {
    // write your code in Swift 4.2.1 (Linux)
    
    print(A)

    return 0
}

Analysis

expand all Example tests

▶

example
example test

✘

WRONG ANSWER
got 0 expected 5

0.032 s

WRONG ANSWER, got 0 expected 5

stdout:

[0, 1, 0, 1, 1]

Code: 15:53:36 UTC, swift4, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

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 {
    // write your code in Swift 4.2.1 (Linux)
    
    print(A)

    

    return 0
}

Code: 15:53:53 UTC, swift4, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

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 {
    // write your code in Swift 4.2.1 (Linux)
    
    print(A)

    for (index, _) in A.enumerated() {
        
    }

    return 0
}

Code: 15:54:03 UTC, swift4, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

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 {
    // write your code in Swift 4.2.1 (Linux)
    
    print(A)

    var arr: []
    for (index, _) in A.enumerated() {

    }

    return 0
}

Code: 15:54:17 UTC, swift4, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

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 {
    // write your code in Swift 4.2.1 (Linux)
    
    print(A)

    var arr: [Int:Int] = []
    for (index, _) in A.enumerated() {
        
    }

    return 0
}

Code: 15:54:40 UTC, swift4, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

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 {
    // write your code in Swift 4.2.1 (Linux)
    
    print(A)

    var arr: [Int:Int] = []
    for (index, _) in A.enumerated() {
        arr[index] = 
    }

    return 0
}

Code: 15:54:59 UTC, swift4, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

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 {
    // write your code in Swift 4.2.1 (Linux)
    
    print(A)

    var arr: [(Int,Int)] = []
    for (index, _) in A.enumerated() {
        arr[index] = []
    }

    return 0
}

Code: 16:30:27 UTC, swift4, autosave

show code in pop-up

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

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 {
    // write your code in Swift 4.2.1 (Linux)
    
    var arr: [(Int,Int)] = []
        
        for (index, _) in A.enumerated() {
            if A[index] == 0 {
                arr.append((A[index], 0))
                for i in index..<A.count {
                    if A[i] == 1 {
                        if arr.last?.1 == 0 {
                            arr[index] = (0, A[i])
                        } else {
                            arr.append((0, A[i]))
                        }
                        
                    }
                }
            }
        }
        
        if arr.count > 1000000000 {
            return -1
        }
        
        return arr.count
}

Code: 16:30:31 UTC, swift4, verify, result: Failed

show code in pop-up

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

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 {
    // write your code in Swift 4.2.1 (Linux)
    
    var arr: [(Int,Int)] = []
    
    for (index, _) in A.enumerated() {
        if A[index] == 0 {
            arr.append((A[index], 0))
            for i in index..<A.count {
                if A[i] == 1 {
                    if arr.last?.1 == 0 {
                        arr[index] = (0, A[i])
                    } else {
                        arr.append((0, A[i]))
                    }
                    
                }
            }
        }
    }
    
    if arr.count > 1000000000 {
        return -1
    }
    
    return arr.count
}

Analysis

expand all Example tests

▶

example
example test

✘

WRONG ANSWER
got 4 expected 5

0.028 s

WRONG ANSWER, got 4 expected 5

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

show code in pop-up

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

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 {
    // write your code in Swift 4.2.1 (Linux)
    
    var arr: [(Int,Int)] = []
        for (index, _) in A.enumerated() {
            if A[index] == 0 {
                for i in index..<A.count {
                    if A[i] == 1 {
                        arr.append((0, 1))
                    }
                }
            }
        }
        
        if arr.count > 1000000000 {
            return -1
        }
        
        return arr.count
}

Code: 16:40:15 UTC, swift4, verify, result: Passed

show code in pop-up

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

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 {
    // write your code in Swift 4.2.1 (Linux)
    
    var arr: [(Int,Int)] = []
    for (index, _) in A.enumerated() {
        if A[index] == 0 {
            for i in index..<A.count {
                if A[i] == 1 {
                    arr.append((0, 1))
                }
            }
        }
    }
    
    if arr.count > 1000000000 {
        return -1
    }
    
    return arr.count
}

Analysis

expand all Example tests

▶

example
example test

✔

0.028 s

Code: 16:40:41 UTC, swift4, verify, result: Passed

show code in pop-up

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

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 {
    // write your code in Swift 4.2.1 (Linux)
    
    var arr: [(Int,Int)] = []
    for (index, _) in A.enumerated() {
        if A[index] == 0 {
            for i in index..<A.count {
                if A[i] == 1 {
                    arr.append((0, 1))
                }
            }
        }
    }
    
    if arr.count > 1000000000 {
        return -1
    }
    
    return arr.count
}

Analysis

expand all Example tests

▶

example
example test

✔

0.032 s

Code: 16:40:48 UTC, swift4, final, score: 50

show code in pop-up

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

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 {
    // write your code in Swift 4.2.1 (Linux)
    
    var arr: [(Int,Int)] = []
    for (index, _) in A.enumerated() {
        if A[index] == 0 {
            for i in index..<A.count {
                if A[i] == 1 {
                    arr.append((0, 1))
                }
            }
        }
    }
    
    if arr.count > 1000000000 {
        return -1
    }
    
    return arr.count
}

Analysis summary

The following issues have been detected: timeout errors.

Analysis

Detected time complexity:

O(N ** 2)

expand all Example tests

▶

example
example test

✔

0.032 s

expand all Correctness tests

▶

single
single element

✔

0.028 s

▶

double
two elements

✔

0.028 s

▶

simple
simple test

✔

0.028 s

▶

small_random
random, length = 100

✔

0.028 s

▶

small_random2
random, length = 1000

✔

0.032 s

expand all Performance tests

▶

medium_random
random, length = ~10,000

✘

TIMEOUT ERROR
running time: 0.472 sec., time limit: 0.112 sec.

0.472 s

TIMEOUT ERROR, running time: 0.472 sec., time limit: 0.112 sec.

▶

large_random
random, length = ~100,000

✘

TIMEOUT ERROR
running time: 1.168 sec., time limit: 0.128 sec.

1.168 s

TIMEOUT ERROR, running time: 1.168 sec., time limit: 0.128 sec.

▶

large_big_answer
0..01..1, length = ~100,000

✘

TIMEOUT ERROR
running time: 0.852 sec., time limit: 0.128 sec.

0.852 s

TIMEOUT ERROR, running time: 0.852 sec., time limit: 0.128 sec.

0.832 s

TIMEOUT ERROR, running time: 0.832 sec., time limit: 0.128 sec.

▶

large_alternate
0101..01, length = ~100,000

✘

TIMEOUT ERROR
running time: 0.872 sec., time limit: 0.128 sec.

0.872 s

TIMEOUT ERROR, running time: 0.872 sec., time limit: 0.128 sec.

0.876 s

TIMEOUT ERROR, running time: 0.876 sec., time limit: 0.128 sec.

▶

large_extreme
large test with all 1s/0s, length = ~100,000

✘

TIMEOUT ERROR
running time: 3.288 sec., time limit: 0.128 sec.

3.288 s

TIMEOUT ERROR, running time: 3.288 sec., time limit: 0.128 sec.

0.032 s

3.288 s

TIMEOUT ERROR, running time: 3.288 sec., time limit: 0.128 sec.