Test results - Codility

Tasks Details

hard

1. Clocks

Find the maximal number of clocks with hands that look identical when rotated.

90%

Not assessed

You are given N round clocks.

Every clock has M hands, and these hands can point to positions 1, 2, 3, ..., P (yes, these represent numbers around each face). The clocks are represented by the matrix A consisting of N rows and M columns of integers. The first row represents the hands of the first clock, and so on.

For example, you are given matrix A consisting of five rows and two columns, and P = 4:

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

You can rotate the clocks to obtain several clocks that look identical. For example, if you rotate the third, fourth and fifth clocks you can obtain the following clocks:

After rotation, the first, third and fourth clocks look the same, and the second clock looks the same as the fifth one. That means there are four pairs of clocks that look the same: (1, 3), (1, 4), (2, 5) and (3, 4).

Write a function:

function solution(A, P);

that, given a zero-indexed matrix A consisting of N rows and M columns of integers and integer P, returns the maximal number of pairs of clocks that can look the same after rotation.

For example, given the following array A and P = 4:

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

the function should return 4, as explained above.

Write an efficient algorithm for the following assumptions:

N and M are integers within the range [1..500];

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

each element of matrix A is an integer within the range [1..P];

the elements of each row of matrix A are all distinct.

Solution

Programming language used JavaScript

Time spent on task 17 minutes

Notes

not defined yet

Task timeline

Code: 03:35:06 UTC, js, 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 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78

// you can use console.log for debugging purposes, i.e.
// console.log('this is debug message');
// write your code in JavaScript (ECMA-262, 5th edition)
// compare 2 arrays - assumes they are the same length
function compareArrays( a1, a2 )
{
    for( var i=0; i<a1.length; i++)
        if( a1[i] != a2[i] ){
            console.log("compareArrays: "+a1+" ... "+a2+" =false");    
            return false;
        }
console.log("compareArrays: "+a1+" ... "+a2+" =true");    
    return true;
}

// compare newpos[] with positions[][]
// - rotates newpos[] to attempt match 
// returns: index of match or -1 if no match
//
function comparePositions(positions,newpos)
{
    for(var ipos=0; ipos<positions.length; ipos++){
        for( i=0; i<newpos.length; i++){
            if( compareArrays(positions[ipos],newpos))
                return ipos;
            newpos.push(newpos.shift());    //rotate array
        }
    }
    return -1;
}

function solution(A, P) {
    var idx,diff,halfP=P/2;
    var highestCount=0;
    var highestIndex=0;
    var positions = [];
    var counts=[];
    A.forEach(function(clock) {
        var position = [];
        // sort 'hands' in ascending order
        //clock.sort(function(a, b) { return a - b });
        // duplicate start point on end
        clock.push(clock[0]);
//console.log(clock);
        // create array of distances between hands, wrapping around clock
        for(idx=1; idx<clock.length;idx++){
            diff= Math.abs(clock[idx] - clock[idx-1]);
            position.push((diff>halfP)?P-diff:diff);
        }
//console.log(position);

        idx= comparePositions(positions,position);
        if( idx < 0 ){
            positions.push(position);   // new pattern
            counts.push(1);
        }else{
            counts[idx]++;  // count old pattern
            if( counts[idx] > highestCount){
                highestCount= counts[idx];
                highestIndex= idx;
            }
        }
    });
    
    positions.forEach(function(pos,idx){
        console.log(idx+" "+positions[idx]);
    });
//    console.log( "Count="+highestCount+" patt="+positions[highestIndex]+" Counts="+counts);

    // sum the combinations of counts for each position type
    var sum=0;
    for(idx=0; idx<counts.length; idx++){
        count=counts[idx];
        sum+= (count > 2) ? (count * (count-1))/2 : 1;
    }

    return sum;
}

Analysis

▶

example
example test

✔

Code: 03:38:31 UTC, js, 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 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73

// you can use console.log for debugging purposes, i.e.
// console.log('this is debug message');
// write your code in JavaScript (ECMA-262, 5th edition)
// compare 2 arrays - assumes they are the same length
function compareArrays( a1, a2 )
{
    for( var i=0; i<a1.length; i++)
        if( a1[i] != a2[i] ){
            console.log("compareArrays: "+a1+" ... "+a2+" =false");    
            return false;
        }
console.log("compareArrays: "+a1+" ... "+a2+" =true");    
    return true;
}

// compare newpos[] with positions[][]
// - rotates newpos[] to attempt match 
// returns: index of match or -1 if no match
//
function comparePositions(positions,newpos)
{
    for(var ipos=0; ipos<positions.length; ipos++){
        for( i=0; i<newpos.length; i++){
            if( compareArrays(positions[ipos],newpos))
                return ipos;
            newpos.push(newpos.shift());    //rotate array
        }
    }
    return -1;
}

function solution(A, P) {
    var idx,diff,halfP=P/2;
    var highestCount=0;
    var highestIndex=0;
    var positions = [];
    var counts=[];
    A.forEach(function(clock) {
        var position = [];
        // sort 'hands' in ascending order
        //clock.sort(function(a, b) { return a - b });
        // duplicate start point on end
        clock.push(clock[0]);
//console.log(clock);
        // create array of distances between hands, wrapping around clock
        for(idx=1; idx<clock.length;idx++){
            diff= Math.abs(clock[idx] - clock[idx-1]);
            position.push((diff>halfP)?P-diff:diff);
        }
//console.log(position);

        idx= comparePositions(positions,position);
        if( idx < 0 ){
            positions.push(position);   // new pattern
            counts.push(1);
        }else{
            counts[idx]++;  // count old pattern
        }
    });
    
    positions.forEach(function(pos,idx){
        console.log(idx+" "+positions[idx]);
    });

    // sum the combinations of counts for each position type
    var sum=0;
    for(idx=0; idx<counts.length; idx++){
        count=counts[idx];
        sum+= (count > 2) ? (count * (count-1))/2 : 1;
    }

    return sum;
}

Analysis

▶

example
example test

✔

▶

test_data0

✔

Code: 03:41:05 UTC, js, verify, result: Passed

// you can use console.log for debugging purposes, i.e.
// console.log('this is debug message');
// write your code in JavaScript (ECMA-262, 5th edition)
// compare 2 arrays - assumes they are the same length
function compareArrays( a1, a2 )
{
    for( var i=0; i<a1.length; i++)
        if( a1[i] != a2[i] ){
            console.log("compareArrays: "+a1+" ... "+a2+" =false");    
            return false;
        }
console.log("compareArrays: "+a1+" ... "+a2+" =true");    
    return true;
}

// compare newpos[] with positions[][]
// - rotates newpos[] to attempt match 
// returns: index of match or -1 if no match
//
function comparePositions(positions,newpos)
{
    for(var ipos=0; ipos<positions.length; ipos++){
        for( i=0; i<newpos.length; i++){
            if( compareArrays(positions[ipos],newpos))
                return ipos;
            newpos.push(newpos.shift());    //rotate array
        }
    }
    return -1;
}

function solution(A, P) {
    var idx,diff,halfP=P/2;
    var highestCount=0;
    var highestIndex=0;
    var positions = [];
    var counts=[];
    A.forEach(function(clock) {
        var position = [];
        // sort 'hands' in ascending order
        clock.sort(function(a, b) { return a - b });
        // duplicate start point on end
        clock.push(clock[0]);
//console.log(clock);
        // create array of distances between hands, wrapping around clock
        for(idx=1; idx<clock.length;idx++){
            diff= Math.abs(clock[idx] - clock[idx-1]);
            position.push((diff>halfP)?P-diff:diff);
        }
//console.log(position);

        idx= comparePositions(positions,position);
        if( idx < 0 ){
            positions.push(position);   // new pattern
            counts.push(1);
        }else{
            counts[idx]++;  // count old pattern
        }
    });
    
    positions.forEach(function(pos,idx){
        console.log(idx+" "+positions[idx]);
    });

    // sum the combinations of counts for each position type
    var sum=0;
    for(idx=0; idx<counts.length; idx++){
        count=counts[idx];
        sum+= (count > 2) ? (count * (count-1))/2 : 1;
    }

    return sum;
}

Analysis

▶

example
example test

✔

▶

test_data0

✔

Code: 03:47:31 UTC, js, 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 59 60 61 62 63 64 65 66 67 68 69 70 71

// you can use console.log for debugging purposes, i.e.
// console.log('this is debug message');
// write your code in JavaScript (ECMA-262, 5th edition)
// compare 2 arrays - assumes they are the same length
function compareArrays( a1, a2 )
{
    for( var i=0; i<a1.length; i++)
        if( a1[i] != a2[i] ){
            return false;
        }
    return true;
}

// compare newpos[] with positions[][]
// - rotates newpos[] to attempt match 
// returns: index of match or -1 if no match
//
function comparePositions(positions,newpos)
{
    for(var ipos=0; ipos<positions.length; ipos++){
        for( i=0; i<newpos.length; i++){
            if( compareArrays(positions[ipos],newpos))
                return ipos;
            newpos.push(newpos.shift());    //rotate array
        }
    }
    return -1;
}

function solution(A, P) {
    var idx,diff,halfP=P/2;
    var highestCount=0;
    var highestIndex=0;
    var positions = [];
    var counts=[];
    A.forEach(function(clock) {
        var position = [];
        // sort 'hands' in ascending order
        clock.sort(function(a, b) { return a - b });
        // duplicate start point on end
        clock.push(clock[0]);
//console.log(clock);
        // create array of distances between hands, wrapping around clock
        for(idx=1; idx<clock.length;idx++){
            diff= Math.abs(clock[idx] - clock[idx-1]);
            position.push((diff>halfP)?P-diff:diff);
        }
//console.log(position);

        idx= comparePositions(positions,position);
        if( idx < 0 ){
            positions.push(position);   // new pattern
            counts.push(1);
        }else{
            counts[idx]++;  // count old pattern
        }
    });
    
    positions.forEach(function(pos,idx){
        console.log(idx+" "+positions[idx]);
    });

    // sum the combinations of counts for each position type
    var sum=0;
    for(idx=0; idx<counts.length; idx++){
        count=counts[idx];
        sum+= (count > 2) ? (count * (count-1))/2 : count-1;
    }

    return sum;
}

Analysis

▶

example
example test

✔

▶

test_data0

✔

Code: 03:49:49 UTC, js, 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 59 60 61 62 63 64 65 66

// you can use console.log for debugging purposes, i.e.
// console.log('this is debug message');
// write your code in JavaScript (ECMA-262, 5th edition)
// compare 2 arrays - assumes they are the same length
function compareArrays( a1, a2 )
{
    for( var i=0; i<a1.length; i++)
        if( a1[i] != a2[i] ){
            return false;
        }
    return true;
}

// compare newpos[] with positions[][]
// - rotates newpos[] to attempt match 
// returns: index of match or -1 if no match
//
function comparePositions(positions,newpos)
{
    for(var ipos=0; ipos<positions.length; ipos++){
        for( i=0; i<newpos.length; i++){
            if( compareArrays(positions[ipos],newpos))
                return ipos;
            newpos.push(newpos.shift());    //rotate array
        }
    }
    return -1;
}

function solution(A, P) {
    var idx,diff,halfP=P/2;
    var highestCount=0;
    var highestIndex=0;
    var positions = [];
    var counts=[];
    A.forEach(function(clock) {
        var position = [];
        // sort 'hands' in ascending order
        clock.sort(function(a, b) { return a - b });
        // duplicate start point on end
        clock.push(clock[0]);

        // create array of distances between hands, wrapping around clock
        for(idx=1; idx<clock.length;idx++){
            diff= Math.abs(clock[idx] - clock[idx-1]);
            position.push((diff>halfP)?P-diff:diff);
        }

        idx= comparePositions(positions,position);
        if( idx < 0 ){
            positions.push(position);   // new pattern
            counts.push(1);
        }else{
            counts[idx]++;  // count old pattern
        }
    });
    
    // sum the combinations of counts for each position type
    var sum=0;
    for(idx=0; idx<counts.length; idx++){
        count=counts[idx];
        sum+= (count > 2) ? (count * (count-1))/2 : count-1;
    }

    return sum;
}

Analysis

▶

example
example test

✔

▶

test_data0

✔

Code: 03:49:53 UTC, js, final, score: 90

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 59 60 61 62 63 64 65 66

// you can use console.log for debugging purposes, i.e.
// console.log('this is debug message');
// write your code in JavaScript (ECMA-262, 5th edition)
// compare 2 arrays - assumes they are the same length
function compareArrays( a1, a2 )
{
    for( var i=0; i<a1.length; i++)
        if( a1[i] != a2[i] ){
            return false;
        }
    return true;
}

// compare newpos[] with positions[][]
// - rotates newpos[] to attempt match 
// returns: index of match or -1 if no match
//
function comparePositions(positions,newpos)
{
    for(var ipos=0; ipos<positions.length; ipos++){
        for( i=0; i<newpos.length; i++){
            if( compareArrays(positions[ipos],newpos))
                return ipos;
            newpos.push(newpos.shift());    //rotate array
        }
    }
    return -1;
}

function solution(A, P) {
    var idx,diff,halfP=P/2;
    var highestCount=0;
    var highestIndex=0;
    var positions = [];
    var counts=[];
    A.forEach(function(clock) {
        var position = [];
        // sort 'hands' in ascending order
        clock.sort(function(a, b) { return a - b });
        // duplicate start point on end
        clock.push(clock[0]);

        // create array of distances between hands, wrapping around clock
        for(idx=1; idx<clock.length;idx++){
            diff= Math.abs(clock[idx] - clock[idx-1]);
            position.push((diff>halfP)?P-diff:diff);
        }

        idx= comparePositions(positions,position);
        if( idx < 0 ){
            positions.push(position);   // new pattern
            counts.push(1);
        }else{
            counts[idx]++;  // count old pattern
        }
    });
    
    // sum the combinations of counts for each position type
    var sum=0;
    for(idx=0; idx<counts.length; idx++){
        count=counts[idx];
        sum+= (count > 2) ? (count * (count-1))/2 : count-1;
    }

    return sum;
}

Analysis summary

The following issues have been detected: timeout errors.

Analysis

Detected time complexity:

O(N * M * log(M) + N * log(N))

▶

example
example test

✔

▶

extreme_size_of_clock
minimal size of clock

✔

▶

extreme_number_of_clocks
minimal number of clocks

✔

▶

simple
simple tests

✔

▶

simple2
simple tests

✔

▶

small_random
small random test, number of clocks = 10 (different = 3)

✔

▶

small_constantSpace
all the same space except two, number of clocks = 15

✔

▶

small_rangeSpace
spaces are 1, 2, ... x, 1, 2, ... (x-1) ..., clocks = 20

✔

▶

small_rangeShuffle
shuffled range spaces, clocks = 25

✔

▶

medium_random_smallDifferent
medium random test, number of clocks = 100 (different = 7)

✔

▶

medium_random_bigDifferent
medium random test, number of clocks = 100 (different = 45)

✔

▶

medium_constantSpace
all the same space except two, number of clocks = 115

✔

▶

medium_rangeSpace
spaces are 1, 2, ... x, 1, 2, ... (x-1) ..., clocks = 113

✔

▶

medium_rangeShuffle
shuffled range spaces, clocks = 121

✔

▶

large_random_tinyDifferent
large random tests, number of clocks = 500 (different = 2)

✔

▶

large_random_smallDifferent
large random test, number of clocks = 500 (different = 9)

✔

▶

large_random_bigDifferent
large random test, number of clocks = 487 (different = 99)

✔

▶

large_constantSpace
all the same space except two, number of clocks = 500

✘

TIMEOUT ERROR
running time: >2.04 sec., time limit: 1.76 sec.

▶

large_rangeSpace1
spaces are 1, 2, ... x, 1, 2, ... (x-1) ..., clocks = 500

✔

▶

large_rangeSpace2
spaces are 1, 2, ... x, 1, 2, ... (x-1) ..., clocks = 496

✔

▶

large_rangeShuffle
shuffled range spaces, clocks = 500

✘

TIMEOUT ERROR
running time: >2.04 sec., time limit: 1.60 sec.

▶

extreme_maximal_pairs
all clocks looks the same

✔