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] = 3You 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] = 3the 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.
function rotate(arr) {
var min = arr.reduce(function(a,b) { return a > b ? b : a });
while (arr[0] != min) {
var first = arr.shift();
arr.push(first);
}
}
function solution(A, P) {
var positions = [];
A.forEach(function(clock) {
var position = [];
clock.sort(function(a, b) { return a - b });
clock.push(clock[0] + P);
clock.forEach(function(hand, idx) {
if (idx == 0) return;
position.push(clock[idx] - clock[idx - 1]);
});
rotate(position);
positions.push(position);
});
positions.sort();
var sum = 0;
var type = positions[0].join(",");
var n = 0;
positions.forEach(function(position, idx) {
if (type == position.join(",")) {
n++;
} else {
type = position.join(",");
sum += (n * (n-1)) / 2;
n = 1;
}
});
sum += (n * (n-1)) / 2;
return sum;
}
function rotate(arr) {
var min = arr.reduce(function(a,b) { return a > b ? b : a });
while (arr[0] != min) {
var first = arr.shift();
arr.push(first);
}
}
function solution(A, P) {
var positions = [];
A.forEach(function(clock) {
var position = [];
clock.sort(function(a, b) { return a - b });
clock.push(clock[0] + P);
clock.forEach(function(hand, idx) {
if (idx == 0) return;
position.push(clock[idx] - clock[idx - 1]);
});
rotate(position);
positions.push(position);
});
positions.sort();
var sum = 0;
var type = positions[0].join(",");
var n = 0;
positions.forEach(function(position, idx) {
if (type == position.join(",")) {
n++;
} else {
type = position.join(",");
sum += (n * (n-1)) / 2;
n = 1;
}
});
sum += (n * (n-1)) / 2;
return sum;
}
function rotate(arr) {
var min = arr.reduce(function(a,b) { return a > b ? b : a });
while (arr[0] != min) {
var first = arr.shift();
arr.push(first);
}
}
function solution(A, P) {
var positions = [];
A.forEach(function(clock) {
var position = [];
clock.sort(function(a, b) { return a - b });
clock.push(clock[0] + P);
clock.forEach(function(hand, idx) {
if (idx == 0) return;
position.push(clock[idx] - clock[idx - 1]);
});
rotate(position);
positions.push(position);
});
positions.sort();
var sum = 0;
var type = positions[0].join(",");
var n = 0;
positions.forEach(function(position, idx) {
if (type == position.join(",")) {
n++;
} else {
type = position.join(",");
sum += (n * (n-1)) / 2;
n = 1;
}
});
sum += (n * (n-1)) / 2;
return sum;
}
function rotate(arr) {
var min = arr.reduce(function(a,b) { return a > b ? b : a });
while (arr[0] != min) {
var first = arr.shift();
arr.push(first);
}
}
function solution(A, P) {
var positions = [];
A.forEach(function(clock) {
var position = [];
clock.sort(function(a, b) { return a - b });
clock.push(clock[0] + P);
clock.forEach(function(hand, idx) {
if (idx == 0) return;
position.push(clock[idx] - clock[idx - 1]);
});
rotate(position);
positions.push(position);
});
positions.sort();
var sum = 0;
var type = positions[0].join(",");
var n = 0;
positions.forEach(function(position, idx) {
if (type == position.join(",")) {
n++;
} else {
type = position.join(",");
sum += (n * (n-1)) / 2;
n = 1;
}
});
sum += (n * (n-1)) / 2;
return sum;
}
The following issues have been detected: wrong answers.
small random test, number of clocks = 10 (different = 3)
got 6 expected 13
all the same space except two, number of clocks = 15
got 8 expected 14
spaces are 1, 2, ... x, 1, 2, ... (x-1) ..., clocks = 20
got 63 expected 190
medium random test, number of clocks = 100 (different = 7)
got 573 expected 701
all the same space except two, number of clocks = 115
got 20 expected 124
spaces are 1, 2, ... x, 1, 2, ... (x-1) ..., clocks = 113
got 925 expected 6328
large random tests, number of clocks = 500 (different = 2)
got 3204 expected 62251
large random test, number of clocks = 487 (different = 99)
got 541 expected 1187
spaces are 1, 2, ... x, 1, 2, ... (x-1) ..., clocks = 500
got 41434 expected 124750
spaces are 1, 2, ... x, 1, 2, ... (x-1) ..., clocks = 496
got 9485 expected 122760