Tasks Details
hard
Given points on a plane, count the number of sets of four points that form regular diamonds.
Task Score
44%
Correctness
100%
Performance
0%
A diamond is a quadrilateral whose four sides all have the same length and whose diagonals are parallel to the coordinate axes.
You are given N distinct points on a plane. Count the number of different diamonds that can be constructed using these points as vertices (two diamonds are different if their sets of vertices are different). Do not count diamonds whose area is empty.
Write a function:
function solution(X, Y);
that, given two arrays X and Y, each containing N integers, representing N points (where X[K], Y[K] are the coordinates of the K-th point), returns the number of diamonds on the plane.
For example, for N = 7 points whose coordinates are specified in arrays X = [1, 1, 2, 2, 2, 3, 3] and Y = [3, 4, 1, 3, 5, 3, 4], the function should return 2, since we can find two diamonds as shown in the picture below:
Given arrays: X = [1, 2, 3, 3, 2, 1], Y = [1, 1, 1, 2, 2, 2], the function should return 0, since there are no diamonds on the plane:
Write an efficient algorithm for the following assumptions:
- N is an integer within the range [4..1,500];
- each element of arrays X and Y is an integer within the range [0..N-1];
- given N points are pairwise distinct.
Copyright 2009–2025 by Codility Limited. All Rights Reserved. Unauthorized copying, publication or disclosure prohibited.
Solution
Programming language used JavaScript
Time spent on task 65 minutes
Notes
not defined yet
Code: 09:24:07 UTC,
java,
autosave
Code: 09:26:51 UTC,
js,
autosave
Code: 09:27:21 UTC,
js,
autosave
Code: 09:27:31 UTC,
js,
autosave
Code: 09:28:28 UTC,
js,
autosave
Code: 09:28:38 UTC,
js,
autosave
Code: 09:29:01 UTC,
js,
autosave
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = []
for (let i = 0; i < X.length; i++) {
points.push([X[i], Y[i]])
}
}
function combinations(array, r) {
}
Code: 09:29:14 UTC,
js,
autosave
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = []
for (let i = 0; i < X.length; i++) {
points.push([X[i], Y[i]])
}
}
function combinations(array, r) {
if r >
}
Code: 09:29:33 UTC,
js,
autosave
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = []
for (let i = 0; i < X.length; i++) {
points.push([X[i], Y[i]])
}
}
function combinations(A, r) {
if (r > A.length) {
return;
}
}
Code: 09:30:09 UTC,
js,
autosave
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = []
for (let i = 0; i < X.length; i++) {
points.push([X[i], Y[i]]);
}
}
function combinations(A, r) {
if (r > A.length) {
return;
}
}
Code: 09:30:33 UTC,
js,
autosave
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = []
for (let i = 0; i < X.length; i++) {
points.push([X[i], Y[i]]);
}
let combinations = combinations(points, 2);
}
function combinations(A, r) {
if (r > A.length) {
return;
}
}
Code: 09:31:06 UTC,
js,
autosave
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = []
for (let i = 0; i < X.length; i++) {
points.push([X[i], Y[i]]);
}
let combinations = combinations(points, 2);
}
function combinations(A, r) {
if (r > A.length) {
return;
}
}
Code: 09:31:16 UTC,
js,
autosave
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = []
for (let i = 0; i < X.length; i++) {
points.push([X[i], Y[i]]);
}
let combinations = combinations(points, 2);
}
function combinations(A, r) {
if (r > A.length) {
return;
}
for
}
Code: 09:31:53 UTC,
js,
autosave
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = []
for (let i = 0; i < X.length; i++) {
points.push([X[i], Y[i]]);
}
let combinations = combinations(points, 2);
}
function combinations(A, r) {
if (r > A.length) {
return;
}
for i
}
Code: 09:32:23 UTC,
js,
autosave
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = []
for (let i = 0; i < X.length; i++) {
points.push([X[i], Y[i]]);
}
let combinations = combinations(points, 2);
}
function combinations(A, r) {
if (r > A.length) {
return;
}
for (let i = 0; i < A.length; i++) {
for (let j = i; )
}
}
Code: 09:32:34 UTC,
js,
autosave
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = []
for (let i = 0; i < X.length; i++) {
points.push([X[i], Y[i]]);
}
let combinations = combinations(points, 2);
}
function combinations(A, r) {
if (r > A.length) {
return;
}
for (let i = 0; i < A.length - 1; i++) {
for (let j = i; )
}
}
Code: 09:32:55 UTC,
js,
autosave
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = []
for (let i = 0; i < X.length; i++) {
points.push([X[i], Y[i]]);
}
let combinations = combinations(points, 2);
}
function combinations(A, r) {
if (r > A.length) {
return;
}
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i; j < A.length; j++) {
}
}
}
Code: 09:33:13 UTC,
js,
autosave
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = []
for (let i = 0; i < X.length; i++) {
points.push([X[i], Y[i]]);
}
let combinations = combinations(points, 2);
}
function combinations(A, r) {
if (r > A.length) {
return;
}
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i; j < A.length; j++) {
comb.push()
}
}
}
Code: 09:34:10 UTC,
js,
autosave
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = []
for (let i = 0; i < X.length; i++) {
points.push([X[i], Y[i]]);
}
let combinations = combinations(points, 2);
}
function combinations(A, r) {
if (r > A.length) {
return;
}
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i; j < A.length; j++) {
comb.push([])
}
}
}
Code: 09:34:25 UTC,
js,
autosave
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = []
for (let i = 0; i < X.length; i++) {
points.push([X[i], Y[i]]);
}
let combinations = combinations(points, 2);
}
function combinations(A, r) {
if (r > A.length) {
return;
}
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
}
Code: 09:34:43 UTC,
js,
autosave
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = []
for (let i = 0; i < X.length; i++) {
points.push([X[i], Y[i]]);
}
let combinations = combinations(points, 2);
}
function combinations(A, r) {
if (r > A.length) {
return;
}
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 09:35:13 UTC,
js,
autosave
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = []
for (let i = 0; i < X.length; i++) {
points.push([X[i], Y[i]]);
}
let combinations = combinations(points, 2);
}
function combinations(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 09:35:27 UTC,
js,
autosave
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = []
for (let i = 0; i < X.length; i++) {
points.push([X[i], Y[i]]);
}
let combinations = combinationsOfTwo(points);
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 09:35:59 UTC,
js,
autosave
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = []
for (let i = 0; i < X.length; i++) {
points.push([X[i], Y[i]]);
}
let combinations = combinationsOfTwo(points);
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 09:36:28 UTC,
js,
verify,
result: Failed
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = []
for (let i = 0; i < X.length; i++) {
points.push([X[i], Y[i]]);
}
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
console.log(pair)
}
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Analysis
expand all
Example tests
1.
0.076 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Invalid result type, integer expected, 'undefined' found Perhaps you are missing a 'return'?stdout:
[ [ 1, 3 ], [ 1, 3 ] ] [ [ 1, 3 ], [ 1, 4 ] ] [ [ 1, 3 ], [ 2, 1 ] ] [ [ 1, 3 ], [ 2, 3 ] ] [ [ 1, 3 ], [ 2, 5 ] ] [ [ 1, 3 ], [ 3, 3 ] ] [ [ 1, 3 ], [ 3, 4 ] ] [ [ 1, 4 ], [ 1, 4 ] ] [ [ 1, 4 ], [ 2, 1 ] ] [ [ 1, 4 ], [ 2, 3 ] ] [ [ 1, 4 ], [ 2, 5 ] ] [ [ 1, 4 ], [ 3, 3 ] ] [ [ 1, 4 ], [ 3, 4 ] ] [ [ 2, 1 ], [ 2, 1 ] ] [ [ 2, 1 ], [ 2, 3 ] ] [ [ 2, 1 ], [ 2, 5 ] ] [ [ 2, 1 ], [ 3, 3 ] ] [ [ 2, 1 ], [ 3, 4 ] ] [ [ 2, 3 ], [ 2, 3 ] ] [ [ 2, 3 ], [ 2, 5 ] ] [ [ 2, 3 ], [ 3, 3 ] ] [ [ 2, 3 ], [ 3, 4 ] ] [ [ 2, 5 ], [ 2, 5 ] ] [ [ 2, 5 ], [ 3, 3 ] ] [ [ 2, 5 ], [ 3, 4 ] ] [ [ 3, 3 ], [ 3, 3 ] ] [ [ 3, 3 ], [ 3, 4 ] ]
1.
0.076 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Invalid result type, integer expected, 'undefined' found Perhaps you are missing a 'return'?stdout:
[ [ 1, 1 ], [ 1, 1 ] ] [ [ 1, 1 ], [ 2, 1 ] ] [ [ 1, 1 ], [ 3, 1 ] ] [ [ 1, 1 ], [ 3, 2 ] ] [ [ 1, 1 ], [ 2, 2 ] ] [ [ 1, 1 ], [ 1, 2 ] ] [ [ 2, 1 ], [ 2, 1 ] ] [ [ 2, 1 ], [ 3, 1 ] ] [ [ 2, 1 ], [ 3, 2 ] ] [ [ 2, 1 ], [ 2, 2 ] ] [ [ 2, 1 ], [ 1, 2 ] ] [ [ 3, 1 ], [ 3, 1 ] ] [ [ 3, 1 ], [ 3, 2 ] ] [ [ 3, 1 ], [ 2, 2 ] ] [ [ 3, 1 ], [ 1, 2 ] ] [ [ 3, 2 ], [ 3, 2 ] ] [ [ 3, 2 ], [ 2, 2 ] ] [ [ 3, 2 ], [ 1, 2 ] ] [ [ 2, 2 ], [ 2, 2 ] ] [ [ 2, 2 ], [ 1, 2 ] ]
Code: 09:36:36 UTC,
js,
autosave
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = []
for (let i = 0; i < X.length; i++) {
points.push([X[i], Y[i]]);
}
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
console.log(pair)
}
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i; j < A.length; j++) {
comb.push(A[i],A[j]]);
}
}
return comb;
}
Code: 09:36:42 UTC,
js,
verify,
result: Failed
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = []
for (let i = 0; i < X.length; i++) {
points.push([X[i], Y[i]]);
}
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
console.log(pair)
}
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i; j < A.length; j++) {
comb.push(A[i],A[j]);
}
}
return comb;
}
Analysis
expand all
Example tests
1.
0.076 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Invalid result type, integer expected, 'undefined' found Perhaps you are missing a 'return'?stdout:
[ 1, 3 ] [ 1, 3 ] [ 1, 3 ] [ 1, 4 ] [ 1, 3 ] [ 2, 1 ] [ 1, 3 ] [ 2, 3 ] [ 1, 3 ] [ 2, 5 ] [ 1, 3 ] [ 3, 3 ] [ 1, 3 ] [ 3, 4 ] [ 1, 4 ] [ 1, 4 ] [ 1, 4 ] [ 2, 1 ] [ 1, 4 ] [ 2, 3 ] [ 1, 4 ] [ 2, 5 ] [ 1, 4 ] [ 3, 3 ] [ 1, 4 ] [ 3, 4 ] [ 2, 1 ] [ 2, 1 ] [ 2, 1 ] [ 2, 3 ] [ 2, 1 ] [ 2, 5 ] [ 2, 1 ] [ 3, 3 ] [ 2, 1 ] [ 3, 4 ] [ 2, 3 ] [ 2, 3 ] [ 2, 3 ] [ 2, 5 ] [ 2, 3 ] [ 3, 3 ] [ 2, 3 ] [ 3, 4 ] [ 2, 5 ] [ 2, 5 ] [ 2, 5 ] [ 3, 3 ] [ 2, 5 ] [ 3, 4 ] [ 3, 3 ] [ 3, 3 ] [ 3, 3 ] [ 3, 4 ]
1.
0.076 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Invalid result type, integer expected, 'undefined' found Perhaps you are missing a 'return'?stdout:
[ 1, 1 ] [ 1, 1 ] [ 1, 1 ] [ 2, 1 ] [ 1, 1 ] [ 3, 1 ] [ 1, 1 ] [ 3, 2 ] [ 1, 1 ] [ 2, 2 ] [ 1, 1 ] [ 1, 2 ] [ 2, 1 ] [ 2, 1 ] [ 2, 1 ] [ 3, 1 ] [ 2, 1 ] [ 3, 2 ] [ 2, 1 ] [ 2, 2 ] [ 2, 1 ] [ 1, 2 ] [ 3, 1 ] [ 3, 1 ] [ 3, 1 ] [ 3, 2 ] [ 3, 1 ] [ 2, 2 ] [ 3, 1 ] [ 1, 2 ] [ 3, 2 ] [ 3, 2 ] [ 3, 2 ] [ 2, 2 ] [ 3, 2 ] [ 1, 2 ] [ 2, 2 ] [ 2, 2 ] [ 2, 2 ] [ 1, 2 ]
Code: 09:36:50 UTC,
js,
verify,
result: Failed
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = []
for (let i = 0; i < X.length; i++) {
points.push([X[i], Y[i]]);
}
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
console.log(pair)
}
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Analysis
expand all
Example tests
1.
0.120 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Invalid result type, integer expected, 'undefined' found Perhaps you are missing a 'return'?stdout:
[ [ 1, 3 ], [ 1, 3 ] ] [ [ 1, 3 ], [ 1, 4 ] ] [ [ 1, 3 ], [ 2, 1 ] ] [ [ 1, 3 ], [ 2, 3 ] ] [ [ 1, 3 ], [ 2, 5 ] ] [ [ 1, 3 ], [ 3, 3 ] ] [ [ 1, 3 ], [ 3, 4 ] ] [ [ 1, 4 ], [ 1, 4 ] ] [ [ 1, 4 ], [ 2, 1 ] ] [ [ 1, 4 ], [ 2, 3 ] ] [ [ 1, 4 ], [ 2, 5 ] ] [ [ 1, 4 ], [ 3, 3 ] ] [ [ 1, 4 ], [ 3, 4 ] ] [ [ 2, 1 ], [ 2, 1 ] ] [ [ 2, 1 ], [ 2, 3 ] ] [ [ 2, 1 ], [ 2, 5 ] ] [ [ 2, 1 ], [ 3, 3 ] ] [ [ 2, 1 ], [ 3, 4 ] ] [ [ 2, 3 ], [ 2, 3 ] ] [ [ 2, 3 ], [ 2, 5 ] ] [ [ 2, 3 ], [ 3, 3 ] ] [ [ 2, 3 ], [ 3, 4 ] ] [ [ 2, 5 ], [ 2, 5 ] ] [ [ 2, 5 ], [ 3, 3 ] ] [ [ 2, 5 ], [ 3, 4 ] ] [ [ 3, 3 ], [ 3, 3 ] ] [ [ 3, 3 ], [ 3, 4 ] ]
1.
0.128 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Invalid result type, integer expected, 'undefined' found Perhaps you are missing a 'return'?stdout:
[ [ 1, 1 ], [ 1, 1 ] ] [ [ 1, 1 ], [ 2, 1 ] ] [ [ 1, 1 ], [ 3, 1 ] ] [ [ 1, 1 ], [ 3, 2 ] ] [ [ 1, 1 ], [ 2, 2 ] ] [ [ 1, 1 ], [ 1, 2 ] ] [ [ 2, 1 ], [ 2, 1 ] ] [ [ 2, 1 ], [ 3, 1 ] ] [ [ 2, 1 ], [ 3, 2 ] ] [ [ 2, 1 ], [ 2, 2 ] ] [ [ 2, 1 ], [ 1, 2 ] ] [ [ 3, 1 ], [ 3, 1 ] ] [ [ 3, 1 ], [ 3, 2 ] ] [ [ 3, 1 ], [ 2, 2 ] ] [ [ 3, 1 ], [ 1, 2 ] ] [ [ 3, 2 ], [ 3, 2 ] ] [ [ 3, 2 ], [ 2, 2 ] ] [ [ 3, 2 ], [ 1, 2 ] ] [ [ 2, 2 ], [ 2, 2 ] ] [ [ 2, 2 ], [ 1, 2 ] ]
Code: 09:37:01 UTC,
js,
verify,
result: Failed
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = []
for (let i = 0; i < X.length; i++) {
points.push([X[i], Y[i]]);
}
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
console.log(pair)
}
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Analysis
expand all
Example tests
1.
0.076 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Invalid result type, integer expected, 'undefined' found Perhaps you are missing a 'return'?stdout:
[ [ 1, 3 ], [ 1, 4 ] ] [ [ 1, 3 ], [ 2, 1 ] ] [ [ 1, 3 ], [ 2, 3 ] ] [ [ 1, 3 ], [ 2, 5 ] ] [ [ 1, 3 ], [ 3, 3 ] ] [ [ 1, 3 ], [ 3, 4 ] ] [ [ 1, 4 ], [ 2, 1 ] ] [ [ 1, 4 ], [ 2, 3 ] ] [ [ 1, 4 ], [ 2, 5 ] ] [ [ 1, 4 ], [ 3, 3 ] ] [ [ 1, 4 ], [ 3, 4 ] ] [ [ 2, 1 ], [ 2, 3 ] ] [ [ 2, 1 ], [ 2, 5 ] ] [ [ 2, 1 ], [ 3, 3 ] ] [ [ 2, 1 ], [ 3, 4 ] ] [ [ 2, 3 ], [ 2, 5 ] ] [ [ 2, 3 ], [ 3, 3 ] ] [ [ 2, 3 ], [ 3, 4 ] ] [ [ 2, 5 ], [ 3, 3 ] ] [ [ 2, 5 ], [ 3, 4 ] ] [ [ 3, 3 ], [ 3, 4 ] ]
1.
0.076 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Invalid result type, integer expected, 'undefined' found Perhaps you are missing a 'return'?stdout:
[ [ 1, 1 ], [ 2, 1 ] ] [ [ 1, 1 ], [ 3, 1 ] ] [ [ 1, 1 ], [ 3, 2 ] ] [ [ 1, 1 ], [ 2, 2 ] ] [ [ 1, 1 ], [ 1, 2 ] ] [ [ 2, 1 ], [ 3, 1 ] ] [ [ 2, 1 ], [ 3, 2 ] ] [ [ 2, 1 ], [ 2, 2 ] ] [ [ 2, 1 ], [ 1, 2 ] ] [ [ 3, 1 ], [ 3, 2 ] ] [ [ 3, 1 ], [ 2, 2 ] ] [ [ 3, 1 ], [ 1, 2 ] ] [ [ 3, 2 ], [ 2, 2 ] ] [ [ 3, 2 ], [ 1, 2 ] ] [ [ 2, 2 ], [ 1, 2 ] ]
Code: 09:38:04 UTC,
js,
autosave
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = []
for (let i = 0; i < X.length; i++) {
points.push({X[i], Y[i]]);
}
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
console.log(pair)
}
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 09:38:16 UTC,
js,
verify,
result: Failed
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = []
for (let i = 0; i < X.length; i++) {
points.push({X[i], Y[i]});
}
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
console.log(pair)
}
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push({A[i],A[j]});
}
}
return comb;
}
Analysis
expand all
Example tests
1.
0.072 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
solution.js:8
points.push({X[i], Y[i]});
^
SyntaxError: Unexpected token [
at createScript (vm.js:80:10)
at Object.runInNewContext (vm.js:135:10)
at getSolution (/tmp/exec.js:402:29)
at Promise.resolve.then (/tmp/exec.js:436:34)
at <anonymous>
at process._tickCallback (internal/process/next_tick.js:188:7)
at Function.Module.runMain (module.js:686:11)
at startup (bootstrap_node.js:187:16)
at bootstrap_node.js:608:3
1.
0.068 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
solution.js:8
points.push({X[i], Y[i]});
^
SyntaxError: Unexpected token [
at createScript (vm.js:80:10)
at Object.runInNewContext (vm.js:135:10)
at getSolution (/tmp/exec.js:402:29)
at Promise.resolve.then (/tmp/exec.js:436:34)
at <anonymous>
at process._tickCallback (internal/process/next_tick.js:188:7)
at Function.Module.runMain (module.js:686:11)
at startup (bootstrap_node.js:187:16)
at bootstrap_node.js:608:3
Code: 09:38:29 UTC,
js,
autosave
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = []
for (let i = 0; i < X.length; i++) {
points.push({1:X[i], Y[i]});
}
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
console.log(pair)
}
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push({A[i],A[j]});
}
}
return comb;
}
Code: 09:38:35 UTC,
js,
verify,
result: Failed
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = []
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
console.log(pair)
}
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push({A[i],A[j]});
}
}
return comb;
}
Analysis
expand all
Example tests
1.
0.072 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
solution.js:20
comb.push({A[i],A[j]});
^
SyntaxError: Unexpected token [
at createScript (vm.js:80:10)
at Object.runInNewContext (vm.js:135:10)
at getSolution (/tmp/exec.js:402:29)
at Promise.resolve.then (/tmp/exec.js:436:34)
at <anonymous>
at process._tickCallback (internal/process/next_tick.js:188:7)
at Function.Module.runMain (module.js:686:11)
at startup (bootstrap_node.js:187:16)
at bootstrap_node.js:608:3
1.
0.072 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
solution.js:20
comb.push({A[i],A[j]});
^
SyntaxError: Unexpected token [
at createScript (vm.js:80:10)
at Object.runInNewContext (vm.js:135:10)
at getSolution (/tmp/exec.js:402:29)
at Promise.resolve.then (/tmp/exec.js:436:34)
at <anonymous>
at process._tickCallback (internal/process/next_tick.js:188:7)
at Function.Module.runMain (module.js:686:11)
at startup (bootstrap_node.js:187:16)
at bootstrap_node.js:608:3
Code: 09:38:48 UTC,
js,
verify,
result: Failed
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = []
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
console.log(pair)
}
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Analysis
expand all
Example tests
1.
0.076 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Invalid result type, integer expected, 'undefined' found Perhaps you are missing a 'return'?stdout:
[ { x: 1, y: 3 }, { x: 1, y: 4 } ]
[ { x: 1, y: 3 }, { x: 2, y: 1 } ]
[ { x: 1, y: 3 }, { x: 2, y: 3 } ]
[ { x: 1, y: 3 }, { x: 2, y: 5 } ]
[ { x: 1, y: 3 }, { x: 3, y: 3 } ]
[ { x: 1, y: 3 }, { x: 3, y: 4 } ]
[ { x: 1, y: 4 }, { x: 2, y: 1 } ]
[ { x: 1, y: 4 }, { x: 2, y: 3 } ]
[ { x: 1, y: 4 }, { x: 2, y: 5 } ]
[ { x: 1, y: 4 }, { x: 3, y: 3 } ]
[ { x: 1, y: 4 }, { x: 3, y: 4 } ]
[ { x: 2, y: 1 }, { x: 2, y: 3 } ]
[ { x: 2, y: 1 }, { x: 2, y: 5 } ]
[ { x: 2, y: 1 }, { x: 3, y: 3 } ]
[ { x: 2, y: 1 }, { x: 3, y: 4 } ]
[ { x: 2, y: 3 }, { x: 2, y: 5 } ]
[ { x: 2, y: 3 }, { x: 3, y: 3 } ]
[ { x: 2, y: 3 }, { x: 3, y: 4 } ]
[ { x: 2, y: 5 }, { x: 3, y: 3 } ]
[ { x: 2, y: 5 }, { x: 3, y: 4 } ]
[ { x: 3, y: 3 }, { x: 3, y: 4 } ]
1.
0.076 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Invalid result type, integer expected, 'undefined' found Perhaps you are missing a 'return'?stdout:
[ { x: 1, y: 1 }, { x: 2, y: 1 } ]
[ { x: 1, y: 1 }, { x: 3, y: 1 } ]
[ { x: 1, y: 1 }, { x: 3, y: 2 } ]
[ { x: 1, y: 1 }, { x: 2, y: 2 } ]
[ { x: 1, y: 1 }, { x: 1, y: 2 } ]
[ { x: 2, y: 1 }, { x: 3, y: 1 } ]
[ { x: 2, y: 1 }, { x: 3, y: 2 } ]
[ { x: 2, y: 1 }, { x: 2, y: 2 } ]
[ { x: 2, y: 1 }, { x: 1, y: 2 } ]
[ { x: 3, y: 1 }, { x: 3, y: 2 } ]
[ { x: 3, y: 1 }, { x: 2, y: 2 } ]
[ { x: 3, y: 1 }, { x: 1, y: 2 } ]
[ { x: 3, y: 2 }, { x: 2, y: 2 } ]
[ { x: 3, y: 2 }, { x: 1, y: 2 } ]
[ { x: 2, y: 2 }, { x: 1, y: 2 } ]
Code: 09:38:59 UTC,
js,
autosave
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = []
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
console.log(pair[0])
}
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 09:39:04 UTC,
js,
verify,
result: Failed
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = []
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
console.log(pair[0])
}
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Analysis
expand all
Example tests
1.
0.076 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Invalid result type, integer expected, 'undefined' found Perhaps you are missing a 'return'?stdout:
{ x: 1, y: 3 }
{ x: 1, y: 3 }
{ x: 1, y: 3 }
{ x: 1, y: 3 }
{ x: 1, y: 3 }
{ x: 1, y: 3 }
{ x: 1, y: 4 }
{ x: 1, y: 4 }
{ x: 1, y: 4 }
{ x: 1, y: 4 }
{ x: 1, y: 4 }
{ x: 2, y: 1 }
{ x: 2, y: 1 }
{ x: 2, y: 1 }
{ x: 2, y: 1 }
{ x: 2, y: 3 }
{ x: 2, y: 3 }
{ x: 2, y: 3 }
{ x: 2, y: 5 }
{ x: 2, y: 5 }
{ x: 3, y: 3 }
1.
0.080 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Invalid result type, integer expected, 'undefined' found Perhaps you are missing a 'return'?stdout:
{ x: 1, y: 1 }
{ x: 1, y: 1 }
{ x: 1, y: 1 }
{ x: 1, y: 1 }
{ x: 1, y: 1 }
{ x: 2, y: 1 }
{ x: 2, y: 1 }
{ x: 2, y: 1 }
{ x: 2, y: 1 }
{ x: 3, y: 1 }
{ x: 3, y: 1 }
{ x: 3, y: 1 }
{ x: 3, y: 2 }
{ x: 3, y: 2 }
{ x: 2, y: 2 }
Code: 09:39:15 UTC,
js,
verify,
result: Failed
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = []
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
console.log(pair[0], pair[1])
}
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Analysis
expand all
Example tests
1.
0.076 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Invalid result type, integer expected, 'undefined' found Perhaps you are missing a 'return'?stdout:
{ x: 1, y: 3 } { x: 1, y: 4 }
{ x: 1, y: 3 } { x: 2, y: 1 }
{ x: 1, y: 3 } { x: 2, y: 3 }
{ x: 1, y: 3 } { x: 2, y: 5 }
{ x: 1, y: 3 } { x: 3, y: 3 }
{ x: 1, y: 3 } { x: 3, y: 4 }
{ x: 1, y: 4 } { x: 2, y: 1 }
{ x: 1, y: 4 } { x: 2, y: 3 }
{ x: 1, y: 4 } { x: 2, y: 5 }
{ x: 1, y: 4 } { x: 3, y: 3 }
{ x: 1, y: 4 } { x: 3, y: 4 }
{ x: 2, y: 1 } { x: 2, y: 3 }
{ x: 2, y: 1 } { x: 2, y: 5 }
{ x: 2, y: 1 } { x: 3, y: 3 }
{ x: 2, y: 1 } { x: 3, y: 4 }
{ x: 2, y: 3 } { x: 2, y: 5 }
{ x: 2, y: 3 } { x: 3, y: 3 }
{ x: 2, y: 3 } { x: 3, y: 4 }
{ x: 2, y: 5 } { x: 3, y: 3 }
{ x: 2, y: 5 } { x: 3, y: 4 }
{ x: 3, y: 3 } { x: 3, y: 4 }
1.
0.076 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Invalid result type, integer expected, 'undefined' found Perhaps you are missing a 'return'?stdout:
{ x: 1, y: 1 } { x: 2, y: 1 }
{ x: 1, y: 1 } { x: 3, y: 1 }
{ x: 1, y: 1 } { x: 3, y: 2 }
{ x: 1, y: 1 } { x: 2, y: 2 }
{ x: 1, y: 1 } { x: 1, y: 2 }
{ x: 2, y: 1 } { x: 3, y: 1 }
{ x: 2, y: 1 } { x: 3, y: 2 }
{ x: 2, y: 1 } { x: 2, y: 2 }
{ x: 2, y: 1 } { x: 1, y: 2 }
{ x: 3, y: 1 } { x: 3, y: 2 }
{ x: 3, y: 1 } { x: 2, y: 2 }
{ x: 3, y: 1 } { x: 1, y: 2 }
{ x: 3, y: 2 } { x: 2, y: 2 }
{ x: 3, y: 2 } { x: 1, y: 2 }
{ x: 2, y: 2 } { x: 1, y: 2 }
Code: 09:39:29 UTC,
js,
autosave
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = []
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
if ()
}
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 09:39:40 UTC,
js,
autosave
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = []
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
if (pair[0].x)
}
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 09:39:53 UTC,
js,
autosave
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = []
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
if (pair[0].x === pair[1].x) {
}
}
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 09:40:23 UTC,
js,
autosave
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = []
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
if (pair[0].x === pair[1].x) {
} else if (pair[0].y === pair[1].y) {
}
}
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 09:40:56 UTC,
js,
autosave
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = []
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
if (pair[0].x === pair[1].x) {
let m
} else if (pair[0].y === pair[1].y) {
}
}
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 09:41:07 UTC,
js,
autosave
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = []
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
if (pair[0].x === pair[1].x) {
let meanX = ()
} else if (pair[0].y === pair[1].y) {
}
}
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 09:41:27 UTC,
js,
autosave
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = []
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
if (pair[0].x === pair[1].x) {
let meanX = (pair[0].x + pair[1].x) / 2
} else if (pair[0].y === pair[1].y) {
}
}
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 09:41:48 UTC,
js,
autosave
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = []
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
if (pair[0].x === pair[1].x) {
let meanX = (pair[0].x + pair[1].x) / 2
let iMeanX = parseInt(meanX)
} else if (pair[0].y === pair[1].y) {
}
}
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 09:42:18 UTC,
js,
autosave
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = []
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
if (pair[0].x === pair[1].x) {
let meanX = (pair[0].x + pair[1].x) / 2
let iMeanX = parseInt(meanX)
if (meanX !== pair[0].x && meanX === i)
} else if (pair[0].y === pair[1].y) {
}
}
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 09:42:28 UTC,
js,
autosave
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = []
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
if (pair[0].x === pair[1].x) {
let meanX = (pair[0].x + pair[1].x) / 2
let iMeanX = parseInt(meanX)
if (meanX !== pair[0].x && meanX === iMeanX) {
}
} else if (pair[0].y === pair[1].y) {
}
}
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 09:43:10 UTC,
js,
autosave
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = []
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
if (pair[0].x === pair[1].x) {
let meanX = (pair[0].x + pair[1].x) / 2
let iMeanX = parseInt(meanX)
if (meanX !== pair[0].x && meanX === iMeanX) {
}
} else if (pair[0].y === pair[1].y) {
let meanX = (pair[0].x + pair[1].x) / 2
let iMeanX = parseInt(meanX)
if (meanX !== pair[0].x && meanX === iMeanX) {
}
}
}
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 09:43:34 UTC,
js,
autosave
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = []
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
if (pair[0].x === pair[1].x) {
let meanX = (pair[0].x + pair[1].x) / 2
let iMeanX = parseInt(meanX)
if (meanX !== pair[0].x && meanX === iMeanX) {
}
} else if (pair[0].y === pair[1].y) {
let meanY = (pair[0].y + pair[1].y) / 2
let iMeanY = parseInt(meanY)
if (meanY !== pair[0].y && meanY === iMeanY) {
}
}
}
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 09:44:47 UTC,
js,
autosave
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = []
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
if (pair[0].x === pair[1].x) {
let meanX = (pair[0].x + pair[1].x) / 2
let iMeanX = parseInt(meanX)
if (meanX !== pair[0].x && meanX === iMeanX) {
}
} else if (pair[0].y === pair[1].y) {
let meanY = (pair[0].y + pair[1].y) / 2
let iMeanY = parseInt(meanY)
if (meanY !== pair[0].y && meanY === iMeanY) {
}
}
}
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 09:45:06 UTC,
js,
autosave
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = []
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let byMeanX = []
let byMeanY = []
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
if (pair[0].x === pair[1].x) {
let meanX = (pair[0].x + pair[1].x) / 2
let iMeanX = parseInt(meanX)
if (meanX !== pair[0].x && meanX === iMeanX) {
}
} else if (pair[0].y === pair[1].y) {
let meanY = (pair[0].y + pair[1].y) / 2
let iMeanY = parseInt(meanY)
if (meanY !== pair[0].y && meanY === iMeanY) {
}
}
}
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 09:45:36 UTC,
js,
autosave
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = []
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
le
let byMeanX = []
let byMeanY = []
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
if (pair[0].x === pair[1].x) {
let meanX = (pair[0].x + pair[1].x) / 2
let iMeanX = parseInt(meanX)
if (meanX !== pair[0].x && meanX === iMeanX) {
}
} else if (pair[0].y === pair[1].y) {
let meanY = (pair[0].y + pair[1].y) / 2
let iMeanY = parseInt(meanY)
if (meanY !== pair[0].y && meanY === iMeanY) {
}
}
}
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 09:45:54 UTC,
js,
autosave
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = []
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = []
let byMeanY = []
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
if (pair[0].x === pair[1].x) {
let meanX = (pair[0].x + pair[1].x) / 2
let iMeanX = parseInt(meanX)
if (meanX !== pair[0].x && meanX === iMeanX) {
}
} else if (pair[0].y === pair[1].y) {
let meanY = (pair[0].y + pair[1].y) / 2
let iMeanY = parseInt(meanY)
if (meanY !== pair[0].y && meanY === iMeanY) {
}
}
}
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 09:46:20 UTC,
js,
autosave
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = []
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = Array.from({ length: max + 1}, )
let byMeanY = []
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
if (pair[0].x === pair[1].x) {
let meanX = (pair[0].x + pair[1].x) / 2
let iMeanX = parseInt(meanX)
if (meanX !== pair[0].x && meanX === iMeanX) {
}
} else if (pair[0].y === pair[1].y) {
let meanY = (pair[0].y + pair[1].y) / 2
let iMeanY = parseInt(meanY)
if (meanY !== pair[0].y && meanY === iMeanY) {
}
}
}
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 09:46:40 UTC,
js,
autosave
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = []
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = Array.from({ length: max + 1}, () => {})
let byMeanY = []
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
if (pair[0].x === pair[1].x) {
let meanX = (pair[0].x + pair[1].x) / 2
let iMeanX = parseInt(meanX)
if (meanX !== pair[0].x && meanX === iMeanX) {
}
} else if (pair[0].y === pair[1].y) {
let meanY = (pair[0].y + pair[1].y) / 2
let iMeanY = parseInt(meanY)
if (meanY !== pair[0].y && meanY === iMeanY) {
}
}
}
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 09:48:16 UTC,
js,
autosave
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = []
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = Array.from({ length: max + 1}, () => {0)
let byMeanY = []
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
if (pair[0].x === pair[1].x) {
let meanX = (pair[0].x + pair[1].x) / 2
let iMeanX = parseInt(meanX)
if (meanX !== pair[0].x && meanX === iMeanX) {
}
} else if (pair[0].y === pair[1].y) {
let meanY = (pair[0].y + pair[1].y) / 2
let iMeanY = parseInt(meanY)
if (meanY !== pair[0].y && meanY === iMeanY) {
}
}
}
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 09:48:30 UTC,
js,
autosave
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = []
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = Array.from({ length: max + 1}, () => 0);
let byMeanY = Array.from({ length: max + 1}, () => 0);
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
if (pair[0].x === pair[1].x) {
let meanX = (pair[0].x + pair[1].x) / 2
let iMeanX = parseInt(meanX)
if (meanX !== pair[0].x && meanX === iMeanX) {
}
} else if (pair[0].y === pair[1].y) {
let meanY = (pair[0].y + pair[1].y) / 2
let iMeanY = parseInt(meanY)
if (meanY !== pair[0].y && meanY === iMeanY) {
}
}
}
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 09:48:43 UTC,
js,
autosave
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = Array.from({ length: max + 1}, () => 0);
let byMeanY = Array.from({ length: max + 1}, () => 0);
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
if (pair[0].x === pair[1].x) {
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
if (meanX !== pair[0].x && meanX === iMeanX) {
}
} else if (pair[0].y === pair[1].y) {
let meanY = (pair[0].y + pair[1].y) / 2
let iMeanY = parseInt(meanY)
if (meanY !== pair[0].y && meanY === iMeanY) {
}
}
}
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 09:48:53 UTC,
js,
autosave
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = Array.from({ length: max + 1}, () => 0);
let byMeanY = Array.from({ length: max + 1}, () => 0);
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
if (pair[0].x === pair[1].x) {
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
if (meanX !== pair[0].x && meanX === iMeanX) {
}
} else if (pair[0].y === pair[1].y) {
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
}
}
}
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 09:49:23 UTC,
js,
autosave
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = Array.from({ length: max + 1}, () => 0);
let byMeanY = Array.from({ length: max + 1}, () => 0);
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
if (pair[0].x === pair[1].x) {
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
if (meanX !== pair[0].x && meanX === iMeanX) {
if (iMeanX)
}
} else if (pair[0].y === pair[1].y) {
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
}
}
}
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 09:49:33 UTC,
js,
autosave
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = Array.from({ length: max + 1}, () => 0);
let byMeanY = Array.from({ length: max + 1}, () => 0);
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
if (pair[0].x === pair[1].x) {
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
if (meanX !== pair[0].x && meanX === iMeanX) {
if (byMeanX)
}
} else if (pair[0].y === pair[1].y) {
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
}
}
}
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 09:49:45 UTC,
js,
autosave
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = Array.from({ length: max + 1}, () => 0);
let byMeanY = Array.from({ length: max + 1}, () => 0);
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
if (pair[0].x === pair[1].x) {
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
if (meanX !== pair[0].x && meanX === iMeanX) {
if (byMeanX[iMeanX])
}
} else if (pair[0].y === pair[1].y) {
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
}
}
}
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 09:49:57 UTC,
js,
autosave
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = Array.from({ length: max + 1}, () => 0);
let byMeanY = Array.from({ length: max + 1}, () => 0);
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
if (pair[0].x === pair[1].x) {
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
if (meanX !== pair[0].x && meanX === iMeanX) {
if (byMeanX[iMeanX] === 0) {
}
}
} else if (pair[0].y === pair[1].y) {
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
}
}
}
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 09:51:11 UTC,
js,
autosave
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = Array.from({ length: max + 1}, () => );
let byMeanY = Array.from({ length: max + 1}, () => 0);
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
if (pair[0].x === pair[1].x) {
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
if (meanX !== pair[0].x && meanX === iMeanX) {
if (byMeanX[iMeanX] === 0) {
}
}
} else if (pair[0].y === pair[1].y) {
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
}
}
}
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 09:51:22 UTC,
js,
autosave
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = Array.from({ length: max + 1}, () => []);
let byMeanY = Array.from({ length: max + 1}, () => []);
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
if (pair[0].x === pair[1].x) {
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
if (meanX !== pair[0].x && meanX === iMeanX) {
if (byMeanX[iMeanX] === 0) {
}
}
} else if (pair[0].y === pair[1].y) {
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
}
}
}
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 09:52:42 UTC,
js,
autosave
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = Array.from({ length: max + 1}, () => []);
let byMeanY = Array.from({ length: max + 1}, () => []);
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
if (pair[0].x === pair[1].x) {
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
if (meanX !== pair[0].x && meanX === iMeanX) {
if (byMeanX[iMeanX] ) {
}
}
} else if (pair[0].y === pair[1].y) {
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
}
}
}
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 09:52:53 UTC,
js,
autosave
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = Array.from({ length: max + 1}, () => []);
let byMeanY = Array.from({ length: max + 1}, () => []);
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
if (pair[0].x === pair[1].x) {
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
if (meanX !== pair[0].x && meanX === iMeanX) {
if (byMeanX[iMeanX][]) {
}
}
} else if (pair[0].y === pair[1].y) {
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
}
}
}
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 09:53:18 UTC,
js,
autosave
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
if (pair[0].x === pair[1].x) {
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
if (meanX !== pair[0].x && meanX === iMeanX) {
if (byMeanX[iMeanX][]) {
}
}
} else if (pair[0].y === pair[1].y) {
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
}
}
}
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 09:54:15 UTC,
js,
autosave
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
if (pair[0].x === pair[1].x) {
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
if (meanX !== pair[0].x && meanX === iMeanX) {
if (byMeanX[iMeanX][pair]) {
}
}
} else if (pair[0].y === pair[1].y) {
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
}
}
}
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 09:54:34 UTC,
js,
autosave
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
if (pair[0].x === pair[1].x) {
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
if (meanX !== pair[0].x && meanX === iMeanX) {
if (byMeanX[iMeanX][pair[0].y] !== undefined) {
}
}
} else if (pair[0].y === pair[1].y) {
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
}
}
}
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 09:54:51 UTC,
js,
autosave
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
if (pair[0].x === pair[1].x) {
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
if (meanX !== pair[0].x && meanX === iMeanX) {
if (byMeanX[iMeanX][pair[0].y] !== undefined) {
byMeanX[iMeanX][pair[0].y] = 1
} else {
}
}
} else if (pair[0].y === pair[1].y) {
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
}
}
}
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 09:55:08 UTC,
js,
autosave
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
if (pair[0].x === pair[1].x) {
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
if (meanX !== pair[0].x && meanX === iMeanX) {
if (byMeanX[iMeanX][pair[0].y] !== undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
} else if (pair[0].y === pair[1].y) {
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
}
}
}
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 09:55:38 UTC,
js,
autosave
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
if (pair[0].x === pair[1].x) {
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
if (meanX !== pair[0].x && meanX === iMeanX) {
if (byMeanX[iMeanX][pair[0].y] !== undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
} else if (pair[0].y === pair[1].y) {
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
if (byMeanY[iMeanY][pair[0].x] !== undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].y]++;
}
}
}
}
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 09:55:48 UTC,
js,
autosave
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
if (pair[0].x === pair[1].x) {
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
if (meanX !== pair[0].x && meanX === iMeanX) {
if (byMeanX[iMeanX][pair[0].y] !== undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
} else if (pair[0].y === pair[1].y) {
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
if (byMeanY[iMeanY][pair[0].x] !== undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].x]++;
}
}
}
}
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 09:56:00 UTC,
js,
autosave
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
if (pair[0].x === pair[1].x) {
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
if (meanX !== pair[0].x && meanX === iMeanX) {
if (byMeanX[iMeanX][pair[0].y] !== undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
} else if (pair[0].y === pair[1].y) {
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
if (byMeanY[iMeanY][pair[0].x] !== undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].x]++;
}
}
}
}
let diamonds = 0;
for let
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 09:56:21 UTC,
js,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
if (pair[0].x === pair[1].x) {
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
if (meanX !== pair[0].x && meanX === iMeanX) {
if (byMeanX[iMeanX][pair[0].y] !== undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
} else if (pair[0].y === pair[1].y) {
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
if (byMeanY[iMeanY][pair[0].x] !== undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].x]++;
}
}
}
}
let diamonds = 0;
for (let y of byMeanY) {
}
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 09:56:51 UTC,
js,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
if (pair[0].x === pair[1].x) {
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
if (meanX !== pair[0].x && meanX === iMeanX) {
if (byMeanX[iMeanX][pair[0].y] !== undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
} else if (pair[0].y === pair[1].y) {
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
if (byMeanY[iMeanY][pair[0].x] !== undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].x]++;
}
}
}
}
let diamonds = 0;
for (let y of byMeanY) {
console.log(y);
for (let x of byMeanX) {
console.log()
}
}
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 09:57:13 UTC,
js,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
if (pair[0].x === pair[1].x) {
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
if (meanX !== pair[0].x && meanX === iMeanX) {
if (byMeanX[iMeanX][pair[0].y] !== undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
} else if (pair[0].y === pair[1].y) {
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
if (byMeanY[iMeanY][pair[0].x] !== undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].x]++;
}
}
}
}
let diamonds = 0;
for (let y of byMeanY) {
console.log(y);
for (let x of byMeanX) {
console.log(x);
if x
}
}
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 09:57:23 UTC,
js,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
if (pair[0].x === pair[1].x) {
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
if (meanX !== pair[0].x && meanX === iMeanX) {
if (byMeanX[iMeanX][pair[0].y] !== undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
} else if (pair[0].y === pair[1].y) {
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
if (byMeanY[iMeanY][pair[0].x] !== undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].x]++;
}
}
}
}
let diamonds = 0;
for (let y of byMeanY) {
console.log(y);
for (let x of byMeanY[y]) {
console.log(x);
if x
}
}
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 09:57:33 UTC,
js,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
if (pair[0].x === pair[1].x) {
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
if (meanX !== pair[0].x && meanX === iMeanX) {
if (byMeanX[iMeanX][pair[0].y] !== undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
} else if (pair[0].y === pair[1].y) {
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
if (byMeanY[iMeanY][pair[0].x] !== undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].x]++;
}
}
}
}
let diamonds = 0;
for (let y of byMeanY) {
console.log(y);
for (let x of byMeanY[y]) {
console.log(x);
if (
}
}
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 09:58:13 UTC,
js,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
if (pair[0].x === pair[1].x) {
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
if (meanX !== pair[0].x && meanX === iMeanX) {
if (byMeanX[iMeanX][pair[0].y] !== undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
} else if (pair[0].y === pair[1].y) {
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
if (byMeanY[iMeanY][pair[0].x] !== undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].x]++;
}
}
}
}
let diamonds = 0;
for (let y of byMeanY) {
console.log(y);
for (let x of byMeanY[y]) {
console.log(x);
if (x
}
}
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 09:58:23 UTC,
js,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
if (pair[0].x === pair[1].x) {
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
if (meanX !== pair[0].x && meanX === iMeanX) {
if (byMeanX[iMeanX][pair[0].y] !== undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
} else if (pair[0].y === pair[1].y) {
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
if (byMeanY[iMeanY][pair[0].x] !== undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].x]++;
}
}
}
}
let diamonds = 0;
for (let y of byMeanY) {
console.log(y);
for (let x of byMeanY[y]) {
console.log(x);
if (x in
}
}
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 09:59:12 UTC,
js,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
if (pair[0].x === pair[1].x) {
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
if (meanX !== pair[0].x && meanX === iMeanX) {
if (byMeanX[iMeanX][pair[0].y] !== undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
} else if (pair[0].y === pair[1].y) {
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
if (byMeanY[iMeanY][pair[0].x] !== undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].x]++;
}
}
}
}
let diamonds = 0;
for (let y of byMeanY) {
console.log(y);
for (let x of byMeanY[y]) {
console.log(x);
if (by
}
}
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 09:59:24 UTC,
js,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
if (pair[0].x === pair[1].x) {
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
if (meanX !== pair[0].x && meanX === iMeanX) {
if (byMeanX[iMeanX][pair[0].y] !== undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
} else if (pair[0].y === pair[1].y) {
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
if (byMeanY[iMeanY][pair[0].x] !== undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].x]++;
}
}
}
}
let diamonds = 0;
for (let y of byMeanY) {
console.log(y);
for (let x of byMeanY[y]) {
console.log(x);
if (byMeanX.hasProperty
}
}
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 09:59:37 UTC,
js,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
if (pair[0].x === pair[1].x) {
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
if (meanX !== pair[0].x && meanX === iMeanX) {
if (byMeanX[iMeanX][pair[0].y] !== undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
} else if (pair[0].y === pair[1].y) {
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
if (byMeanY[iMeanY][pair[0].x] !== undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].x]++;
}
}
}
}
let diamonds = 0;
for (let y of byMeanY) {
console.log(y);
for (let x of byMeanY[y]) {
console.log(x);
if (byMeanX.hasOwnProperty(x)
}
}
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 10:00:01 UTC,
js,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
if (pair[0].x === pair[1].x) {
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
if (meanX !== pair[0].x && meanX === iMeanX) {
if (byMeanX[iMeanX][pair[0].y] !== undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
} else if (pair[0].y === pair[1].y) {
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
if (byMeanY[iMeanY][pair[0].x] !== undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].x]++;
}
}
}
}
let diamonds = 0;
for (let y of byMeanY) {
console.log(y);
for (let x of byMeanY[y]) {
console.log(x);
if (byMeanX.hasOwnProperty(x) && byMeanY.hasOwnProperty()
}
}
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 10:00:29 UTC,
js,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
if (pair[0].x === pair[1].x) {
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
if (meanX !== pair[0].x && meanX === iMeanX) {
if (byMeanX[iMeanX][pair[0].y] !== undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
} else if (pair[0].y === pair[1].y) {
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
if (byMeanY[iMeanY][pair[0].x] !== undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].x]++;
}
}
}
}
let diamonds = 0;
for (let y of byMeanY) {
console.log(y);
for (let x of byMeanY[y]) {
console.log(x);
if (byMeanX.hasOwnProperty(x) && byMeanY[].hasOwnProperty()
}
}
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 10:00:59 UTC,
js,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
if (pair[0].x === pair[1].x) {
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
if (meanX !== pair[0].x && meanX === iMeanX) {
if (byMeanX[iMeanX][pair[0].y] !== undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
} else if (pair[0].y === pair[1].y) {
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
if (byMeanY[iMeanY][pair[0].x] !== undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].x]++;
}
}
}
}
let diamonds = 0;
for (let y of byMeanY) {
console.log(y);
for (let x of byMeanY[y]) {
console.log(x);
if (byMeanX.hasOwnProperty(x) && byMeanY[x].hasOwnProperty(y) {
d += bMeanX[x][y]
}
}
}
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 10:01:16 UTC,
js,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
if (pair[0].x === pair[1].x) {
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
if (meanX !== pair[0].x && meanX === iMeanX) {
if (byMeanX[iMeanX][pair[0].y] !== undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
} else if (pair[0].y === pair[1].y) {
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
if (byMeanY[iMeanY][pair[0].x] !== undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].x]++;
}
}
}
}
let diamonds = 0;
for (let y of byMeanY) {
console.log(y);
for (let x of byMeanY[y]) {
console.log(x);
if (byMeanX.hasOwnProperty(x) && byMeanY[x].hasOwnProperty(y) {
d += bMeanX[x][y] * bMeanY[y][x];
}
}
}
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 10:01:36 UTC,
js,
verify,
result: Failed
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
if (pair[0].x === pair[1].x) {
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
if (meanX !== pair[0].x && meanX === iMeanX) {
if (byMeanX[iMeanX][pair[0].y] !== undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
} else if (pair[0].y === pair[1].y) {
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
if (byMeanY[iMeanY][pair[0].x] !== undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].x]++;
}
}
}
}
let diamonds = 0;
for (let y of byMeanY) {
console.log(y);
for (let x of byMeanY[y]) {
console.log(x);
if (byMeanX.hasOwnProperty(x) && byMeanY[x].hasOwnProperty(y) {
diamonds += bMeanX[x][y] * bMeanY[y][x];
}
}
}
return diamonds;
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Analysis
expand all
Example tests
1.
0.072 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
solution.js:46
if (byMeanX.hasOwnProperty(x) && byMeanY[x].hasOwnProperty(y) {
^
SyntaxError: Unexpected token {
at createScript (vm.js:80:10)
at Object.runInNewContext (vm.js:135:10)
at getSolution (/tmp/exec.js:402:29)
at Promise.resolve.then (/tmp/exec.js:436:34)
at <anonymous>
at process._tickCallback (internal/process/next_tick.js:188:7)
at Function.Module.runMain (module.js:686:11)
at startup (bootstrap_node.js:187:16)
at bootstrap_node.js:608:3
1.
0.072 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
solution.js:46
if (byMeanX.hasOwnProperty(x) && byMeanY[x].hasOwnProperty(y) {
^
SyntaxError: Unexpected token {
at createScript (vm.js:80:10)
at Object.runInNewContext (vm.js:135:10)
at getSolution (/tmp/exec.js:402:29)
at Promise.resolve.then (/tmp/exec.js:436:34)
at <anonymous>
at process._tickCallback (internal/process/next_tick.js:188:7)
at Function.Module.runMain (module.js:686:11)
at startup (bootstrap_node.js:187:16)
at bootstrap_node.js:608:3
Code: 10:01:44 UTC,
js,
verify,
result: Failed
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
if (pair[0].x === pair[1].x) {
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
if (meanX !== pair[0].x && meanX === iMeanX) {
if (byMeanX[iMeanX][pair[0].y] !== undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
} else if (pair[0].y === pair[1].y) {
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
if (byMeanY[iMeanY][pair[0].x] !== undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].x]++;
}
}
}
}
let diamonds = 0;
for (let y of byMeanY) {
console.log(y);
for (let x of byMeanY[y]) {
console.log(x);
if (byMeanX.hasOwnProperty(x) && byMeanY[x].hasOwnProperty(y)) {
diamonds += bMeanX[x][y] * bMeanY[y][x];
}
}
}
return diamonds;
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Analysis
expand all
Example tests
1.
0.072 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
TypeError: byMeanY is not iterable
at solution (solution.js:42:19)
at solutionWrapper (/tmp/exec.js:412:28)
at Promise.resolve.then (/tmp/exec.js:438:24)
at <anonymous>
at process._tickCallback (internal/process/next_tick.js:188:7)
at Function.Module.runMain (module.js:686:11)
at startup (bootstrap_node.js:187:16)
at bootstrap_node.js:608:3
1.
0.072 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
TypeError: byMeanY is not iterable
at solution (solution.js:42:19)
at solutionWrapper (/tmp/exec.js:412:28)
at Promise.resolve.then (/tmp/exec.js:438:24)
at <anonymous>
at process._tickCallback (internal/process/next_tick.js:188:7)
at Function.Module.runMain (module.js:686:11)
at startup (bootstrap_node.js:187:16)
at bootstrap_node.js:608:3
Code: 10:01:54 UTC,
js,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
if (pair[0].x === pair[1].x) {
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
if (meanX !== pair[0].x && meanX === iMeanX) {
if (byMeanX[iMeanX][pair[0].y] !== undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
} else if (pair[0].y === pair[1].y) {
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
if (byMeanY[iMeanY][pair[0].x] !== undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].x]++;
}
}
}
}
cons
let diamonds = 0;
for (let y of byMeanY) {
console.log(y);
for (let x of byMeanY[y]) {
console.log(x);
if (byMeanX.hasOwnProperty(x) && byMeanY[x].hasOwnProperty(y)) {
diamonds += bMeanX[x][y] * bMeanY[y][x];
}
}
}
return diamonds;
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 10:02:02 UTC,
js,
verify,
result: Failed
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
if (pair[0].x === pair[1].x) {
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
if (meanX !== pair[0].x && meanX === iMeanX) {
if (byMeanX[iMeanX][pair[0].y] !== undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
} else if (pair[0].y === pair[1].y) {
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
if (byMeanY[iMeanY][pair[0].x] !== undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].x]++;
}
}
}
}
console.log(byMeanY)
let diamonds = 0;
for (let y of byMeanY) {
console.log(y);
for (let x of byMeanY[y]) {
console.log(x);
if (byMeanX.hasOwnProperty(x) && byMeanY[x].hasOwnProperty(y)) {
diamonds += bMeanX[x][y] * bMeanY[y][x];
}
}
}
return diamonds;
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Analysis
expand all
Example tests
1.
0.072 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
TypeError: byMeanY is not iterable
at solution (solution.js:42:19)
at solutionWrapper (/tmp/exec.js:412:28)
at Promise.resolve.then (/tmp/exec.js:438:24)
at <anonymous>
at process._tickCallback (internal/process/next_tick.js:188:7)
at Function.Module.runMain (module.js:686:11)
at startup (bootstrap_node.js:187:16)
at bootstrap_node.js:608:3
stdout:
{}
1.
0.072 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
TypeError: byMeanY is not iterable
at solution (solution.js:42:19)
at solutionWrapper (/tmp/exec.js:412:28)
at Promise.resolve.then (/tmp/exec.js:438:24)
at <anonymous>
at process._tickCallback (internal/process/next_tick.js:188:7)
at Function.Module.runMain (module.js:686:11)
at startup (bootstrap_node.js:187:16)
at bootstrap_node.js:608:3
stdout:
{}
Code: 10:02:20 UTC,
js,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
if (pair[0].x === pair[1].x) {
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
if (meanX !== pair[0].x && meanX === iMeanX) {
if (byMeanX[iMeanX][pair[0].y] !== undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
} else if (pair[0].y === pair[1].y) {
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
console.log('here')
if (byMeanY[iMeanY][pair[0].x] !== undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].x]++;
}
}
}
}
console.log(byMeanY)
let diamonds = 0;
for (let y of byMeanY) {
console.log(y);
for (let x of byMeanY[y]) {
console.log(x);
if (byMeanX.hasOwnProperty(x) && byMeanY[x].hasOwnProperty(y)) {
diamonds += bMeanX[x][y] * bMeanY[y][x];
}
}
}
return diamonds;
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 10:02:31 UTC,
js,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
if (pair[0].x === pair[1].x) {
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
if (meanX !== pair[0].x && meanX === iMeanX) {
console.log('here')
if (byMeanX[iMeanX][pair[0].y] !== undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
} else if (pair[0].y === pair[1].y) {
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
console.log('here')
if (byMeanY[iMeanY][pair[0].x] !== undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].x]++;
}
}
}
}
console.log(byMeanY)
let diamonds = 0;
for (let y of byMeanY) {
console.log(y);
for (let x of byMeanY[y]) {
console.log(x);
if (byMeanX.hasOwnProperty(x) && byMeanY[x].hasOwnProperty(y)) {
diamonds += bMeanX[x][y] * bMeanY[y][x];
}
}
}
return diamonds;
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 10:02:31 UTC,
js,
verify,
result: Failed
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
if (pair[0].x === pair[1].x) {
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
if (meanX !== pair[0].x && meanX === iMeanX) {
console.log('here')
if (byMeanX[iMeanX][pair[0].y] !== undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
} else if (pair[0].y === pair[1].y) {
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
console.log('here')
if (byMeanY[iMeanY][pair[0].x] !== undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].x]++;
}
}
}
}
console.log(byMeanY)
let diamonds = 0;
for (let y of byMeanY) {
console.log(y);
for (let x of byMeanY[y]) {
console.log(x);
if (byMeanX.hasOwnProperty(x) && byMeanY[x].hasOwnProperty(y)) {
diamonds += bMeanX[x][y] * bMeanY[y][x];
}
}
}
return diamonds;
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Analysis
expand all
Example tests
1.
0.072 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
TypeError: byMeanY is not iterable
at solution (solution.js:44:19)
at solutionWrapper (/tmp/exec.js:412:28)
at Promise.resolve.then (/tmp/exec.js:438:24)
at <anonymous>
at process._tickCallback (internal/process/next_tick.js:188:7)
at Function.Module.runMain (module.js:686:11)
at startup (bootstrap_node.js:187:16)
at bootstrap_node.js:608:3
stdout:
{}
1.
0.072 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
TypeError: byMeanY is not iterable
at solution (solution.js:44:19)
at solutionWrapper (/tmp/exec.js:412:28)
at Promise.resolve.then (/tmp/exec.js:438:24)
at <anonymous>
at process._tickCallback (internal/process/next_tick.js:188:7)
at Function.Module.runMain (module.js:686:11)
at startup (bootstrap_node.js:187:16)
at bootstrap_node.js:608:3
stdout:
{}
Code: 10:02:44 UTC,
js,
verify,
result: Failed
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
if (pair[0].x === pair[1].x) {
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
if (meanX !== pair[0].x && meanX === iMeanX) {
console.log('here')
if (byMeanX[iMeanX][pair[0].y] !== undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
} else if (pair[0].y === pair[1].y) {
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
console.log('here')
if (byMeanY[iMeanY][pair[0].x] !== undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].x]++;
}
}
}
}
console.log(byMeanY)
let diamonds = 0;
// for (let y of byMeanY) {
// console.log(y);
// for (let x of byMeanY[y]) {
// console.log(x);
// if (byMeanX.hasOwnProperty(x) && byMeanY[x].hasOwnProperty(y)) {
// diamonds += bMeanX[x][y] * bMeanY[y][x];
// }
// }
// }
return diamonds;
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Analysis
expand all
Example tests
1.
0.080 s
WRONG ANSWER,
got 0 expected 2
stdout:
{}
1.
0.080 s
OK
stdout:
{}
Code: 10:02:51 UTC,
js,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
con
for (let pair of combinations) {
if (pair[0].x === pair[1].x) {
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
if (meanX !== pair[0].x && meanX === iMeanX) {
console.log('here')
if (byMeanX[iMeanX][pair[0].y] !== undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
} else if (pair[0].y === pair[1].y) {
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
console.log('here')
if (byMeanY[iMeanY][pair[0].x] !== undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].x]++;
}
}
}
}
console.log(byMeanY)
let diamonds = 0;
// for (let y of byMeanY) {
// console.log(y);
// for (let x of byMeanY[y]) {
// console.log(x);
// if (byMeanX.hasOwnProperty(x) && byMeanY[x].hasOwnProperty(y)) {
// diamonds += bMeanX[x][y] * bMeanY[y][x];
// }
// }
// }
return diamonds;
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 10:02:59 UTC,
js,
verify,
result: Failed
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
console.log(combinations);
for (let pair of combinations) {
if (pair[0].x === pair[1].x) {
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
if (meanX !== pair[0].x && meanX === iMeanX) {
console.log('here')
if (byMeanX[iMeanX][pair[0].y] !== undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
} else if (pair[0].y === pair[1].y) {
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
console.log('here')
if (byMeanY[iMeanY][pair[0].x] !== undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].x]++;
}
}
}
}
console.log(byMeanY)
let diamonds = 0;
// for (let y of byMeanY) {
// console.log(y);
// for (let x of byMeanY[y]) {
// console.log(x);
// if (byMeanX.hasOwnProperty(x) && byMeanY[x].hasOwnProperty(y)) {
// diamonds += bMeanX[x][y] * bMeanY[y][x];
// }
// }
// }
return diamonds;
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Analysis
expand all
Example tests
1.
0.076 s
WRONG ANSWER,
got 0 expected 2
stdout:
[ [ { x: 1, y: 3 }, { x: 1, y: 4 } ],
[ { x: 1, y: 3 }, { x: 2, y: 1 } ],
[ { x: 1, y: 3 }, { x: 2, y: 3 } ],
[ { x: 1, y: 3 }, { x: 2, y: 5 } ],
[ { x: 1, y: 3 }, { x: 3, y: 3 } ],
[ { x: 1, y: 3 }, { x: 3, y: 4 } ],
[ { x: 1, y: 4 }, { x: 2, y: 1 } ],
[ { x: 1, y: 4 }, { x: 2, y: 3 } ],
[ { x: 1, y: 4 }, { x: 2, y: 5 } ],
[ { x: 1, y: 4 }, { x: 3, y: 3 } ],
[ { x: 1, y: 4 }, { x: 3, y: 4 } ],
[ { x: 2, y: 1 }, { x: 2, y: 3 } ],
[ { x: 2, y: 1 }, { x: 2, y: 5 } ],
[ { x: 2, y: 1 }, { x: 3, y: 3 } ],
[ { x: 2, y: 1 }, { x: 3, y: 4 } ],
[ { x: 2, y: 3 }, { x: 2, y: 5 } ],
[ { x: 2, y: 3 }, { x: 3, y: 3 } ],
[ { x: 2, y: 3 }, { x: 3, y: 4 } ],
[ { x: 2, y: 5 }, { x: 3, y: 3 } ],
[ { x: 2, y: 5 }, { x: 3, y: 4 } ],
[ { x: 3, y: 3 }, { x: 3, y: 4 } ] ]
{}
1.
0.076 s
OK
stdout:
[ [ { x: 1, y: 1 }, { x: 2, y: 1 } ],
[ { x: 1, y: 1 }, { x: 3, y: 1 } ],
[ { x: 1, y: 1 }, { x: 3, y: 2 } ],
[ { x: 1, y: 1 }, { x: 2, y: 2 } ],
[ { x: 1, y: 1 }, { x: 1, y: 2 } ],
[ { x: 2, y: 1 }, { x: 3, y: 1 } ],
[ { x: 2, y: 1 }, { x: 3, y: 2 } ],
[ { x: 2, y: 1 }, { x: 2, y: 2 } ],
[ { x: 2, y: 1 }, { x: 1, y: 2 } ],
[ { x: 3, y: 1 }, { x: 3, y: 2 } ],
[ { x: 3, y: 1 }, { x: 2, y: 2 } ],
[ { x: 3, y: 1 }, { x: 1, y: 2 } ],
[ { x: 3, y: 2 }, { x: 2, y: 2 } ],
[ { x: 3, y: 2 }, { x: 1, y: 2 } ],
[ { x: 2, y: 2 }, { x: 1, y: 2 } ] ]
{}
Code: 10:03:21 UTC,
js,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
console.log(combinations);
for (let pair of combinations) {
if (pair[0].x === pair[1].x) {
consol
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
if (meanX !== pair[0].x && meanX === iMeanX) {
console.log('here')
if (byMeanX[iMeanX][pair[0].y] !== undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
} else if (pair[0].y === pair[1].y) {
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
console.log('here')
if (byMeanY[iMeanY][pair[0].x] !== undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].x]++;
}
}
}
}
console.log(byMeanY)
let diamonds = 0;
// for (let y of byMeanY) {
// console.log(y);
// for (let x of byMeanY[y]) {
// console.log(x);
// if (byMeanX.hasOwnProperty(x) && byMeanY[x].hasOwnProperty(y)) {
// diamonds += bMeanX[x][y] * bMeanY[y][x];
// }
// }
// }
return diamonds;
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 10:03:36 UTC,
js,
verify,
result: Failed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
console.log(combinations);
for (let pair of combinations) {
if (pair[0].x === pair[1].x) {
console.log('x equal')
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
if (meanX !== pair[0].x && meanX === iMeanX) {
console.log('here')
if (byMeanX[iMeanX][pair[0].y] !== undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
} else if (pair[0].y === pair[1].y) {
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
console.log('here')
if (byMeanY[iMeanY][pair[0].x] !== undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].x]++;
}
}
}
}
console.log(byMeanY)
let diamonds = 0;
// for (let y of byMeanY) {
// console.log(y);
// for (let x of byMeanY[y]) {
// console.log(x);
// if (byMeanX.hasOwnProperty(x) && byMeanY[x].hasOwnProperty(y)) {
// diamonds += bMeanX[x][y] * bMeanY[y][x];
// }
// }
// }
return diamonds;
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Analysis
expand all
Example tests
1.
0.084 s
WRONG ANSWER,
got 0 expected 2
stdout:
[ [ { x: 1, y: 3 }, { x: 1, y: 4 } ],
[ { x: 1, y: 3 }, { x: 2, y: 1 } ],
[ { x: 1, y: 3 }, { x: 2, y: 3 } ],
[ { x: 1, y: 3 }, { x: 2, y: 5 } ],
[ { x: 1, y: 3 }, { x: 3, y: 3 } ],
[ { x: 1, y: 3 }, { x: 3, y: 4 } ],
[ { x: 1, y: 4 }, { x: 2, y: 1 } ],
[ { x: 1, y: 4 }, { x: 2, y: 3 } ],
[ { x: 1, y: 4 }, { x: 2, y: 5 } ],
[ { x: 1, y: 4 }, { x: 3, y: 3 } ],
[ { x: 1, y: 4 }, { x: 3, y: 4 } ],
[ { x: 2, y: 1 }, { x: 2, y: 3 } ],
[ { x: 2, y: 1 }, { x: 2, y: 5 } ],
[ { x: 2, y: 1 }, { x: 3, y: 3 } ],
[ { x: 2, y: 1 }, { x: 3, y: 4 } ],
[ { x: 2, y: 3 }, { x: 2, y: 5 } ],
[ { x: 2, y: 3 }, { x: 3, y: 3 } ],
[ { x: 2, y: 3 }, { x: 3, y: 4 } ],
[ { x: 2, y: 5 }, { x: 3, y: 3 } ],
[ { x: 2, y: 5 }, { x: 3, y: 4 } ],
[ { x: 3, y: 3 }, { x: 3, y: 4 } ] ]
x equal
x equal
x equal
x equal
x equal
{}
1.
0.084 s
OK
stdout:
[ [ { x: 1, y: 1 }, { x: 2, y: 1 } ],
[ { x: 1, y: 1 }, { x: 3, y: 1 } ],
[ { x: 1, y: 1 }, { x: 3, y: 2 } ],
[ { x: 1, y: 1 }, { x: 2, y: 2 } ],
[ { x: 1, y: 1 }, { x: 1, y: 2 } ],
[ { x: 2, y: 1 }, { x: 3, y: 1 } ],
[ { x: 2, y: 1 }, { x: 3, y: 2 } ],
[ { x: 2, y: 1 }, { x: 2, y: 2 } ],
[ { x: 2, y: 1 }, { x: 1, y: 2 } ],
[ { x: 3, y: 1 }, { x: 3, y: 2 } ],
[ { x: 3, y: 1 }, { x: 2, y: 2 } ],
[ { x: 3, y: 1 }, { x: 1, y: 2 } ],
[ { x: 3, y: 2 }, { x: 2, y: 2 } ],
[ { x: 3, y: 2 }, { x: 1, y: 2 } ],
[ { x: 2, y: 2 }, { x: 1, y: 2 } ] ]
x equal
x equal
x equal
{}
Code: 10:03:51 UTC,
js,
verify,
result: Failed
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
console.log(combinations);
for (let pair of combinations) {
if (pair[0].x === pair[1].x) {
console.log('x equal')
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
if (meanX !== pair[0].x && meanX === iMeanX) {
console.log('here')
if (byMeanX[iMeanX][pair[0].y] !== undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
} else if (pair[0].y === pair[1].y) {
console.log('y equal')
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
console.log('here')
if (byMeanY[iMeanY][pair[0].x] !== undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].x]++;
}
}
}
}
console.log(byMeanY)
let diamonds = 0;
// for (let y of byMeanY) {
// console.log(y);
// for (let x of byMeanY[y]) {
// console.log(x);
// if (byMeanX.hasOwnProperty(x) && byMeanY[x].hasOwnProperty(y)) {
// diamonds += bMeanX[x][y] * bMeanY[y][x];
// }
// }
// }
return diamonds;
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Analysis
expand all
Example tests
1.
0.076 s
WRONG ANSWER,
got 0 expected 2
stdout:
[ [ { x: 1, y: 3 }, { x: 1, y: 4 } ],
[ { x: 1, y: 3 }, { x: 2, y: 1 } ],
[ { x: 1, y: 3 }, { x: 2, y: 3 } ],
[ { x: 1, y: 3 }, { x: 2, y: 5 } ],
[ { x: 1, y: 3 }, { x: 3, y: 3 } ],
[ { x: 1, y: 3 }, { x: 3, y: 4 } ],
[ { x: 1, y: 4 }, { x: 2, y: 1 } ],
[ { x: 1, y: 4 }, { x: 2, y: 3 } ],
[ { x: 1, y: 4 }, { x: 2, y: 5 } ],
[ { x: 1, y: 4 }, { x: 3, y: 3 } ],
[ { x: 1, y: 4 }, { x: 3, y: 4 } ],
[ { x: 2, y: 1 }, { x: 2, y: 3 } ],
[ { x: 2, y: 1 }, { x: 2, y: 5 } ],
[ { x: 2, y: 1 }, { x: 3, y: 3 } ],
[ { x: 2, y: 1 }, { x: 3, y: 4 } ],
[ { x: 2, y: 3 }, { x: 2, y: 5 } ],
[ { x: 2, y: 3 }, { x: 3, y: 3 } ],
[ { x: 2, y: 3 }, { x: 3, y: 4 } ],
[ { x: 2, y: 5 }, { x: 3, y: 3 } ],
[ { x: 2, y: 5 }, { x: 3, y: 4 } ],
[ { x: 3, y: 3 }, { x: 3, y: 4 } ] ]
x equal
y equal
y equal
y equal
x equal
x equal
x equal
y equal
x equal
{}
1.
0.076 s
OK
stdout:
[ [ { x: 1, y: 1 }, { x: 2, y: 1 } ],
[ { x: 1, y: 1 }, { x: 3, y: 1 } ],
[ { x: 1, y: 1 }, { x: 3, y: 2 } ],
[ { x: 1, y: 1 }, { x: 2, y: 2 } ],
[ { x: 1, y: 1 }, { x: 1, y: 2 } ],
[ { x: 2, y: 1 }, { x: 3, y: 1 } ],
[ { x: 2, y: 1 }, { x: 3, y: 2 } ],
[ { x: 2, y: 1 }, { x: 2, y: 2 } ],
[ { x: 2, y: 1 }, { x: 1, y: 2 } ],
[ { x: 3, y: 1 }, { x: 3, y: 2 } ],
[ { x: 3, y: 1 }, { x: 2, y: 2 } ],
[ { x: 3, y: 1 }, { x: 1, y: 2 } ],
[ { x: 3, y: 2 }, { x: 2, y: 2 } ],
[ { x: 3, y: 2 }, { x: 1, y: 2 } ],
[ { x: 2, y: 2 }, { x: 1, y: 2 } ] ]
y equal
y equal
x equal
y equal
x equal
x equal
y equal
y equal
y equal
{}
Code: 10:04:30 UTC,
js,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
console.log(combinations);
for (let pair of combinations) {
if (pair[0].x === pair[1].x) {
console.log('x equal')
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
if (meanX !== pair[0].x && meanX === iMeanX) {
console.log('here')
if (byMeanX[iMeanX][pair[0].y] !== undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
} else if (pair[0].y === pair[1].y) {
console.log('y equal')
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
console.log('here')
if (byMeanY[iMeanY][pair[0].x] !== undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].x]++;
}
}
}
}
console.log(byMeanY)
let diamonds = 0;
// for (let y of byMeanY) {
// console.log(y);
// for (let x of byMeanY[y]) {
// console.log(x);
// if (byMeanX.hasOwnProperty(x) && byMeanY[x].hasOwnProperty(y)) {
// diamonds += bMeanX[x][y] * bMeanY[y][x];
// }
// }
// }
return diamonds;
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 10:04:50 UTC,
js,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
console.log(combinations);
for (let pair of combinations) {
if (pair[0].x === pair[1].x) {
console.log('x equal')
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
console.log('meanX, iMeanX:', )
if (meanX !== pair[0].x && meanX === iMeanX) {
console.log('here')
if (byMeanX[iMeanX][pair[0].y] !== undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
} else if (pair[0].y === pair[1].y) {
console.log('y equal')
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
console.log('here')
if (byMeanY[iMeanY][pair[0].x] !== undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].x]++;
}
}
}
}
console.log(byMeanY)
let diamonds = 0;
// for (let y of byMeanY) {
// console.log(y);
// for (let x of byMeanY[y]) {
// console.log(x);
// if (byMeanX.hasOwnProperty(x) && byMeanY[x].hasOwnProperty(y)) {
// diamonds += bMeanX[x][y] * bMeanY[y][x];
// }
// }
// }
return diamonds;
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 10:04:55 UTC,
js,
verify,
result: Failed
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
console.log(combinations);
for (let pair of combinations) {
if (pair[0].x === pair[1].x) {
console.log('x equal')
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
console.log('meanX, iMeanX:', meanX, iMeanX)
if (meanX !== pair[0].x && meanX === iMeanX) {
console.log('here')
if (byMeanX[iMeanX][pair[0].y] !== undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
} else if (pair[0].y === pair[1].y) {
console.log('y equal')
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
console.log('here')
if (byMeanY[iMeanY][pair[0].x] !== undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].x]++;
}
}
}
}
console.log(byMeanY)
let diamonds = 0;
// for (let y of byMeanY) {
// console.log(y);
// for (let x of byMeanY[y]) {
// console.log(x);
// if (byMeanX.hasOwnProperty(x) && byMeanY[x].hasOwnProperty(y)) {
// diamonds += bMeanX[x][y] * bMeanY[y][x];
// }
// }
// }
return diamonds;
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Analysis
expand all
Example tests
1.
0.084 s
WRONG ANSWER,
got 0 expected 2
stdout:
[ [ { x: 1, y: 3 }, { x: 1, y: 4 } ],
[ { x: 1, y: 3 }, { x: 2, y: 1 } ],
[ { x: 1, y: 3 }, { x: 2, y: 3 } ],
[ { x: 1, y: 3 }, { x: 2, y: 5 } ],
[ { x: 1, y: 3 }, { x: 3, y: 3 } ],
[ { x: 1, y: 3 }, { x: 3, y: 4 } ],
[ { x: 1, y: 4 }, { x: 2, y: 1 } ],
[ { x: 1, y: 4 }, { x: 2, y: 3 } ],
[ { x: 1, y: 4 }, { x: 2, y: 5 } ],
[ { x: 1, y: 4 }, { x: 3, y: 3 } ],
[ { x: 1, y: 4 }, { x: 3, y: 4 } ],
[ { x: 2, y: 1 }, { x: 2, y: 3 } ],
[ { x: 2, y: 1 }, { x: 2, y: 5 } ],
[ { x: 2, y: 1 }, { x: 3, y: 3 } ],
[ { x: 2, y: 1 }, { x: 3, y: 4 } ],
[ { x: 2, y: 3 }, { x: 2, y: 5 } ],
[ { x: 2, y: 3 }, { x: 3, y: 3 } ],
[ { x: 2, y: 3 }, { x: 3, y: 4 } ],
[ { x: 2, y: 5 }, { x: 3, y: 3 } ],
[ { x: 2, y: 5 }, { x: 3, y: 4 } ],
[ { x: 3, y: 3 }, { x: 3, y: 4 } ] ]
x equal
meanX, iMeanX: 1 1
y equal
y equal
y equal
x equal
meanX, iMeanX: 2 2
x equal
meanX, iMeanX: 2 2
x equal
meanX, iMeanX: 2 2
y equal
x equal
meanX, iMeanX: 3 3
{}
1.
0.084 s
OK
stdout:
[ [ { x: 1, y: 1 }, { x: 2, y: 1 } ],
[ { x: 1, y: 1 }, { x: 3, y: 1 } ],
[ { x: 1, y: 1 }, { x: 3, y: 2 } ],
[ { x: 1, y: 1 }, { x: 2, y: 2 } ],
[ { x: 1, y: 1 }, { x: 1, y: 2 } ],
[ { x: 2, y: 1 }, { x: 3, y: 1 } ],
[ { x: 2, y: 1 }, { x: 3, y: 2 } ],
[ { x: 2, y: 1 }, { x: 2, y: 2 } ],
[ { x: 2, y: 1 }, { x: 1, y: 2 } ],
[ { x: 3, y: 1 }, { x: 3, y: 2 } ],
[ { x: 3, y: 1 }, { x: 2, y: 2 } ],
[ { x: 3, y: 1 }, { x: 1, y: 2 } ],
[ { x: 3, y: 2 }, { x: 2, y: 2 } ],
[ { x: 3, y: 2 }, { x: 1, y: 2 } ],
[ { x: 2, y: 2 }, { x: 1, y: 2 } ] ]
y equal
y equal
x equal
meanX, iMeanX: 1 1
y equal
x equal
meanX, iMeanX: 2 2
x equal
meanX, iMeanX: 3 3
y equal
y equal
y equal
{}
Code: 10:05:20 UTC,
js,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
console.log(combinations);
for (let pair of combinations) {
if (pair[0].x === pair[1].x) {
console.log('x equal')
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
console.log('p.x meanX, iMeanX:', meanX, iMeanX)
if (meanX !== pair[0].x && meanX === iMeanX) {
console.log('here')
if (byMeanX[iMeanX][pair[0].y] !== undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
} else if (pair[0].y === pair[1].y) {
console.log('y equal')
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
console.log('here')
if (byMeanY[iMeanY][pair[0].x] !== undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].x]++;
}
}
}
}
console.log(byMeanY)
let diamonds = 0;
// for (let y of byMeanY) {
// console.log(y);
// for (let x of byMeanY[y]) {
// console.log(x);
// if (byMeanX.hasOwnProperty(x) && byMeanY[x].hasOwnProperty(y)) {
// diamonds += bMeanX[x][y] * bMeanY[y][x];
// }
// }
// }
return diamonds;
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 10:05:30 UTC,
js,
verify,
result: Failed
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
console.log(combinations);
for (let pair of combinations) {
if (pair[0].x === pair[1].x) {
console.log('x equal')
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
console.log('p.x meanX, iMeanX:',pair[0].x, meanX, iMeanX)
if (meanX !== pair[0].x && meanX === iMeanX) {
console.log('here')
if (byMeanX[iMeanX][pair[0].y] !== undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
} else if (pair[0].y === pair[1].y) {
console.log('y equal')
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
console.log('here')
if (byMeanY[iMeanY][pair[0].x] !== undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].x]++;
}
}
}
}
console.log(byMeanY)
let diamonds = 0;
// for (let y of byMeanY) {
// console.log(y);
// for (let x of byMeanY[y]) {
// console.log(x);
// if (byMeanX.hasOwnProperty(x) && byMeanY[x].hasOwnProperty(y)) {
// diamonds += bMeanX[x][y] * bMeanY[y][x];
// }
// }
// }
return diamonds;
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Analysis
expand all
Example tests
1.
0.076 s
WRONG ANSWER,
got 0 expected 2
stdout:
[ [ { x: 1, y: 3 }, { x: 1, y: 4 } ],
[ { x: 1, y: 3 }, { x: 2, y: 1 } ],
[ { x: 1, y: 3 }, { x: 2, y: 3 } ],
[ { x: 1, y: 3 }, { x: 2, y: 5 } ],
[ { x: 1, y: 3 }, { x: 3, y: 3 } ],
[ { x: 1, y: 3 }, { x: 3, y: 4 } ],
[ { x: 1, y: 4 }, { x: 2, y: 1 } ],
[ { x: 1, y: 4 }, { x: 2, y: 3 } ],
[ { x: 1, y: 4 }, { x: 2, y: 5 } ],
[ { x: 1, y: 4 }, { x: 3, y: 3 } ],
[ { x: 1, y: 4 }, { x: 3, y: 4 } ],
[ { x: 2, y: 1 }, { x: 2, y: 3 } ],
[ { x: 2, y: 1 }, { x: 2, y: 5 } ],
[ { x: 2, y: 1 }, { x: 3, y: 3 } ],
[ { x: 2, y: 1 }, { x: 3, y: 4 } ],
[ { x: 2, y: 3 }, { x: 2, y: 5 } ],
[ { x: 2, y: 3 }, { x: 3, y: 3 } ],
[ { x: 2, y: 3 }, { x: 3, y: 4 } ],
[ { x: 2, y: 5 }, { x: 3, y: 3 } ],
[ { x: 2, y: 5 }, { x: 3, y: 4 } ],
[ { x: 3, y: 3 }, { x: 3, y: 4 } ] ]
x equal
p.x meanX, iMeanX: 1 1 1
y equal
y equal
y equal
x equal
p.x meanX, iMeanX: 2 2 2
x equal
p.x meanX, iMeanX: 2 2 2
x equal
p.x meanX, iMeanX: 2 2 2
y equal
x equal
p.x meanX, iMeanX: 3 3 3
{}
1.
0.076 s
OK
stdout:
[ [ { x: 1, y: 1 }, { x: 2, y: 1 } ],
[ { x: 1, y: 1 }, { x: 3, y: 1 } ],
[ { x: 1, y: 1 }, { x: 3, y: 2 } ],
[ { x: 1, y: 1 }, { x: 2, y: 2 } ],
[ { x: 1, y: 1 }, { x: 1, y: 2 } ],
[ { x: 2, y: 1 }, { x: 3, y: 1 } ],
[ { x: 2, y: 1 }, { x: 3, y: 2 } ],
[ { x: 2, y: 1 }, { x: 2, y: 2 } ],
[ { x: 2, y: 1 }, { x: 1, y: 2 } ],
[ { x: 3, y: 1 }, { x: 3, y: 2 } ],
[ { x: 3, y: 1 }, { x: 2, y: 2 } ],
[ { x: 3, y: 1 }, { x: 1, y: 2 } ],
[ { x: 3, y: 2 }, { x: 2, y: 2 } ],
[ { x: 3, y: 2 }, { x: 1, y: 2 } ],
[ { x: 2, y: 2 }, { x: 1, y: 2 } ] ]
y equal
y equal
x equal
p.x meanX, iMeanX: 1 1 1
y equal
x equal
p.x meanX, iMeanX: 2 2 2
x equal
p.x meanX, iMeanX: 3 3 3
y equal
y equal
y equal
{}
Code: 10:06:11 UTC,
js,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
console.log(combinations);
for (let pair of combinations) {
if (pair[0].y === pair[1].x) {
console.log('x equal')
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
console.log('p.x meanX, iMeanX:',pair[0].x, meanX, iMeanX)
if (meanX !== pair[0].x && meanX === iMeanX) {
console.log('here')
if (byMeanX[iMeanX][pair[0].y] !== undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
} else if (pair[0].y === pair[1].y) {
console.log('y equal')
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
console.log('here')
if (byMeanY[iMeanY][pair[0].x] !== undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].x]++;
}
}
}
}
console.log(byMeanY)
let diamonds = 0;
// for (let y of byMeanY) {
// console.log(y);
// for (let x of byMeanY[y]) {
// console.log(x);
// if (byMeanX.hasOwnProperty(x) && byMeanY[x].hasOwnProperty(y)) {
// diamonds += bMeanX[x][y] * bMeanY[y][x];
// }
// }
// }
return diamonds;
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 10:06:28 UTC,
js,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
console.log(combinations);
for (let pair of combinations) {
if (pair[0].y === pair[1].y) {
console.log('y equal')
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
console.log('p.x meanX, iMeanX:',pair[0].x, meanX, iMeanX)
if (meanX !== pair[0].x && meanX === iMeanX) {
console.log('here')
if (byMeanX[iMeanX][pair[0].y] !== undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
} else if (pair[0].x === pair[1].x) {
console.log('x equal')
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
console.log('here')
if (byMeanY[iMeanY][pair[0].x] !== undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].x]++;
}
}
}
}
console.log(byMeanY)
let diamonds = 0;
// for (let y of byMeanY) {
// console.log(y);
// for (let x of byMeanY[y]) {
// console.log(x);
// if (byMeanX.hasOwnProperty(x) && byMeanY[x].hasOwnProperty(y)) {
// diamonds += bMeanX[x][y] * bMeanY[y][x];
// }
// }
// }
return diamonds;
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 10:06:34 UTC,
js,
verify,
result: Failed
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
console.log(combinations);
for (let pair of combinations) {
if (pair[0].y === pair[1].y) {
console.log('y equal')
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
console.log('p.x meanX, iMeanX:',pair[0].x, meanX, iMeanX)
if (meanX !== pair[0].x && meanX === iMeanX) {
console.log('here')
if (byMeanX[iMeanX][pair[0].y] !== undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
} else if (pair[0].x === pair[1].x) {
console.log('x equal')
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
console.log('here')
if (byMeanY[iMeanY][pair[0].x] !== undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].x]++;
}
}
}
}
console.log(byMeanY)
let diamonds = 0;
// for (let y of byMeanY) {
// console.log(y);
// for (let x of byMeanY[y]) {
// console.log(x);
// if (byMeanX.hasOwnProperty(x) && byMeanY[x].hasOwnProperty(y)) {
// diamonds += bMeanX[x][y] * bMeanY[y][x];
// }
// }
// }
return diamonds;
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Analysis
expand all
Example tests
1.
0.076 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
TypeError: Cannot read property '3' of undefined
at solution (solution.js:25:36)
at solutionWrapper (/tmp/exec.js:412:28)
at Promise.resolve.then (/tmp/exec.js:438:24)
at <anonymous>
at process._tickCallback (internal/process/next_tick.js:188:7)
at Function.Module.runMain (module.js:686:11)
at startup (bootstrap_node.js:187:16)
at bootstrap_node.js:608:3
stdout:
[ [ { x: 1, y: 3 }, { x: 1, y: 4 } ],
[ { x: 1, y: 3 }, { x: 2, y: 1 } ],
[ { x: 1, y: 3 }, { x: 2, y: 3 } ],
[ { x: 1, y: 3 }, { x: 2, y: 5 } ],
[ { x: 1, y: 3 }, { x: 3, y: 3 } ],
[ { x: 1, y: 3 }, { x: 3, y: 4 } ],
[ { x: 1, y: 4 }, { x: 2, y: 1 } ],
[ { x: 1, y: 4 }, { x: 2, y: 3 } ],
[ { x: 1, y: 4 }, { x: 2, y: 5 } ],
[ { x: 1, y: 4 }, { x: 3, y: 3 } ],
[ { x: 1, y: 4 }, { x: 3, y: 4 } ],
[ { x: 2, y: 1 }, { x: 2, y: 3 } ],
[ { x: 2, y: 1 }, { x: 2, y: 5 } ],
[ { x: 2, y: 1 }, { x: 3, y: 3 } ],
[ { x: 2, y: 1 }, { x: 3, y: 4 } ],
[ { x: 2, y: 3 }, { x: 2, y: 5 } ],
[ { x: 2, y: 3 }, { x: 3, y: 3 } ],
[ { x: 2, y: 3 }, { x: 3, y: 4 } ],
[ { x: 2, y: 5 }, { x: 3, y: 3 } ],
[ { x: 2, y: 5 }, { x: 3, y: 4 } ],
[ { x: 3, y: 3 }, { x: 3, y: 4 } ] ]
x equal
y equal
p.x meanX, iMeanX: 1 1.5 1
y equal
p.x meanX, iMeanX: 1 2 2
here
1.
0.076 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
TypeError: Cannot read property '1' of undefined
at solution (solution.js:25:36)
at solutionWrapper (/tmp/exec.js:412:28)
at Promise.resolve.then (/tmp/exec.js:438:24)
at <anonymous>
at process._tickCallback (internal/process/next_tick.js:188:7)
at Function.Module.runMain (module.js:686:11)
at startup (bootstrap_node.js:187:16)
at bootstrap_node.js:608:3
stdout:
[ [ { x: 1, y: 1 }, { x: 2, y: 1 } ],
[ { x: 1, y: 1 }, { x: 3, y: 1 } ],
[ { x: 1, y: 1 }, { x: 3, y: 2 } ],
[ { x: 1, y: 1 }, { x: 2, y: 2 } ],
[ { x: 1, y: 1 }, { x: 1, y: 2 } ],
[ { x: 2, y: 1 }, { x: 3, y: 1 } ],
[ { x: 2, y: 1 }, { x: 3, y: 2 } ],
[ { x: 2, y: 1 }, { x: 2, y: 2 } ],
[ { x: 2, y: 1 }, { x: 1, y: 2 } ],
[ { x: 3, y: 1 }, { x: 3, y: 2 } ],
[ { x: 3, y: 1 }, { x: 2, y: 2 } ],
[ { x: 3, y: 1 }, { x: 1, y: 2 } ],
[ { x: 3, y: 2 }, { x: 2, y: 2 } ],
[ { x: 3, y: 2 }, { x: 1, y: 2 } ],
[ { x: 2, y: 2 }, { x: 1, y: 2 } ] ]
y equal
p.x meanX, iMeanX: 1 1.5 1
y equal
p.x meanX, iMeanX: 1 2 2
here
Code: 10:07:13 UTC,
js,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
console.log(combinations);
for (let pair of combinations) {
if (pair[0].y === pair[1].y) {
console.log('y equal')
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
console.log('p.x meanX, iMeanX:',pair[0].x, meanX, iMeanX)
if (meanX !== pair[0].x && meanX === iMeanX) {
console.log('here')
if (byMeanX[iMeanX][pair[0].y] !== undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
} else if (pair[0].x === pair[1].x) {
console.log('x equal')
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
console.log('here')
if (byMeanY[iMeanY][pair[0].x] !== undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].x]++;
}
}
}
}
console.log(byMeanY)
let diamonds = 0;
// for (let y of byMeanY) {
// console.log(y);
// for (let x of byMeanY[y]) {
// console.log(x);
// if (byMeanX.hasOwnProperty(x) && byMeanY[x].hasOwnProperty(y)) {
// diamonds += bMeanX[x][y] * bMeanY[y][x];
// }
// }
// }
return diamonds;
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 10:07:39 UTC,
js,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
console.log(combinations);
for (let pair of combinations) {
if (pair[0].y === pair[1].y) {
console.log('y equal')
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
console.log('p.x meanX, iMeanX:',pair[0].x, meanX, iMeanX)
if (meanX !== pair[0].x && meanX === iMeanX) {
console.log('here')
if (byMeanX[iMeanX] === undefined)
if (byMeanX[iMeanX][pair[0].y] !== undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
} else if (pair[0].x === pair[1].x) {
console.log('x equal')
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
console.log('here')
if (byMeanY[iMeanY][pair[0].x] !== undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].x]++;
}
}
}
}
console.log(byMeanY)
let diamonds = 0;
// for (let y of byMeanY) {
// console.log(y);
// for (let x of byMeanY[y]) {
// console.log(x);
// if (byMeanX.hasOwnProperty(x) && byMeanY[x].hasOwnProperty(y)) {
// diamonds += bMeanX[x][y] * bMeanY[y][x];
// }
// }
// }
return diamonds;
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 10:07:51 UTC,
js,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
console.log(combinations);
for (let pair of combinations) {
if (pair[0].y === pair[1].y) {
console.log('y equal')
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
console.log('p.x meanX, iMeanX:',pair[0].x, meanX, iMeanX)
if (meanX !== pair[0].x && meanX === iMeanX) {
console.log('here')
if (byMeanX[iMeanX] === undefined) {
}
if (byMeanX[iMeanX][pair[0].y] === undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
} else if (pair[0].x === pair[1].x) {
console.log('x equal')
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
console.log('here')
if (byMeanY[iMeanY][pair[0].x] !== undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].x]++;
}
}
}
}
console.log(byMeanY)
let diamonds = 0;
// for (let y of byMeanY) {
// console.log(y);
// for (let x of byMeanY[y]) {
// console.log(x);
// if (byMeanX.hasOwnProperty(x) && byMeanY[x].hasOwnProperty(y)) {
// diamonds += bMeanX[x][y] * bMeanY[y][x];
// }
// }
// }
return diamonds;
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 10:08:01 UTC,
js,
verify,
result: Failed
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
console.log(combinations);
for (let pair of combinations) {
if (pair[0].y === pair[1].y) {
console.log('y equal')
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
console.log('p.x meanX, iMeanX:',pair[0].x, meanX, iMeanX)
if (meanX !== pair[0].x && meanX === iMeanX) {
console.log('here')
if (byMeanX[iMeanX] === undefined) {
byMeanX[iMeanX] = {};
}
if (byMeanX[iMeanX][pair[0].y] === undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
} else if (pair[0].x === pair[1].x) {
console.log('x equal')
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
console.log('here')
if (byMeanY[iMeanY][pair[0].x] !== undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].x]++;
}
}
}
}
console.log(byMeanY)
let diamonds = 0;
// for (let y of byMeanY) {
// console.log(y);
// for (let x of byMeanY[y]) {
// console.log(x);
// if (byMeanX.hasOwnProperty(x) && byMeanY[x].hasOwnProperty(y)) {
// diamonds += bMeanX[x][y] * bMeanY[y][x];
// }
// }
// }
return diamonds;
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Analysis
expand all
Example tests
1.
0.072 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
TypeError: Cannot read property '2' of undefined
at solution (solution.js:40:36)
at solutionWrapper (/tmp/exec.js:412:28)
at Promise.resolve.then (/tmp/exec.js:438:24)
at <anonymous>
at process._tickCallback (internal/process/next_tick.js:188:7)
at Function.Module.runMain (module.js:686:11)
at startup (bootstrap_node.js:187:16)
at bootstrap_node.js:608:3
stdout:
[ [ { x: 1, y: 3 }, { x: 1, y: 4 } ],
[ { x: 1, y: 3 }, { x: 2, y: 1 } ],
[ { x: 1, y: 3 }, { x: 2, y: 3 } ],
[ { x: 1, y: 3 }, { x: 2, y: 5 } ],
[ { x: 1, y: 3 }, { x: 3, y: 3 } ],
[ { x: 1, y: 3 }, { x: 3, y: 4 } ],
[ { x: 1, y: 4 }, { x: 2, y: 1 } ],
[ { x: 1, y: 4 }, { x: 2, y: 3 } ],
[ { x: 1, y: 4 }, { x: 2, y: 5 } ],
[ { x: 1, y: 4 }, { x: 3, y: 3 } ],
[ { x: 1, y: 4 }, { x: 3, y: 4 } ],
[ { x: 2, y: 1 }, { x: 2, y: 3 } ],
[ { x: 2, y: 1 }, { x: 2, y: 5 } ],
[ { x: 2, y: 1 }, { x: 3, y: 3 } ],
[ { x: 2, y: 1 }, { x: 3, y: 4 } ],
[ { x: 2, y: 3 }, { x: 2, y: 5 } ],
[ { x: 2, y: 3 }, { x: 3, y: 3 } ],
[ { x: 2, y: 3 }, { x: 3, y: 4 } ],
[ { x: 2, y: 5 }, { x: 3, y: 3 } ],
[ { x: 2, y: 5 }, { x: 3, y: 4 } ],
[ { x: 3, y: 3 }, { x: 3, y: 4 } ] ]
x equal
y equal
p.x meanX, iMeanX: 1 1.5 1
y equal
p.x meanX, iMeanX: 1 2 2
here
y equal
p.x meanX, iMeanX: 1 2 2
here
x equal
here
1.
0.072 s
OK
stdout:
[ [ { x: 1, y: 1 }, { x: 2, y: 1 } ],
[ { x: 1, y: 1 }, { x: 3, y: 1 } ],
[ { x: 1, y: 1 }, { x: 3, y: 2 } ],
[ { x: 1, y: 1 }, { x: 2, y: 2 } ],
[ { x: 1, y: 1 }, { x: 1, y: 2 } ],
[ { x: 2, y: 1 }, { x: 3, y: 1 } ],
[ { x: 2, y: 1 }, { x: 3, y: 2 } ],
[ { x: 2, y: 1 }, { x: 2, y: 2 } ],
[ { x: 2, y: 1 }, { x: 1, y: 2 } ],
[ { x: 3, y: 1 }, { x: 3, y: 2 } ],
[ { x: 3, y: 1 }, { x: 2, y: 2 } ],
[ { x: 3, y: 1 }, { x: 1, y: 2 } ],
[ { x: 3, y: 2 }, { x: 2, y: 2 } ],
[ { x: 3, y: 2 }, { x: 1, y: 2 } ],
[ { x: 2, y: 2 }, { x: 1, y: 2 } ] ]
y equal
p.x meanX, iMeanX: 1 1.5 1
y equal
p.x meanX, iMeanX: 1 2 2
here
x equal
y equal
p.x meanX, iMeanX: 2 2.5 2
x equal
x equal
y equal
p.x meanX, iMeanX: 3 2.5 2
y equal
p.x meanX, iMeanX: 3 2 2
here
y equal
p.x meanX, iMeanX: 2 1.5 1
{}
Code: 10:09:11 UTC,
js,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
console.log(combinations);
for (let pair of combinations) {
if (pair[0].y === pair[1].y) {
console.log('y equal')
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
console.log('p.x meanX, iMeanX:',pair[0].x, meanX, iMeanX)
if (meanX !== pair[0].x && meanX === iMeanX) {
console.log('here')
if (byMeanX[iMeanX] === undefined) {
byMeanX[iMeanX] = {};
}
if (byMeanX[iMeanX][pair[0].y] === undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
} else if (pair[0].x === pair[1].x) {
console.log('x equal')
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
console.log('here')
if (byMeanY[iMeanY][pair[0].x] !== undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].x]++;
}
}
}
}
console.log(byMeanY)
console.log(byMeanY)
let diamonds = 0;
// for (let y of byMeanY) {
// console.log(y);
// for (let x of byMeanY[y]) {
// console.log(x);
// if (byMeanX.hasOwnProperty(x) && byMeanY[x].hasOwnProperty(y)) {
// diamonds += bMeanX[x][y] * bMeanY[y][x];
// }
// }
// }
return diamonds;
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 10:09:16 UTC,
js,
verify,
result: Failed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
console.log(combinations);
for (let pair of combinations) {
if (pair[0].y === pair[1].y) {
console.log('y equal')
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
console.log('p.x meanX, iMeanX:',pair[0].x, meanX, iMeanX)
if (meanX !== pair[0].x && meanX === iMeanX) {
console.log('here')
if (byMeanX[iMeanX] === undefined) {
byMeanX[iMeanX] = {};
}
if (byMeanX[iMeanX][pair[0].y] === undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
} else if (pair[0].x === pair[1].x) {
console.log('x equal')
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
console.log('here')
if (byMeanY[iMeanY][pair[0].x] !== undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].x]++;
}
}
}
}
console.log(byMeanY)
console.log(byMeanX)
let diamonds = 0;
// for (let y of byMeanY) {
// console.log(y);
// for (let x of byMeanY[y]) {
// console.log(x);
// if (byMeanX.hasOwnProperty(x) && byMeanY[x].hasOwnProperty(y)) {
// diamonds += bMeanX[x][y] * bMeanY[y][x];
// }
// }
// }
return diamonds;
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Analysis
expand all
Example tests
1.
0.076 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
TypeError: Cannot read property '2' of undefined
at solution (solution.js:40:36)
at solutionWrapper (/tmp/exec.js:412:28)
at Promise.resolve.then (/tmp/exec.js:438:24)
at <anonymous>
at process._tickCallback (internal/process/next_tick.js:188:7)
at Function.Module.runMain (module.js:686:11)
at startup (bootstrap_node.js:187:16)
at bootstrap_node.js:608:3
stdout:
[ [ { x: 1, y: 3 }, { x: 1, y: 4 } ],
[ { x: 1, y: 3 }, { x: 2, y: 1 } ],
[ { x: 1, y: 3 }, { x: 2, y: 3 } ],
[ { x: 1, y: 3 }, { x: 2, y: 5 } ],
[ { x: 1, y: 3 }, { x: 3, y: 3 } ],
[ { x: 1, y: 3 }, { x: 3, y: 4 } ],
[ { x: 1, y: 4 }, { x: 2, y: 1 } ],
[ { x: 1, y: 4 }, { x: 2, y: 3 } ],
[ { x: 1, y: 4 }, { x: 2, y: 5 } ],
[ { x: 1, y: 4 }, { x: 3, y: 3 } ],
[ { x: 1, y: 4 }, { x: 3, y: 4 } ],
[ { x: 2, y: 1 }, { x: 2, y: 3 } ],
[ { x: 2, y: 1 }, { x: 2, y: 5 } ],
[ { x: 2, y: 1 }, { x: 3, y: 3 } ],
[ { x: 2, y: 1 }, { x: 3, y: 4 } ],
[ { x: 2, y: 3 }, { x: 2, y: 5 } ],
[ { x: 2, y: 3 }, { x: 3, y: 3 } ],
[ { x: 2, y: 3 }, { x: 3, y: 4 } ],
[ { x: 2, y: 5 }, { x: 3, y: 3 } ],
[ { x: 2, y: 5 }, { x: 3, y: 4 } ],
[ { x: 3, y: 3 }, { x: 3, y: 4 } ] ]
x equal
y equal
p.x meanX, iMeanX: 1 1.5 1
y equal
p.x meanX, iMeanX: 1 2 2
here
y equal
p.x meanX, iMeanX: 1 2 2
here
x equal
here
1.
0.076 s
OK
stdout:
[ [ { x: 1, y: 1 }, { x: 2, y: 1 } ],
[ { x: 1, y: 1 }, { x: 3, y: 1 } ],
[ { x: 1, y: 1 }, { x: 3, y: 2 } ],
[ { x: 1, y: 1 }, { x: 2, y: 2 } ],
[ { x: 1, y: 1 }, { x: 1, y: 2 } ],
[ { x: 2, y: 1 }, { x: 3, y: 1 } ],
[ { x: 2, y: 1 }, { x: 3, y: 2 } ],
[ { x: 2, y: 1 }, { x: 2, y: 2 } ],
[ { x: 2, y: 1 }, { x: 1, y: 2 } ],
[ { x: 3, y: 1 }, { x: 3, y: 2 } ],
[ { x: 3, y: 1 }, { x: 2, y: 2 } ],
[ { x: 3, y: 1 }, { x: 1, y: 2 } ],
[ { x: 3, y: 2 }, { x: 2, y: 2 } ],
[ { x: 3, y: 2 }, { x: 1, y: 2 } ],
[ { x: 2, y: 2 }, { x: 1, y: 2 } ] ]
y equal
p.x meanX, iMeanX: 1 1.5 1
y equal
p.x meanX, iMeanX: 1 2 2
here
x equal
y equal
p.x meanX, iMeanX: 2 2.5 2
x equal
x equal
y equal
p.x meanX, iMeanX: 3 2.5 2
y equal
p.x meanX, iMeanX: 3 2 2
here
y equal
p.x meanX, iMeanX: 2 1.5 1
{}
{ '2': { '1': 1, '2': 1 } }
Code: 10:09:48 UTC,
js,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
console.log(combinations);
for (let pair of combinations) {
if (pair[0].y === pair[1].y) {
console.log('y equal')
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
console.log('p.x meanX, iMeanX:',pair[0].x, meanX, iMeanX)
if (meanX !== pair[0].x && meanX === iMeanX) {
console.log('here')
if (byMeanX[iMeanX] === undefined) {
byMeanX[iMeanX] = {};
}
if (byMeanX[iMeanX][pair[0].y] === undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
} else if (pair[0].x === pair[1].x) {
console.log('x equal')
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
console.log('here')
if (byMeanX[iMeanX] === undefined) {
byMeanX[iMeanX] = {};
}
if (byMeanY[iMeanY][pair[0].x] !== undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].x]++;
}
}
}
}
console.log(byMeanY)
console.log(byMeanX)
let diamonds = 0;
// for (let y of byMeanY) {
// console.log(y);
// for (let x of byMeanY[y]) {
// console.log(x);
// if (byMeanX.hasOwnProperty(x) && byMeanY[x].hasOwnProperty(y)) {
// diamonds += bMeanX[x][y] * bMeanY[y][x];
// }
// }
// }
return diamonds;
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 10:09:53 UTC,
js,
verify,
result: Failed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
console.log(combinations);
for (let pair of combinations) {
if (pair[0].y === pair[1].y) {
console.log('y equal')
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
console.log('p.x meanX, iMeanX:',pair[0].x, meanX, iMeanX)
if (meanX !== pair[0].x && meanX === iMeanX) {
console.log('here')
if (byMeanX[iMeanX] === undefined) {
byMeanX[iMeanX] = {};
}
if (byMeanX[iMeanX][pair[0].y] === undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
} else if (pair[0].x === pair[1].x) {
console.log('x equal')
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
console.log('here')
if (byMeanX[iMeanY] === undefined) {
byMeanX[iMeanY] = {};
}
if (byMeanY[iMeanY][pair[0].x] !== undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].x]++;
}
}
}
}
console.log(byMeanY)
console.log(byMeanX)
let diamonds = 0;
// for (let y of byMeanY) {
// console.log(y);
// for (let x of byMeanY[y]) {
// console.log(x);
// if (byMeanX.hasOwnProperty(x) && byMeanY[x].hasOwnProperty(y)) {
// diamonds += bMeanX[x][y] * bMeanY[y][x];
// }
// }
// }
return diamonds;
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Analysis
expand all
Example tests
1.
0.076 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
TypeError: Cannot read property '2' of undefined
at solution (solution.js:43:36)
at solutionWrapper (/tmp/exec.js:412:28)
at Promise.resolve.then (/tmp/exec.js:438:24)
at <anonymous>
at process._tickCallback (internal/process/next_tick.js:188:7)
at Function.Module.runMain (module.js:686:11)
at startup (bootstrap_node.js:187:16)
at bootstrap_node.js:608:3
stdout:
[ [ { x: 1, y: 3 }, { x: 1, y: 4 } ],
[ { x: 1, y: 3 }, { x: 2, y: 1 } ],
[ { x: 1, y: 3 }, { x: 2, y: 3 } ],
[ { x: 1, y: 3 }, { x: 2, y: 5 } ],
[ { x: 1, y: 3 }, { x: 3, y: 3 } ],
[ { x: 1, y: 3 }, { x: 3, y: 4 } ],
[ { x: 1, y: 4 }, { x: 2, y: 1 } ],
[ { x: 1, y: 4 }, { x: 2, y: 3 } ],
[ { x: 1, y: 4 }, { x: 2, y: 5 } ],
[ { x: 1, y: 4 }, { x: 3, y: 3 } ],
[ { x: 1, y: 4 }, { x: 3, y: 4 } ],
[ { x: 2, y: 1 }, { x: 2, y: 3 } ],
[ { x: 2, y: 1 }, { x: 2, y: 5 } ],
[ { x: 2, y: 1 }, { x: 3, y: 3 } ],
[ { x: 2, y: 1 }, { x: 3, y: 4 } ],
[ { x: 2, y: 3 }, { x: 2, y: 5 } ],
[ { x: 2, y: 3 }, { x: 3, y: 3 } ],
[ { x: 2, y: 3 }, { x: 3, y: 4 } ],
[ { x: 2, y: 5 }, { x: 3, y: 3 } ],
[ { x: 2, y: 5 }, { x: 3, y: 4 } ],
[ { x: 3, y: 3 }, { x: 3, y: 4 } ] ]
x equal
y equal
p.x meanX, iMeanX: 1 1.5 1
y equal
p.x meanX, iMeanX: 1 2 2
here
y equal
p.x meanX, iMeanX: 1 2 2
here
x equal
here
1.
0.076 s
OK
stdout:
[ [ { x: 1, y: 1 }, { x: 2, y: 1 } ],
[ { x: 1, y: 1 }, { x: 3, y: 1 } ],
[ { x: 1, y: 1 }, { x: 3, y: 2 } ],
[ { x: 1, y: 1 }, { x: 2, y: 2 } ],
[ { x: 1, y: 1 }, { x: 1, y: 2 } ],
[ { x: 2, y: 1 }, { x: 3, y: 1 } ],
[ { x: 2, y: 1 }, { x: 3, y: 2 } ],
[ { x: 2, y: 1 }, { x: 2, y: 2 } ],
[ { x: 2, y: 1 }, { x: 1, y: 2 } ],
[ { x: 3, y: 1 }, { x: 3, y: 2 } ],
[ { x: 3, y: 1 }, { x: 2, y: 2 } ],
[ { x: 3, y: 1 }, { x: 1, y: 2 } ],
[ { x: 3, y: 2 }, { x: 2, y: 2 } ],
[ { x: 3, y: 2 }, { x: 1, y: 2 } ],
[ { x: 2, y: 2 }, { x: 1, y: 2 } ] ]
y equal
p.x meanX, iMeanX: 1 1.5 1
y equal
p.x meanX, iMeanX: 1 2 2
here
x equal
y equal
p.x meanX, iMeanX: 2 2.5 2
x equal
x equal
y equal
p.x meanX, iMeanX: 3 2.5 2
y equal
p.x meanX, iMeanX: 3 2 2
here
y equal
p.x meanX, iMeanX: 2 1.5 1
{}
{ '2': { '1': 1, '2': 1 } }
Code: 10:11:48 UTC,
js,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
console.log(combinations);
for (let pair of combinations) {
if (pair[0].y === pair[1].y) {
console.log('y equal')
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
console.log('p.x meanX, iMeanX:',pair[0].x, meanX, iMeanX)
if (meanX !== pair[0].x && meanX === iMeanX) {
console.log('here')
if (byMeanX[iMeanX] === undefined) {
byMeanX[iMeanX] = {};
}
if (byMeanX[iMeanX][pair[0].y] === undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
} else if (pair[0].x === pair[1].x) {
console.log('x equal')
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
console.log('here')
if (byMean[iMeanY] === undefined) {
byMeanX[iMeanY] = {};
}
if (byMeanY[iMeanY][pair[0].x] !== undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].x]++;
}
}
}
}
console.log(byMeanY)
console.log(byMeanX)
let diamonds = 0;
// for (let y of byMeanY) {
// console.log(y);
// for (let x of byMeanY[y]) {
// console.log(x);
// if (byMeanX.hasOwnProperty(x) && byMeanY[x].hasOwnProperty(y)) {
// diamonds += bMeanX[x][y] * bMeanY[y][x];
// }
// }
// }
return diamonds;
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 10:11:51 UTC,
js,
verify,
result: Failed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
console.log(combinations);
for (let pair of combinations) {
if (pair[0].y === pair[1].y) {
console.log('y equal')
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
console.log('p.x meanX, iMeanX:',pair[0].x, meanX, iMeanX)
if (meanX !== pair[0].x && meanX === iMeanX) {
console.log('here')
if (byMeanX[iMeanX] === undefined) {
byMeanX[iMeanX] = {};
}
if (byMeanX[iMeanX][pair[0].y] === undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
} else if (pair[0].x === pair[1].x) {
console.log('x equal')
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
console.log('here')
if (byMeanY[iMeanY] === undefined) {
byMeanY[iMeanY] = {};
}
if (byMeanY[iMeanY][pair[0].x] !== undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].x]++;
}
}
}
}
console.log(byMeanY)
console.log(byMeanX)
let diamonds = 0;
// for (let y of byMeanY) {
// console.log(y);
// for (let x of byMeanY[y]) {
// console.log(x);
// if (byMeanX.hasOwnProperty(x) && byMeanY[x].hasOwnProperty(y)) {
// diamonds += bMeanX[x][y] * bMeanY[y][x];
// }
// }
// }
return diamonds;
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Analysis
expand all
Example tests
1.
0.076 s
WRONG ANSWER,
got 0 expected 2
stdout:
[ [ { x: 1, y: 3 }, { x: 1, y: 4 } ],
[ { x: 1, y: 3 }, { x: 2, y: 1 } ],
[ { x: 1, y: 3 }, { x: 2, y: 3 } ],
[ { x: 1, y: 3 }, { x: 2, y: 5 } ],
[ { x: 1, y: 3 }, { x: 3, y: 3 } ],
[ { x: 1, y: 3 }, { x: 3, y: 4 } ],
[ { x: 1, y: 4 }, { x: 2, y: 1 } ],
[ { x: 1, y: 4 }, { x: 2, y: 3 } ],
[ { x: 1, y: 4 }, { x: 2, y: 5 } ],
[ { x: 1, y: 4 }, { x: 3, y: 3 } ],
[ { x: 1, y: 4 }, { x: 3, y: 4 } ],
[ { x: 2, y: 1 }, { x: 2, y: 3 } ],
[ { x: 2, y: 1 }, { x: 2, y: 5 } ],
[ { x: 2, y: 1 }, { x: 3, y: 3 } ],
[ { x: 2, y: 1 }, { x: 3, y: 4 } ],
[ { x: 2, y: 3 }, { x: 2, y: 5 } ],
[ { x: 2, y: 3 }, { x: 3, y: 3 } ],
[ { x: 2, y: 3 }, { x: 3, y: 4 } ],
[ { x: 2, y: 5 }, { x: 3, y: 3 } ],
[ { x: 2, y: 5 }, { x: 3, y: 4 } ],
[ { x: 3, y: 3 }, { x: 3, y: 4 } ] ]
x equal
y equal
p.x meanX, iMeanX: 1 1.5 1
y equal
p.x meanX, iMeanX: 1 2 2
here
y equal
p.x meanX, iMeanX: 1 2 2
here
x equal
here
x equal
here
x equal
here
y equal
p.x meanX, iMeanX: 2 2.5 2
x equal
{ '2': { '2': NaN }, '3': { '2': NaN }, '4': { '2': NaN } }
{ '2': { '3': 1, '4': 1 } }
1.
0.076 s
OK
stdout:
[ [ { x: 1, y: 1 }, { x: 2, y: 1 } ],
[ { x: 1, y: 1 }, { x: 3, y: 1 } ],
[ { x: 1, y: 1 }, { x: 3, y: 2 } ],
[ { x: 1, y: 1 }, { x: 2, y: 2 } ],
[ { x: 1, y: 1 }, { x: 1, y: 2 } ],
[ { x: 2, y: 1 }, { x: 3, y: 1 } ],
[ { x: 2, y: 1 }, { x: 3, y: 2 } ],
[ { x: 2, y: 1 }, { x: 2, y: 2 } ],
[ { x: 2, y: 1 }, { x: 1, y: 2 } ],
[ { x: 3, y: 1 }, { x: 3, y: 2 } ],
[ { x: 3, y: 1 }, { x: 2, y: 2 } ],
[ { x: 3, y: 1 }, { x: 1, y: 2 } ],
[ { x: 3, y: 2 }, { x: 2, y: 2 } ],
[ { x: 3, y: 2 }, { x: 1, y: 2 } ],
[ { x: 2, y: 2 }, { x: 1, y: 2 } ] ]
y equal
p.x meanX, iMeanX: 1 1.5 1
y equal
p.x meanX, iMeanX: 1 2 2
here
x equal
y equal
p.x meanX, iMeanX: 2 2.5 2
x equal
x equal
y equal
p.x meanX, iMeanX: 3 2.5 2
y equal
p.x meanX, iMeanX: 3 2 2
here
y equal
p.x meanX, iMeanX: 2 1.5 1
{}
{ '2': { '1': 1, '2': 1 } }
Code: 10:12:12 UTC,
js,
verify,
result: Failed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
console.log(combinations);
for (let pair of combinations) {
if (pair[0].y === pair[1].y) {
console.log('y equal')
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
console.log('p.x meanX, iMeanX:',pair[0].x, meanX, iMeanX)
if (meanX !== pair[0].x && meanX === iMeanX) {
console.log('here')
if (byMeanX[iMeanX] === undefined) {
byMeanX[iMeanX] = {};
}
if (byMeanX[iMeanX][pair[0].y] === undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
} else if (pair[0].x === pair[1].x) {
console.log('x equal')
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
console.log('here')
if (byMeanY[iMeanY] === undefined) {
byMeanY[iMeanY] = {};
}
if (byMeanY[iMeanY][pair[0].x] === undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].x]++;
}
}
}
}
console.log(byMeanY)
console.log(byMeanX)
let diamonds = 0;
// for (let y of byMeanY) {
// console.log(y);
// for (let x of byMeanY[y]) {
// console.log(x);
// if (byMeanX.hasOwnProperty(x) && byMeanY[x].hasOwnProperty(y)) {
// diamonds += bMeanX[x][y] * bMeanY[y][x];
// }
// }
// }
return diamonds;
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Analysis
expand all
Example tests
1.
0.076 s
WRONG ANSWER,
got 0 expected 2
stdout:
[ [ { x: 1, y: 3 }, { x: 1, y: 4 } ],
[ { x: 1, y: 3 }, { x: 2, y: 1 } ],
[ { x: 1, y: 3 }, { x: 2, y: 3 } ],
[ { x: 1, y: 3 }, { x: 2, y: 5 } ],
[ { x: 1, y: 3 }, { x: 3, y: 3 } ],
[ { x: 1, y: 3 }, { x: 3, y: 4 } ],
[ { x: 1, y: 4 }, { x: 2, y: 1 } ],
[ { x: 1, y: 4 }, { x: 2, y: 3 } ],
[ { x: 1, y: 4 }, { x: 2, y: 5 } ],
[ { x: 1, y: 4 }, { x: 3, y: 3 } ],
[ { x: 1, y: 4 }, { x: 3, y: 4 } ],
[ { x: 2, y: 1 }, { x: 2, y: 3 } ],
[ { x: 2, y: 1 }, { x: 2, y: 5 } ],
[ { x: 2, y: 1 }, { x: 3, y: 3 } ],
[ { x: 2, y: 1 }, { x: 3, y: 4 } ],
[ { x: 2, y: 3 }, { x: 2, y: 5 } ],
[ { x: 2, y: 3 }, { x: 3, y: 3 } ],
[ { x: 2, y: 3 }, { x: 3, y: 4 } ],
[ { x: 2, y: 5 }, { x: 3, y: 3 } ],
[ { x: 2, y: 5 }, { x: 3, y: 4 } ],
[ { x: 3, y: 3 }, { x: 3, y: 4 } ] ]
x equal
y equal
p.x meanX, iMeanX: 1 1.5 1
y equal
p.x meanX, iMeanX: 1 2 2
here
y equal
p.x meanX, iMeanX: 1 2 2
here
x equal
here
x equal
here
x equal
here
y equal
p.x meanX, iMeanX: 2 2.5 2
x equal
{ '2': { '2': 1 }, '3': { '2': 1 }, '4': { '2': 1 } }
{ '2': { '3': 1, '4': 1 } }
1.
0.076 s
OK
stdout:
[ [ { x: 1, y: 1 }, { x: 2, y: 1 } ],
[ { x: 1, y: 1 }, { x: 3, y: 1 } ],
[ { x: 1, y: 1 }, { x: 3, y: 2 } ],
[ { x: 1, y: 1 }, { x: 2, y: 2 } ],
[ { x: 1, y: 1 }, { x: 1, y: 2 } ],
[ { x: 2, y: 1 }, { x: 3, y: 1 } ],
[ { x: 2, y: 1 }, { x: 3, y: 2 } ],
[ { x: 2, y: 1 }, { x: 2, y: 2 } ],
[ { x: 2, y: 1 }, { x: 1, y: 2 } ],
[ { x: 3, y: 1 }, { x: 3, y: 2 } ],
[ { x: 3, y: 1 }, { x: 2, y: 2 } ],
[ { x: 3, y: 1 }, { x: 1, y: 2 } ],
[ { x: 3, y: 2 }, { x: 2, y: 2 } ],
[ { x: 3, y: 2 }, { x: 1, y: 2 } ],
[ { x: 2, y: 2 }, { x: 1, y: 2 } ] ]
y equal
p.x meanX, iMeanX: 1 1.5 1
y equal
p.x meanX, iMeanX: 1 2 2
here
x equal
y equal
p.x meanX, iMeanX: 2 2.5 2
x equal
x equal
y equal
p.x meanX, iMeanX: 3 2.5 2
y equal
p.x meanX, iMeanX: 3 2 2
here
y equal
p.x meanX, iMeanX: 2 1.5 1
{}
{ '2': { '1': 1, '2': 1 } }
Code: 10:12:44 UTC,
js,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
console.log(combinations);
for (let pair of combinations) {
if (pair[0].y === pair[1].y) {
console.log('y equal')
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
console.log('p.x meanX, iMeanX:',pair[0].x, meanX, iMeanX)
if (meanX !== pair[0].x && meanX === iMeanX) {
console.log('here')
if (byMeanX[iMeanX] === undefined) {
byMeanX[iMeanX] = {};
}
if (byMeanX[iMeanX][pair[0].y] === undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
} else if (pair[0].x === pair[1].x) {
console.log('x equal')
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
console.log('here')
if (byMeanY[iMeanY] === undefined) {
byMeanY[iMeanY] = {};
}
if (byMeanY[iMeanY][pair[0].x] === undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].x]++;
}
}
}
}
console.log(byMeanY)
console.log(byMeanX)
let diamonds = 0;
for (let y of byMeanY) {
console.log(y);
for (let x of byMeanY[y]) {
console.log(x);
if (byMeanX.hasOwnProperty(x) && byMeanY[x].hasOwnProperty(y)) {
diamonds += bMeanX[x][y] * bMeanY[y][x];
}
}
}
return diamonds;
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 10:13:02 UTC,
js,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
console.log(combinations);
for (let pair of combinations) {
if (pair[0].y === pair[1].y) {
console.log('y equal')
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
console.log('p.x meanX, iMeanX:',pair[0].x, meanX, iMeanX)
if (meanX !== pair[0].x && meanX === iMeanX) {
console.log('here')
if (byMeanX[iMeanX] === undefined) {
byMeanX[iMeanX] = {};
}
if (byMeanX[iMeanX][pair[0].y] === undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
} else if (pair[0].x === pair[1].x) {
console.log('x equal')
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
console.log('here')
if (byMeanY[iMeanY] === undefined) {
byMeanY[iMeanY] = {};
}
if (byMeanY[iMeanY][pair[0].x] === undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].x]++;
}
}
}
}
console.log(byMeanY)
console.log(byMeanX)
let diamonds = 0;
for (let y of byMeanY.keys) {
console.log(y);
for (let x of byMeanY[y]) {
console.log(x);
if (byMeanX.hasOwnProperty(x) && byMeanY[x].hasOwnProperty(y)) {
diamonds += bMeanX[x][y] * bMeanY[y][x];
}
}
}
return diamonds;
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 10:13:17 UTC,
js,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
console.log(combinations);
for (let pair of combinations) {
if (pair[0].y === pair[1].y) {
console.log('y equal')
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
console.log('p.x meanX, iMeanX:',pair[0].x, meanX, iMeanX)
if (meanX !== pair[0].x && meanX === iMeanX) {
console.log('here')
if (byMeanX[iMeanX] === undefined) {
byMeanX[iMeanX] = {};
}
if (byMeanX[iMeanX][pair[0].y] === undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
} else if (pair[0].x === pair[1].x) {
console.log('x equal')
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
console.log('here')
if (byMeanY[iMeanY] === undefined) {
byMeanY[iMeanY] = {};
}
if (byMeanY[iMeanY][pair[0].x] === undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].x]++;
}
}
}
}
console.log(byMeanY)
console.log(byMeanX)
let diamonds = 0;
for (let y of Object.keys(byMeanY)) {
console.log(y);
for (let x of byMeanY[y]) {
console.log(x);
if (byMeanX.hasOwnProperty(x) && byMeanY[x].hasOwnProperty(y)) {
diamonds += bMeanX[x][y] * bMeanY[y][x];
}
}
}
return diamonds;
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 10:13:24 UTC,
js,
verify,
result: Failed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
console.log(combinations);
for (let pair of combinations) {
if (pair[0].y === pair[1].y) {
console.log('y equal')
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
console.log('p.x meanX, iMeanX:',pair[0].x, meanX, iMeanX)
if (meanX !== pair[0].x && meanX === iMeanX) {
console.log('here')
if (byMeanX[iMeanX] === undefined) {
byMeanX[iMeanX] = {};
}
if (byMeanX[iMeanX][pair[0].y] === undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
} else if (pair[0].x === pair[1].x) {
console.log('x equal')
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
console.log('here')
if (byMeanY[iMeanY] === undefined) {
byMeanY[iMeanY] = {};
}
if (byMeanY[iMeanY][pair[0].x] === undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].x]++;
}
}
}
}
console.log(byMeanY)
console.log(byMeanX)
let diamonds = 0;
for (let y of Object.keys(byMeanY)) {
console.log(y);
for (let x of Object.keys(byMeanY[y])) {
console.log(x);
if (byMeanX.hasOwnProperty(x) && byMeanY[x].hasOwnProperty(y)) {
diamonds += bMeanX[x][y] * bMeanY[y][x];
}
}
}
return diamonds;
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Analysis
expand all
Example tests
1.
0.076 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
ReferenceError: bMeanX is not defined
at solution (solution.js:60:29)
at solutionWrapper (/tmp/exec.js:412:28)
at Promise.resolve.then (/tmp/exec.js:438:24)
at <anonymous>
at process._tickCallback (internal/process/next_tick.js:188:7)
at Function.Module.runMain (module.js:686:11)
at startup (bootstrap_node.js:187:16)
at bootstrap_node.js:608:3
stdout:
[ [ { x: 1, y: 3 }, { x: 1, y: 4 } ],
[ { x: 1, y: 3 }, { x: 2, y: 1 } ],
[ { x: 1, y: 3 }, { x: 2, y: 3 } ],
[ { x: 1, y: 3 }, { x: 2, y: 5 } ],
[ { x: 1, y: 3 }, { x: 3, y: 3 } ],
[ { x: 1, y: 3 }, { x: 3, y: 4 } ],
[ { x: 1, y: 4 }, { x: 2, y: 1 } ],
[ { x: 1, y: 4 }, { x: 2, y: 3 } ],
[ { x: 1, y: 4 }, { x: 2, y: 5 } ],
[ { x: 1, y: 4 }, { x: 3, y: 3 } ],
[ { x: 1, y: 4 }, { x: 3, y: 4 } ],
[ { x: 2, y: 1 }, { x: 2, y: 3 } ],
[ { x: 2, y: 1 }, { x: 2, y: 5 } ],
[ { x: 2, y: 1 }, { x: 3, y: 3 } ],
[ { x: 2, y: 1 }, { x: 3, y: 4 } ],
[ { x: 2, y: 3 }, { x: 2, y: 5 } ],
[ { x: 2, y: 3 }, { x: 3, y: 3 } ],
[ { x: 2, y: 3 }, { x: 3, y: 4 } ],
[ { x: 2, y: 5 }, { x: 3, y: 3 } ],
[ { x: 2, y: 5 }, { x: 3, y: 4 } ],
[ { x: 3, y: 3 }, { x: 3, y: 4 } ] ]
x equal
y equal
p.x meanX, iMeanX: 1 1.5 1
y equal
p.x meanX, iMeanX: 1 2 2
here
y equal
p.x meanX, iMeanX: 1 2 2
here
x equal
here
x equal
here
x equal
here
y equal
p.x meanX, iMeanX: 2 2.5 2
x equal
{ '2': { '2': 1 }, '3': { '2': 1 }, '4': { '2': 1 } }
{ '2': { '3': 1, '4': 1 } }
2
2
1.
0.076 s
OK
stdout:
[ [ { x: 1, y: 1 }, { x: 2, y: 1 } ],
[ { x: 1, y: 1 }, { x: 3, y: 1 } ],
[ { x: 1, y: 1 }, { x: 3, y: 2 } ],
[ { x: 1, y: 1 }, { x: 2, y: 2 } ],
[ { x: 1, y: 1 }, { x: 1, y: 2 } ],
[ { x: 2, y: 1 }, { x: 3, y: 1 } ],
[ { x: 2, y: 1 }, { x: 3, y: 2 } ],
[ { x: 2, y: 1 }, { x: 2, y: 2 } ],
[ { x: 2, y: 1 }, { x: 1, y: 2 } ],
[ { x: 3, y: 1 }, { x: 3, y: 2 } ],
[ { x: 3, y: 1 }, { x: 2, y: 2 } ],
[ { x: 3, y: 1 }, { x: 1, y: 2 } ],
[ { x: 3, y: 2 }, { x: 2, y: 2 } ],
[ { x: 3, y: 2 }, { x: 1, y: 2 } ],
[ { x: 2, y: 2 }, { x: 1, y: 2 } ] ]
y equal
p.x meanX, iMeanX: 1 1.5 1
y equal
p.x meanX, iMeanX: 1 2 2
here
x equal
y equal
p.x meanX, iMeanX: 2 2.5 2
x equal
x equal
y equal
p.x meanX, iMeanX: 3 2.5 2
y equal
p.x meanX, iMeanX: 3 2 2
here
y equal
p.x meanX, iMeanX: 2 1.5 1
{}
{ '2': { '1': 1, '2': 1 } }
Code: 10:13:47 UTC,
js,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
console.log(combinations);
for (let pair of combinations) {
if (pair[0].y === pair[1].y) {
console.log('y equal')
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
console.log('p.x meanX, iMeanX:',pair[0].x, meanX, iMeanX)
if (meanX !== pair[0].x && meanX === iMeanX) {
console.log('here')
if (byMeanX[iMeanX] === undefined) {
byMeanX[iMeanX] = {};
}
if (byMeanX[iMeanX][pair[0].y] === undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
} else if (pair[0].x === pair[1].x) {
console.log('x equal')
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
console.log('here')
if (byMeanY[iMeanY] === undefined) {
byMeanY[iMeanY] = {};
}
if (byMeanY[iMeanY][pair[0].x] === undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].x]++;
}
}
}
}
console.log(byMeanY)
console.log(byMeanX)
let diamonds = 0;
for (let y of Object.keys(byMeanY)) {
console.log(y);
for (let x of Object.keys(byMeanY[y])) {
console.log(x);
if (byMeanX.hasOwnProperty(x) && byMeanY[x].hasOwnProperty(y)) {
diamonds += byMeanX[x][y] * byMeanY[y][x];
}
}
}
return diamonds;
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 10:13:48 UTC,
js,
verify,
result: Failed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
console.log(combinations);
for (let pair of combinations) {
if (pair[0].y === pair[1].y) {
console.log('y equal')
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
console.log('p.x meanX, iMeanX:',pair[0].x, meanX, iMeanX)
if (meanX !== pair[0].x && meanX === iMeanX) {
console.log('here')
if (byMeanX[iMeanX] === undefined) {
byMeanX[iMeanX] = {};
}
if (byMeanX[iMeanX][pair[0].y] === undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
} else if (pair[0].x === pair[1].x) {
console.log('x equal')
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
console.log('here')
if (byMeanY[iMeanY] === undefined) {
byMeanY[iMeanY] = {};
}
if (byMeanY[iMeanY][pair[0].x] === undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].x]++;
}
}
}
}
console.log(byMeanY)
console.log(byMeanX)
let diamonds = 0;
for (let y of Object.keys(byMeanY)) {
console.log(y);
for (let x of Object.keys(byMeanY[y])) {
console.log(x);
if (byMeanX.hasOwnProperty(x) && byMeanY[x].hasOwnProperty(y)) {
diamonds += byMeanX[x][y] * byMeanY[y][x];
}
}
}
return diamonds;
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Analysis
expand all
Example tests
1.
0.076 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Invalid result type, integer expected, non-integer number foundstdout:
[ [ { x: 1, y: 3 }, { x: 1, y: 4 } ],
[ { x: 1, y: 3 }, { x: 2, y: 1 } ],
[ { x: 1, y: 3 }, { x: 2, y: 3 } ],
[ { x: 1, y: 3 }, { x: 2, y: 5 } ],
[ { x: 1, y: 3 }, { x: 3, y: 3 } ],
[ { x: 1, y: 3 }, { x: 3, y: 4 } ],
[ { x: 1, y: 4 }, { x: 2, y: 1 } ],
[ { x: 1, y: 4 }, { x: 2, y: 3 } ],
[ { x: 1, y: 4 }, { x: 2, y: 5 } ],
[ { x: 1, y: 4 }, { x: 3, y: 3 } ],
[ { x: 1, y: 4 }, { x: 3, y: 4 } ],
[ { x: 2, y: 1 }, { x: 2, y: 3 } ],
[ { x: 2, y: 1 }, { x: 2, y: 5 } ],
[ { x: 2, y: 1 }, { x: 3, y: 3 } ],
[ { x: 2, y: 1 }, { x: 3, y: 4 } ],
[ { x: 2, y: 3 }, { x: 2, y: 5 } ],
[ { x: 2, y: 3 }, { x: 3, y: 3 } ],
[ { x: 2, y: 3 }, { x: 3, y: 4 } ],
[ { x: 2, y: 5 }, { x: 3, y: 3 } ],
[ { x: 2, y: 5 }, { x: 3, y: 4 } ],
[ { x: 3, y: 3 }, { x: 3, y: 4 } ] ]
x equal
y equal
p.x meanX, iMeanX: 1 1.5 1
y equal
p.x meanX, iMeanX: 1 2 2
here
y equal
p.x meanX, iMeanX: 1 2 2
here
x equal
here
x equal
here
x equal
here
y equal
p.x meanX, iMeanX: 2 2.5 2
x equal
{ '2': { '2': 1 }, '3': { '2': 1 }, '4': { '2': 1 } }
{ '2': { '3': 1, '4': 1 } }
2
2
3
2
4
2
1.
0.076 s
OK
stdout:
[ [ { x: 1, y: 1 }, { x: 2, y: 1 } ],
[ { x: 1, y: 1 }, { x: 3, y: 1 } ],
[ { x: 1, y: 1 }, { x: 3, y: 2 } ],
[ { x: 1, y: 1 }, { x: 2, y: 2 } ],
[ { x: 1, y: 1 }, { x: 1, y: 2 } ],
[ { x: 2, y: 1 }, { x: 3, y: 1 } ],
[ { x: 2, y: 1 }, { x: 3, y: 2 } ],
[ { x: 2, y: 1 }, { x: 2, y: 2 } ],
[ { x: 2, y: 1 }, { x: 1, y: 2 } ],
[ { x: 3, y: 1 }, { x: 3, y: 2 } ],
[ { x: 3, y: 1 }, { x: 2, y: 2 } ],
[ { x: 3, y: 1 }, { x: 1, y: 2 } ],
[ { x: 3, y: 2 }, { x: 2, y: 2 } ],
[ { x: 3, y: 2 }, { x: 1, y: 2 } ],
[ { x: 2, y: 2 }, { x: 1, y: 2 } ] ]
y equal
p.x meanX, iMeanX: 1 1.5 1
y equal
p.x meanX, iMeanX: 1 2 2
here
x equal
y equal
p.x meanX, iMeanX: 2 2.5 2
x equal
x equal
y equal
p.x meanX, iMeanX: 3 2.5 2
y equal
p.x meanX, iMeanX: 3 2 2
here
y equal
p.x meanX, iMeanX: 2 1.5 1
{}
{ '2': { '1': 1, '2': 1 } }
Code: 10:14:13 UTC,
js,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
console.log(combinations);
for (let pair of combinations) {
if (pair[0].y === pair[1].y) {
console.log('y equal')
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
console.log('p.x meanX, iMeanX:',pair[0].x, meanX, iMeanX)
if (meanX !== pair[0].x && meanX === iMeanX) {
console.log('here')
if (byMeanX[iMeanX] === undefined) {
byMeanX[iMeanX] = {};
}
if (byMeanX[iMeanX][pair[0].y] === undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
} else if (pair[0].x === pair[1].x) {
console.log('x equal')
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
console.log('here')
if (byMeanY[iMeanY] === undefined) {
byMeanY[iMeanY] = {};
}
if (byMeanY[iMeanY][pair[0].x] === undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].x]++;
}
}
}
}
console.log(byMeanY)
console.log(byMeanX)
let diamonds = 0;
for (let y of Object.keys(byMeanY)) {
console.log(y);
for (let x of Object.keys(byMeanY[y])) {
console.log(x);
if (byMeanX.hasOwnProperty(x) && byMeanY[x].hasOwnProperty(y)) {
console.log()
diamonds += byMeanX[x][y] * byMeanY[y][x];
}
}
}
return diamonds;
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 10:14:36 UTC,
js,
verify,
result: Failed
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
console.log(combinations);
for (let pair of combinations) {
if (pair[0].y === pair[1].y) {
console.log('y equal')
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
console.log('p.x meanX, iMeanX:',pair[0].x, meanX, iMeanX)
if (meanX !== pair[0].x && meanX === iMeanX) {
console.log('here')
if (byMeanX[iMeanX] === undefined) {
byMeanX[iMeanX] = {};
}
if (byMeanX[iMeanX][pair[0].y] === undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
} else if (pair[0].x === pair[1].x) {
console.log('x equal')
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
console.log('here')
if (byMeanY[iMeanY] === undefined) {
byMeanY[iMeanY] = {};
}
if (byMeanY[iMeanY][pair[0].x] === undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].x]++;
}
}
}
}
console.log(byMeanY)
console.log(byMeanX)
let diamonds = 0;
for (let y of Object.keys(byMeanY)) {
console.log(y);
for (let x of Object.keys(byMeanY[y])) {
console.log(x);
if (byMeanX.hasOwnProperty(x) && byMeanY[x].hasOwnProperty(y)) {
console.log('multi:', byMeanX[x][y] * byMeanY[y][x])
diamonds += byMeanX[x][y] * byMeanY[y][x];
}
}
}
return diamonds;
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Analysis
expand all
Example tests
1.
0.076 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Invalid result type, integer expected, non-integer number foundstdout:
[ [ { x: 1, y: 3 }, { x: 1, y: 4 } ],
[ { x: 1, y: 3 }, { x: 2, y: 1 } ],
[ { x: 1, y: 3 }, { x: 2, y: 3 } ],
[ { x: 1, y: 3 }, { x: 2, y: 5 } ],
[ { x: 1, y: 3 }, { x: 3, y: 3 } ],
[ { x: 1, y: 3 }, { x: 3, y: 4 } ],
[ { x: 1, y: 4 }, { x: 2, y: 1 } ],
[ { x: 1, y: 4 }, { x: 2, y: 3 } ],
[ { x: 1, y: 4 }, { x: 2, y: 5 } ],
[ { x: 1, y: 4 }, { x: 3, y: 3 } ],
[ { x: 1, y: 4 }, { x: 3, y: 4 } ],
[ { x: 2, y: 1 }, { x: 2, y: 3 } ],
[ { x: 2, y: 1 }, { x: 2, y: 5 } ],
[ { x: 2, y: 1 }, { x: 3, y: 3 } ],
[ { x: 2, y: 1 }, { x: 3, y: 4 } ],
[ { x: 2, y: 3 }, { x: 2, y: 5 } ],
[ { x: 2, y: 3 }, { x: 3, y: 3 } ],
[ { x: 2, y: 3 }, { x: 3, y: 4 } ],
[ { x: 2, y: 5 }, { x: 3, y: 3 } ],
[ { x: 2, y: 5 }, { x: 3, y: 4 } ],
[ { x: 3, y: 3 }, { x: 3, y: 4 } ] ]
x equal
y equal
p.x meanX, iMeanX: 1 1.5 1
y equal
p.x meanX, iMeanX: 1 2 2
here
y equal
p.x meanX, iMeanX: 1 2 2
here
x equal
here
x equal
here
x equal
here
y equal
p.x meanX, iMeanX: 2 2.5 2
x equal
{ '2': { '2': 1 }, '3': { '2': 1 }, '4': { '2': 1 } }
{ '2': { '3': 1, '4': 1 } }
2
2
multi: NaN
3
2
4
2
1.
0.076 s
OK
stdout:
[ [ { x: 1, y: 1 }, { x: 2, y: 1 } ],
[ { x: 1, y: 1 }, { x: 3, y: 1 } ],
[ { x: 1, y: 1 }, { x: 3, y: 2 } ],
[ { x: 1, y: 1 }, { x: 2, y: 2 } ],
[ { x: 1, y: 1 }, { x: 1, y: 2 } ],
[ { x: 2, y: 1 }, { x: 3, y: 1 } ],
[ { x: 2, y: 1 }, { x: 3, y: 2 } ],
[ { x: 2, y: 1 }, { x: 2, y: 2 } ],
[ { x: 2, y: 1 }, { x: 1, y: 2 } ],
[ { x: 3, y: 1 }, { x: 3, y: 2 } ],
[ { x: 3, y: 1 }, { x: 2, y: 2 } ],
[ { x: 3, y: 1 }, { x: 1, y: 2 } ],
[ { x: 3, y: 2 }, { x: 2, y: 2 } ],
[ { x: 3, y: 2 }, { x: 1, y: 2 } ],
[ { x: 2, y: 2 }, { x: 1, y: 2 } ] ]
y equal
p.x meanX, iMeanX: 1 1.5 1
y equal
p.x meanX, iMeanX: 1 2 2
here
x equal
y equal
p.x meanX, iMeanX: 2 2.5 2
x equal
x equal
y equal
p.x meanX, iMeanX: 3 2.5 2
y equal
p.x meanX, iMeanX: 3 2 2
here
y equal
p.x meanX, iMeanX: 2 1.5 1
{}
{ '2': { '1': 1, '2': 1 } }
Code: 10:14:52 UTC,
js,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
console.log(combinations);
for (let pair of combinations) {
if (pair[0].y === pair[1].y) {
console.log('y equal')
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
console.log('p.x meanX, iMeanX:',pair[0].x, meanX, iMeanX)
if (meanX !== pair[0].x && meanX === iMeanX) {
console.log('here')
if (byMeanX[iMeanX] === undefined) {
byMeanX[iMeanX] = {};
}
if (byMeanX[iMeanX][pair[0].y] === undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
} else if (pair[0].x === pair[1].x) {
console.log('x equal')
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
console.log('here')
if (byMeanY[iMeanY] === undefined) {
byMeanY[iMeanY] = {};
}
if (byMeanY[iMeanY][pair[0].x] === undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].x]++;
}
}
}
}
console.log(byMeanY)
console.log(byMeanX)
let diamonds = 0;
for (let y of Object.keys(byMeanY)) {
console.log(y);
for (let x of Object.keys(byMeanY[y])) {
console.log(x);
if (byMeanX.hasOwnProperty(x) && byMeanY[x].hasOwnProperty(y)) {
console.log('multi:', byMeanX[x][y] * byMeanY[y][x])
diamonds += byMeanX[x][y] * byMeanY[y][x];
}
}
}
return diamonds;
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 10:15:09 UTC,
js,
verify,
result: Failed
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
console.log(combinations);
for (let pair of combinations) {
if (pair[0].y === pair[1].y) {
console.log('y equal')
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
console.log('p.x meanX, iMeanX:',pair[0].x, meanX, iMeanX)
if (meanX !== pair[0].x && meanX === iMeanX) {
console.log('here')
if (byMeanX[iMeanX] === undefined) {
byMeanX[iMeanX] = {};
}
if (byMeanX[iMeanX][pair[0].y] === undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
} else if (pair[0].x === pair[1].x) {
console.log('x equal')
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
console.log('here')
if (byMeanY[iMeanY] === undefined) {
byMeanY[iMeanY] = {};
}
if (byMeanY[iMeanY][pair[0].x] === undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].x]++;
}
}
}
}
console.log(byMeanY)
console.log(byMeanX)
let diamonds = 0;
for (let y of Object.keys(byMeanY)) {
console.log(y);
for (let x of Object.keys(byMeanY[y])) {
console.log(x);
if (byMeanX.hasOwnProperty(x) && byMeanY[x].hasOwnProperty(y)) {
console.log(byMeanX[x][y])
console.log('multi:', byMeanX[x][y] * byMeanY[y][x])
diamonds += byMeanX[x][y] * byMeanY[y][x];
}
}
}
return diamonds;
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Analysis
expand all
Example tests
1.
0.076 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Invalid result type, integer expected, non-integer number foundstdout:
[ [ { x: 1, y: 3 }, { x: 1, y: 4 } ],
[ { x: 1, y: 3 }, { x: 2, y: 1 } ],
[ { x: 1, y: 3 }, { x: 2, y: 3 } ],
[ { x: 1, y: 3 }, { x: 2, y: 5 } ],
[ { x: 1, y: 3 }, { x: 3, y: 3 } ],
[ { x: 1, y: 3 }, { x: 3, y: 4 } ],
[ { x: 1, y: 4 }, { x: 2, y: 1 } ],
[ { x: 1, y: 4 }, { x: 2, y: 3 } ],
[ { x: 1, y: 4 }, { x: 2, y: 5 } ],
[ { x: 1, y: 4 }, { x: 3, y: 3 } ],
[ { x: 1, y: 4 }, { x: 3, y: 4 } ],
[ { x: 2, y: 1 }, { x: 2, y: 3 } ],
[ { x: 2, y: 1 }, { x: 2, y: 5 } ],
[ { x: 2, y: 1 }, { x: 3, y: 3 } ],
[ { x: 2, y: 1 }, { x: 3, y: 4 } ],
[ { x: 2, y: 3 }, { x: 2, y: 5 } ],
[ { x: 2, y: 3 }, { x: 3, y: 3 } ],
[ { x: 2, y: 3 }, { x: 3, y: 4 } ],
[ { x: 2, y: 5 }, { x: 3, y: 3 } ],
[ { x: 2, y: 5 }, { x: 3, y: 4 } ],
[ { x: 3, y: 3 }, { x: 3, y: 4 } ] ]
x equal
y equal
p.x meanX, iMeanX: 1 1.5 1
y equal
p.x meanX, iMeanX: 1 2 2
here
y equal
p.x meanX, iMeanX: 1 2 2
here
x equal
here
x equal
here
x equal
here
y equal
p.x meanX, iMeanX: 2 2.5 2
x equal
{ '2': { '2': 1 }, '3': { '2': 1 }, '4': { '2': 1 } }
{ '2': { '3': 1, '4': 1 } }
2
2
undefined
multi: NaN
3
2
4
2
1.
0.076 s
OK
stdout:
[ [ { x: 1, y: 1 }, { x: 2, y: 1 } ],
[ { x: 1, y: 1 }, { x: 3, y: 1 } ],
[ { x: 1, y: 1 }, { x: 3, y: 2 } ],
[ { x: 1, y: 1 }, { x: 2, y: 2 } ],
[ { x: 1, y: 1 }, { x: 1, y: 2 } ],
[ { x: 2, y: 1 }, { x: 3, y: 1 } ],
[ { x: 2, y: 1 }, { x: 3, y: 2 } ],
[ { x: 2, y: 1 }, { x: 2, y: 2 } ],
[ { x: 2, y: 1 }, { x: 1, y: 2 } ],
[ { x: 3, y: 1 }, { x: 3, y: 2 } ],
[ { x: 3, y: 1 }, { x: 2, y: 2 } ],
[ { x: 3, y: 1 }, { x: 1, y: 2 } ],
[ { x: 3, y: 2 }, { x: 2, y: 2 } ],
[ { x: 3, y: 2 }, { x: 1, y: 2 } ],
[ { x: 2, y: 2 }, { x: 1, y: 2 } ] ]
y equal
p.x meanX, iMeanX: 1 1.5 1
y equal
p.x meanX, iMeanX: 1 2 2
here
x equal
y equal
p.x meanX, iMeanX: 2 2.5 2
x equal
x equal
y equal
p.x meanX, iMeanX: 3 2.5 2
y equal
p.x meanX, iMeanX: 3 2 2
here
y equal
p.x meanX, iMeanX: 2 1.5 1
{}
{ '2': { '1': 1, '2': 1 } }
Code: 10:15:39 UTC,
js,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
console.log(combinations);
for (let pair of combinations) {
if (pair[0].y === pair[1].y) {
console.log('y equal')
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
console.log('p.x meanX, iMeanX:',pair[0].x, meanX, iMeanX)
if (meanX !== pair[0].x && meanX === iMeanX) {
console.log('here')
if (byMeanX[iMeanX] === undefined) {
byMeanX[iMeanX] = {};
}
if (byMeanX[iMeanX][pair[0].y] === undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
} else if (pair[0].x === pair[1].x) {
console.log('x equal')
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
console.log('here')
if (byMeanY[iMeanY] === undefined) {
byMeanY[iMeanY] = {};
}
if (byMeanY[iMeanY][pair[0].x] === undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].x]++;
}
}
}
}
console.log(byMeanY)
console.log(byMeanX)
let diamonds = 0;
for (let y of Object.keys(byMeanY)) {
for (let x of Object.keys(byMeanY[y])) {
console.log(x);
if (byMeanX.hasOwnProperty(x) && byMeanY[x].hasOwnProperty(y)) {
console.log(byMeanX[x][y])
console.log('multi:', byMeanX[x][y] * byMeanY[y][x])
diamonds += byMeanX[x][y] * byMeanY[y][x];
}
}
}
return diamonds;
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 10:16:00 UTC,
js,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
console.log(combinations);
for (let pair of combinations) {
if (pair[0].y === pair[1].y) {
console.log('y equal')
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
console.log('p.x meanX, iMeanX:',pair[0].x, meanX, iMeanX)
if (meanX !== pair[0].x && meanX === iMeanX) {
console.log('here')
if (byMeanX[iMeanX] === undefined) {
byMeanX[iMeanX] = {};
}
if (byMeanX[iMeanX][pair[0].y] === undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
} else if (pair[0].x === pair[1].x) {
console.log('x equal')
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
console.log('here')
if (byMeanY[iMeanY] === undefined) {
byMeanY[iMeanY] = {};
}
if (byMeanY[iMeanY][pair[0].x] === undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].x]++;
}
}
}
}
console.log(byMeanY)
console.log(byMeanX)
let diamonds = 0;
for (let y of Object.keys(byMeanY)) {
for (let x of Object.keys(byMeanY[y])) {
console.log('x, y:' x);
if (byMeanX.hasOwnProperty(x) && byMeanY[x].hasOwnProperty(y)) {
console.log(byMeanX[x][y])
console.log('multi:', byMeanX[x][y] * byMeanY[y][x])
diamonds += byMeanX[x][y] * byMeanY[y][x];
}
}
}
return diamonds;
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 10:16:11 UTC,
js,
verify,
result: Failed
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
console.log(combinations);
for (let pair of combinations) {
if (pair[0].y === pair[1].y) {
console.log('y equal')
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
console.log('p.x meanX, iMeanX:',pair[0].x, meanX, iMeanX)
if (meanX !== pair[0].x && meanX === iMeanX) {
console.log('here')
if (byMeanX[iMeanX] === undefined) {
byMeanX[iMeanX] = {};
}
if (byMeanX[iMeanX][pair[0].y] === undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
} else if (pair[0].x === pair[1].x) {
console.log('x equal')
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
console.log('here')
if (byMeanY[iMeanY] === undefined) {
byMeanY[iMeanY] = {};
}
if (byMeanY[iMeanY][pair[0].x] === undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].x]++;
}
}
}
}
console.log(byMeanY)
console.log(byMeanX)
let diamonds = 0;
for (let y of Object.keys(byMeanY)) {
for (let x of Object.keys(byMeanY[y])) {
console.log('y, x:', y, x);
if (byMeanX.hasOwnProperty(x) && byMeanY[x].hasOwnProperty(y)) {
console.log(byMeanX[x][y])
console.log('multi:', byMeanX[x][y] * byMeanY[y][x])
diamonds += byMeanX[x][y] * byMeanY[y][x];
}
}
}
return diamonds;
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Analysis
expand all
Example tests
1.
0.076 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Invalid result type, integer expected, non-integer number foundstdout:
[ [ { x: 1, y: 3 }, { x: 1, y: 4 } ],
[ { x: 1, y: 3 }, { x: 2, y: 1 } ],
[ { x: 1, y: 3 }, { x: 2, y: 3 } ],
[ { x: 1, y: 3 }, { x: 2, y: 5 } ],
[ { x: 1, y: 3 }, { x: 3, y: 3 } ],
[ { x: 1, y: 3 }, { x: 3, y: 4 } ],
[ { x: 1, y: 4 }, { x: 2, y: 1 } ],
[ { x: 1, y: 4 }, { x: 2, y: 3 } ],
[ { x: 1, y: 4 }, { x: 2, y: 5 } ],
[ { x: 1, y: 4 }, { x: 3, y: 3 } ],
[ { x: 1, y: 4 }, { x: 3, y: 4 } ],
[ { x: 2, y: 1 }, { x: 2, y: 3 } ],
[ { x: 2, y: 1 }, { x: 2, y: 5 } ],
[ { x: 2, y: 1 }, { x: 3, y: 3 } ],
[ { x: 2, y: 1 }, { x: 3, y: 4 } ],
[ { x: 2, y: 3 }, { x: 2, y: 5 } ],
[ { x: 2, y: 3 }, { x: 3, y: 3 } ],
[ { x: 2, y: 3 }, { x: 3, y: 4 } ],
[ { x: 2, y: 5 }, { x: 3, y: 3 } ],
[ { x: 2, y: 5 }, { x: 3, y: 4 } ],
[ { x: 3, y: 3 }, { x: 3, y: 4 } ] ]
x equal
y equal
p.x meanX, iMeanX: 1 1.5 1
y equal
p.x meanX, iMeanX: 1 2 2
here
y equal
p.x meanX, iMeanX: 1 2 2
here
x equal
here
x equal
here
x equal
here
y equal
p.x meanX, iMeanX: 2 2.5 2
x equal
{ '2': { '2': 1 }, '3': { '2': 1 }, '4': { '2': 1 } }
{ '2': { '3': 1, '4': 1 } }
y, x: 2 2
undefined
multi: NaN
y, x: 3 2
y, x: 4 2
1.
0.076 s
OK
stdout:
[ [ { x: 1, y: 1 }, { x: 2, y: 1 } ],
[ { x: 1, y: 1 }, { x: 3, y: 1 } ],
[ { x: 1, y: 1 }, { x: 3, y: 2 } ],
[ { x: 1, y: 1 }, { x: 2, y: 2 } ],
[ { x: 1, y: 1 }, { x: 1, y: 2 } ],
[ { x: 2, y: 1 }, { x: 3, y: 1 } ],
[ { x: 2, y: 1 }, { x: 3, y: 2 } ],
[ { x: 2, y: 1 }, { x: 2, y: 2 } ],
[ { x: 2, y: 1 }, { x: 1, y: 2 } ],
[ { x: 3, y: 1 }, { x: 3, y: 2 } ],
[ { x: 3, y: 1 }, { x: 2, y: 2 } ],
[ { x: 3, y: 1 }, { x: 1, y: 2 } ],
[ { x: 3, y: 2 }, { x: 2, y: 2 } ],
[ { x: 3, y: 2 }, { x: 1, y: 2 } ],
[ { x: 2, y: 2 }, { x: 1, y: 2 } ] ]
y equal
p.x meanX, iMeanX: 1 1.5 1
y equal
p.x meanX, iMeanX: 1 2 2
here
x equal
y equal
p.x meanX, iMeanX: 2 2.5 2
x equal
x equal
y equal
p.x meanX, iMeanX: 3 2.5 2
y equal
p.x meanX, iMeanX: 3 2 2
here
y equal
p.x meanX, iMeanX: 2 1.5 1
{}
{ '2': { '1': 1, '2': 1 } }
Code: 10:16:30 UTC,
js,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
console.log(combinations);
for (let pair of combinations) {
if (pair[0].y === pair[1].y) {
console.log('y equal')
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
// console.log('p.x meanX, iMeanX:',pair[0].x, meanX, iMeanX)
if (meanX !== pair[0].x && meanX === iMeanX) {
if (byMeanX[iMeanX] === undefined) {
byMeanX[iMeanX] = {};
}
if (byMeanX[iMeanX][pair[0].y] === undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
} else if (pair[0].x === pair[1].x) {
// console.log('x equal')
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
if (byMeanY[iMeanY] === undefined) {
byMeanY[iMeanY] = {};
}
if (byMeanY[iMeanY][pair[0].x] === undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].x]++;
}
}
}
}
console.log(byMeanY)
console.log(byMeanX)
let diamonds = 0;
for (let y of Object.keys(byMeanY)) {
for (let x of Object.keys(byMeanY[y])) {
console.log('y, x:', y, x);
if (byMeanX.hasOwnProperty(x) && byMeanY[x].hasOwnProperty(y)) {
console.log(byMeanX[x][y])
console.log('multi:', byMeanX[x][y] * byMeanY[y][x])
diamonds += byMeanX[x][y] * byMeanY[y][x];
}
}
}
return diamonds;
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 10:16:42 UTC,
js,
verify,
result: Failed
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
if (pair[0].y === pair[1].y) {
// console.log('y equal')
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
// console.log('p.x meanX, iMeanX:',pair[0].x, meanX, iMeanX)
if (meanX !== pair[0].x && meanX === iMeanX) {
if (byMeanX[iMeanX] === undefined) {
byMeanX[iMeanX] = {};
}
if (byMeanX[iMeanX][pair[0].y] === undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
} else if (pair[0].x === pair[1].x) {
// console.log('x equal')
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
if (byMeanY[iMeanY] === undefined) {
byMeanY[iMeanY] = {};
}
if (byMeanY[iMeanY][pair[0].x] === undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].x]++;
}
}
}
}
console.log(byMeanY)
console.log(byMeanX)
let diamonds = 0;
for (let y of Object.keys(byMeanY)) {
for (let x of Object.keys(byMeanY[y])) {
console.log('y, x:', y, x);
if (byMeanX.hasOwnProperty(x) && byMeanY[x].hasOwnProperty(y)) {
console.log(byMeanX[x][y])
console.log('multi:', byMeanX[x][y] * byMeanY[y][x])
diamonds += byMeanX[x][y] * byMeanY[y][x];
}
}
}
return diamonds;
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Analysis
expand all
Example tests
1.
0.072 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Invalid result type, integer expected, non-integer number foundstdout:
{ '2': { '2': 1 }, '3': { '2': 1 }, '4': { '2': 1 } }
{ '2': { '3': 1, '4': 1 } }
y, x: 2 2
undefined
multi: NaN
y, x: 3 2
y, x: 4 2
1.
0.076 s
OK
stdout:
{}
{ '2': { '1': 1, '2': 1 } }
Code: 10:16:59 UTC,
js,
verify,
result: Failed
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
if (pair[0].y === pair[1].y) {
// console.log('y equal')
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
// console.log('p.x meanX, iMeanX:',pair[0].x, meanX, iMeanX)
if (meanX !== pair[0].x && meanX === iMeanX) {
if (byMeanX[iMeanX] === undefined) {
byMeanX[iMeanX] = {};
}
if (byMeanX[iMeanX][pair[0].y] === undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
} else if (pair[0].x === pair[1].x) {
// console.log('x equal')
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
if (byMeanY[iMeanY] === undefined) {
byMeanY[iMeanY] = {};
}
if (byMeanY[iMeanY][pair[0].x] === undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].x]++;
}
}
}
}
console.log(byMeanY)
console.log(byMeanX)
let diamonds = 0;
for (let y of Object.keys(byMeanY)) {
for (let x of Object.keys(byMeanY[y])) {
console.log('y, x:', y, x);
if (byMeanX.hasOwnProperty(x) && byMeanY[x].hasOwnProperty(y)) {
console.log(byMeanX[x])
console.log('multi:', byMeanX[x][y] * byMeanY[y][x])
diamonds += byMeanX[x][y] * byMeanY[y][x];
}
}
}
return diamonds;
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Analysis
expand all
Example tests
1.
0.076 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Invalid result type, integer expected, non-integer number foundstdout:
{ '2': { '2': 1 }, '3': { '2': 1 }, '4': { '2': 1 } }
{ '2': { '3': 1, '4': 1 } }
y, x: 2 2
{ '3': 1, '4': 1 }
multi: NaN
y, x: 3 2
y, x: 4 2
1.
0.076 s
OK
stdout:
{}
{ '2': { '1': 1, '2': 1 } }
Code: 10:17:33 UTC,
js,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
if (pair[0].y === pair[1].y) {
// console.log('y equal')
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
// console.log('p.x meanX, iMeanX:',pair[0].x, meanX, iMeanX)
if (meanX !== pair[0].x && meanX === iMeanX) {
if (byMeanX[iMeanX] === undefined) {
byMeanX[iMeanX] = {};
}
if (byMeanX[iMeanX][pair[0].y] === undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
} else if (pair[0].x === pair[1].x) {
// console.log('x equal')
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
if (byMeanY[iMeanY] === undefined) {
byMeanY[iMeanY] = {};
}
if (byMeanY[iMeanY][pair[0].x] === undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].x]++;
}
}
}
}
console.log(byMeanY)
console.log(byMeanX)
let diamonds = 0;
for (let y of Object.keys(byMeanY)) {
for (let x of Object.keys(byMeanY[y])) {
console.log('y, x:', y, x);
if (byMeanX.hasOwnProperty(x) && byMeanY[x].hasOwnProperty(y)) {
console.log(byMeanX[x])
console.log('multi:', byMeanX[x][y] * byMeanY[y][x])
diamonds += byMeanX[x][y] * byMeanY[y][x];
}
}
}
return diamonds;
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 10:17:43 UTC,
js,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
if (pair[0].y === pair[1].y) {
// console.log('y equal')
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
// console.log('p.x meanX, iMeanX:',pair[0].x, meanX, iMeanX)
if (meanX !== pair[0].x && meanX === iMeanX) {
if (byMeanX[iMeanX] === undefined) {
byMeanX[iMeanX] = {};
}
if (byMeanX[iMeanX][pair[0].y] === undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
} else if (pair[0].x === pair[1].x) {
// console.log('x equal')
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
if (byMeanY[iMeanY] === undefined) {
byMeanY[iMeanY] = {};
}
if (byMeanY[iMeanY][pair[0].x] === undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].x]++;
}
}
}
}
console.log(byMeanY)
console.log(byMeanX)
let diamonds = 0;
for (let y of Object.keys(byMeanY)) {
for (let x of Object.keys(byMeanY[y])) {
console.log('y, x:', y, x);
console.log()
if (byMeanX.hasOwnProperty(x) && byMeanY[x].hasOwnProperty(y)) {
console.log(byMeanX[x])
console.log('multi:', byMeanX[x][y] * byMeanY[y][x])
diamonds += byMeanX[x][y] * byMeanY[y][x];
}
}
}
return diamonds;
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 10:17:53 UTC,
js,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
if (pair[0].y === pair[1].y) {
// console.log('y equal')
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
// console.log('p.x meanX, iMeanX:',pair[0].x, meanX, iMeanX)
if (meanX !== pair[0].x && meanX === iMeanX) {
if (byMeanX[iMeanX] === undefined) {
byMeanX[iMeanX] = {};
}
if (byMeanX[iMeanX][pair[0].y] === undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
} else if (pair[0].x === pair[1].x) {
// console.log('x equal')
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
if (byMeanY[iMeanY] === undefined) {
byMeanY[iMeanY] = {};
}
if (byMeanY[iMeanY][pair[0].x] === undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].x]++;
}
}
}
}
console.log(byMeanY)
console.log(byMeanX)
let diamonds = 0;
for (let y of Object.keys(byMeanY)) {
for (let x of Object.keys(byMeanY[y])) {
console.log('y, x:', y, x);
console.log(byMeanX.hasOwnProperty(x))
if (byMeanX.hasOwnProperty(x) && byMeanY[x].hasOwnProperty(y)) {
console.log(byMeanX[x])
console.log('multi:', byMeanX[x][y] * byMeanY[y][x])
diamonds += byMeanX[x][y] * byMeanY[y][x];
}
}
}
return diamonds;
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 10:18:08 UTC,
js,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
if (pair[0].y === pair[1].y) {
// console.log('y equal')
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
// console.log('p.x meanX, iMeanX:',pair[0].x, meanX, iMeanX)
if (meanX !== pair[0].x && meanX === iMeanX) {
if (byMeanX[iMeanX] === undefined) {
byMeanX[iMeanX] = {};
}
if (byMeanX[iMeanX][pair[0].y] === undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
} else if (pair[0].x === pair[1].x) {
// console.log('x equal')
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
if (byMeanY[iMeanY] === undefined) {
byMeanY[iMeanY] = {};
}
if (byMeanY[iMeanY][pair[0].x] === undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].x]++;
}
}
}
}
console.log(byMeanY)
console.log(byMeanX)
let diamonds = 0;
for (let y of Object.keys(byMeanY)) {
for (let x of Object.keys(byMeanY[y])) {
console.log('y, x byMeanX, byMeanY:', y, x);
console.log(byMeanX.hasOwnProperty(x))
if (byMeanX.hasOwnProperty(x) && byMeanY[x].hasOwnProperty(y)) {
console.log(byMeanX[x])
console.log('multi:', byMeanX[x][y] * byMeanY[y][x])
diamonds += byMeanX[x][y] * byMeanY[y][x];
}
}
}
return diamonds;
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 10:18:27 UTC,
js,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
if (pair[0].y === pair[1].y) {
// console.log('y equal')
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
// console.log('p.x meanX, iMeanX:',pair[0].x, meanX, iMeanX)
if (meanX !== pair[0].x && meanX === iMeanX) {
if (byMeanX[iMeanX] === undefined) {
byMeanX[iMeanX] = {};
}
if (byMeanX[iMeanX][pair[0].y] === undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
} else if (pair[0].x === pair[1].x) {
// console.log('x equal')
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
if (byMeanY[iMeanY] === undefined) {
byMeanY[iMeanY] = {};
}
if (byMeanY[iMeanY][pair[0].x] === undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].x]++;
}
}
}
}
console.log(byMeanY)
console.log(byMeanX)
let diamonds = 0;
for (let y of Object.keys(byMeanY)) {
for (let x of Object.keys(byMeanY[y])) {
console.log('y, x byMeanX, byMeanY:', y, x);
console.log(byMeanX.hasOwnProperty(x))
if (byMeanX.hasOwnProperty(x) && byMeanX[x].hasOwnProperty(y)) {
console.log(byMeanX[x])
console.log('multi:', byMeanX[x][y] * byMeanY[y][x])
diamonds += byMeanX[x][y] * byMeanY[y][x];
}
}
}
return diamonds;
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 10:18:53 UTC,
js,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
if (pair[0].y === pair[1].y) {
// console.log('y equal')
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
// console.log('p.x meanX, iMeanX:',pair[0].x, meanX, iMeanX)
if (meanX !== pair[0].x && meanX === iMeanX) {
if (byMeanX[iMeanX] === undefined) {
byMeanX[iMeanX] = {};
}
if (byMeanX[iMeanX][pair[0].y] === undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
} else if (pair[0].x === pair[1].x) {
// console.log('x equal')
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
if (byMeanY[iMeanY] === undefined) {
byMeanY[iMeanY] = {};
}
if (byMeanY[iMeanY][pair[0].x] === undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].x]++;
}
}
}
}
console.log(byMeanY)
console.log(byMeanX)
let diamonds = 0;
for (let y of Object.keys(byMeanY)) {
for (let x of Object.keys(byMeanY[y])) {
console.log('y, x byMeanX, byMeanXx:', y, x, );
if (byMeanX.hasOwnProperty(x) && byMeanX[x].hasOwnProperty(y)) {
console.log(byMeanX[x])
console.log('multi:', byMeanX[x][y] * byMeanY[y][x])
diamonds += byMeanX[x][y] * byMeanY[y][x];
}
}
}
return diamonds;
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 10:19:04 UTC,
js,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
if (pair[0].y === pair[1].y) {
// console.log('y equal')
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
// console.log('p.x meanX, iMeanX:',pair[0].x, meanX, iMeanX)
if (meanX !== pair[0].x && meanX === iMeanX) {
if (byMeanX[iMeanX] === undefined) {
byMeanX[iMeanX] = {};
}
if (byMeanX[iMeanX][pair[0].y] === undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
} else if (pair[0].x === pair[1].x) {
// console.log('x equal')
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
if (byMeanY[iMeanY] === undefined) {
byMeanY[iMeanY] = {};
}
if (byMeanY[iMeanY][pair[0].x] === undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].x]++;
}
}
}
}
console.log(byMeanY)
console.log(byMeanX)
let diamonds = 0;
for (let y of Object.keys(byMeanY)) {
for (let x of Object.keys(byMeanY[y])) {
console.log('y, x byMeanX, byMeanXx:', y, x, byMeanX, );
if (byMeanX.hasOwnProperty(x) && byMeanX[x].hasOwnProperty(y)) {
console.log(byMeanX[x])
console.log('multi:', byMeanX[x][y] * byMeanY[y][x])
diamonds += byMeanX[x][y] * byMeanY[y][x];
}
}
}
return diamonds;
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 10:19:07 UTC,
js,
verify,
result: Passed
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
if (pair[0].y === pair[1].y) {
// console.log('y equal')
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
// console.log('p.x meanX, iMeanX:',pair[0].x, meanX, iMeanX)
if (meanX !== pair[0].x && meanX === iMeanX) {
if (byMeanX[iMeanX] === undefined) {
byMeanX[iMeanX] = {};
}
if (byMeanX[iMeanX][pair[0].y] === undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
} else if (pair[0].x === pair[1].x) {
// console.log('x equal')
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
if (byMeanY[iMeanY] === undefined) {
byMeanY[iMeanY] = {};
}
if (byMeanY[iMeanY][pair[0].x] === undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].x]++;
}
}
}
}
console.log(byMeanY)
console.log(byMeanX)
let diamonds = 0;
for (let y of Object.keys(byMeanY)) {
for (let x of Object.keys(byMeanY[y])) {
console.log('y, x byMeanX, byMeanXx:', y, x, byMeanX, byMeanX[x]);
if (byMeanX.hasOwnProperty(x) && byMeanX[x].hasOwnProperty(y)) {
console.log(byMeanX[x])
console.log('multi:', byMeanX[x][y] * byMeanY[y][x])
diamonds += byMeanX[x][y] * byMeanY[y][x];
}
}
}
return diamonds;
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Analysis
expand all
Example tests
1.
0.076 s
OK
stdout:
{ '2': { '2': 1 }, '3': { '2': 1 }, '4': { '2': 1 } }
{ '2': { '3': 1, '4': 1 } }
y, x byMeanX, byMeanXx: 2 2 { '2': { '3': 1, '4': 1 } } { '3': 1, '4': 1 }
y, x byMeanX, byMeanXx: 3 2 { '2': { '3': 1, '4': 1 } } { '3': 1, '4': 1 }
{ '3': 1, '4': 1 }
multi: 1
y, x byMeanX, byMeanXx: 4 2 { '2': { '3': 1, '4': 1 } } { '3': 1, '4': 1 }
{ '3': 1, '4': 1 }
multi: 1
1.
0.076 s
OK
stdout:
{}
{ '2': { '1': 1, '2': 1 } }
Code: 10:19:33 UTC,
js,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
if (pair[0].y === pair[1].y) {
// console.log('y equal')
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
// console.log('p.x meanX, iMeanX:',pair[0].x, meanX, iMeanX)
if (meanX !== pair[0].x && meanX === iMeanX) {
if (byMeanX[iMeanX] === undefined) {
byMeanX[iMeanX] = {};
}
if (byMeanX[iMeanX][pair[0].y] === undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
} else if (pair[0].x === pair[1].x) {
// console.log('x equal')
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
if (byMeanY[iMeanY] === undefined) {
byMeanY[iMeanY] = {};
}
if (byMeanY[iMeanY][pair[0].x] === undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].x]++;
}
}
}
}
console.log(byMeanY)
console.log(byMeanX)
let diamonds = 0;
for (let y of Object.keys(byMeanY)) {
for (let x of Object.keys(byMeanY[y])) {
// console.log('y, x byMeanX, byMeanXx:', y, x, byMeanX, byMeanX[x]);
if (byMeanX.hasOwnProperty(x) && byMeanX[x].hasOwnProperty(y)) {
diamonds += byMeanX[x][y] * byMeanY[y][x];
}
}
}
return diamonds;
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 10:19:41 UTC,
js,
verify,
result: Passed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
if (pair[0].y === pair[1].y) {
// console.log('y equal')
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
// console.log('p.x meanX, iMeanX:',pair[0].x, meanX, iMeanX)
if (meanX !== pair[0].x && meanX === iMeanX) {
if (byMeanX[iMeanX] === undefined) {
byMeanX[iMeanX] = {};
}
if (byMeanX[iMeanX][pair[0].y] === undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
} else if (pair[0].x === pair[1].x) {
// console.log('x equal')
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
if (byMeanY[iMeanY] === undefined) {
byMeanY[iMeanY] = {};
}
if (byMeanY[iMeanY][pair[0].x] === undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].x]++;
}
}
}
}
let diamonds = 0;
for (let y of Object.keys(byMeanY)) {
for (let x of Object.keys(byMeanY[y])) {
// console.log('y, x byMeanX, byMeanXx:', y, x, byMeanX, byMeanX[x]);
if (byMeanX.hasOwnProperty(x) && byMeanX[x].hasOwnProperty(y)) {
diamonds += byMeanX[x][y] * byMeanY[y][x];
}
}
}
return diamonds;
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Analysis
Code: 10:19:53 UTC,
js,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
if (pair[0].y === pair[1].y) {
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
// console.log('p.x meanX, iMeanX:',pair[0].x, meanX, iMeanX)
if (meanX !== pair[0].x && meanX === iMeanX) {
if (byMeanX[iMeanX] === undefined) {
byMeanX[iMeanX] = {};
}
if (byMeanX[iMeanX][pair[0].y] === undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
} else if (pair[0].x === pair[1].x) {
// console.log('x equal')
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
if (byMeanY[iMeanY] === undefined) {
byMeanY[iMeanY] = {};
}
if (byMeanY[iMeanY][pair[0].x] === undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].x]++;
}
}
}
}
let diamonds = 0;
for (let y of Object.keys(byMeanY)) {
for (let x of Object.keys(byMeanY[y])) {
// console.log('y, x byMeanX, byMeanXx:', y, x, byMeanX, byMeanX[x]);
if (byMeanX.hasOwnProperty(x) && byMeanX[x].hasOwnProperty(y)) {
diamonds += byMeanX[x][y] * byMeanY[y][x];
}
}
}
return diamonds;
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 10:20:07 UTC,
js,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
// check if y values are equal
if (pair[0].y === pair[1].y) {
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
// console.log('p.x meanX, iMeanX:',pair[0].x, meanX, iMeanX)
if (meanX !== pair[0].x && meanX === iMeanX) {
if (byMeanX[iMeanX] === undefined) {
byMeanX[iMeanX] = {};
}
if (byMeanX[iMeanX][pair[0].y] === undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
} else if (pair[0].x === pair[1].x) {
// console.log('x equal')
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
if (byMeanY[iMeanY] === undefined) {
byMeanY[iMeanY] = {};
}
if (byMeanY[iMeanY][pair[0].x] === undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].x]++;
}
}
}
}
let diamonds = 0;
for (let y of Object.keys(byMeanY)) {
for (let x of Object.keys(byMeanY[y])) {
// console.log('y, x byMeanX, byMeanXx:', y, x, byMeanX, byMeanX[x]);
if (byMeanX.hasOwnProperty(x) && byMeanX[x].hasOwnProperty(y)) {
diamonds += byMeanX[x][y] * byMeanY[y][x];
}
}
}
return diamonds;
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 10:20:17 UTC,
js,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
// check if y values are equal
if (pair[0].y === pair[1].y) {
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
// console.log('p.x meanX, iMeanX:',pair[0].x, meanX, iMeanX)
if (meanX !== pair[0].x && meanX === iMeanX) {
if (byMeanX[iMeanX] === undefined) {
byMeanX[iMeanX] = {};
}
if (byMeanX[iMeanX][pair[0].y] === undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
// check if x values are equal
} else if (pair[0].x === pair[1].x) {
// console.log('x equal')
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
if (byMeanY[iMeanY] === undefined) {
byMeanY[iMeanY] = {};
}
if (byMeanY[iMeanY][pair[0].x] === undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].x]++;
}
}
}
}
let diamonds = 0;
for (let y of Object.keys(byMeanY)) {
for (let x of Object.keys(byMeanY[y])) {
// console.log('y, x byMeanX, byMeanXx:', y, x, byMeanX, byMeanX[x]);
if (byMeanX.hasOwnProperty(x) && byMeanX[x].hasOwnProperty(y)) {
diamonds += byMeanX[x][y] * byMeanY[y][x];
}
}
}
return diamonds;
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 10:20:35 UTC,
js,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
// check if y values are equal
if (pair[0].y === pair[1].y) {
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
// check the mean is an int
if (meanX !== pair[0].x && meanX === iMeanX) {
if (byMeanX[iMeanX] === undefined) {
byMeanX[iMeanX] = {};
}
if (byMeanX[iMeanX][pair[0].y] === undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
// check if x values are equal
} else if (pair[0].x === pair[1].x) {
// console.log('x equal')
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
if (byMeanY[iMeanY] === undefined) {
byMeanY[iMeanY] = {};
}
if (byMeanY[iMeanY][pair[0].x] === undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].x]++;
}
}
}
}
let diamonds = 0;
for (let y of Object.keys(byMeanY)) {
for (let x of Object.keys(byMeanY[y])) {
// console.log('y, x byMeanX, byMeanXx:', y, x, byMeanX, byMeanX[x]);
if (byMeanX.hasOwnProperty(x) && byMeanX[x].hasOwnProperty(y)) {
diamonds += byMeanX[x][y] * byMeanY[y][x];
}
}
}
return diamonds;
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 10:20:45 UTC,
js,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
// check if y values are equal
if (pair[0].y === pair[1].y) {
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
// check the mean is an int and
if (meanX !== pair[0].x && meanX === iMeanX) {
if (byMeanX[iMeanX] === undefined) {
byMeanX[iMeanX] = {};
}
if (byMeanX[iMeanX][pair[0].y] === undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
// check if x values are equal
} else if (pair[0].x === pair[1].x) {
// console.log('x equal')
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
if (byMeanY[iMeanY] === undefined) {
byMeanY[iMeanY] = {};
}
if (byMeanY[iMeanY][pair[0].x] === undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].x]++;
}
}
}
}
let diamonds = 0;
for (let y of Object.keys(byMeanY)) {
for (let x of Object.keys(byMeanY[y])) {
// console.log('y, x byMeanX, byMeanXx:', y, x, byMeanX, byMeanX[x]);
if (byMeanX.hasOwnProperty(x) && byMeanX[x].hasOwnProperty(y)) {
diamonds += byMeanX[x][y] * byMeanY[y][x];
}
}
}
return diamonds;
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 10:21:05 UTC,
js,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
// check if y values are equal
if (pair[0].y === pair[1].y) {
// calculate the mean of x values
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
// check the mean is an int and
if (meanX !== pair[0].x && meanX === iMeanX) {
if (byMeanX[iMeanX] === undefined) {
byMeanX[iMeanX] = {};
}
if (byMeanX[iMeanX][pair[0].y] === undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
// check if x values are equal
} else if (pair[0].x === pair[1].x) {
// console.log('x equal')
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
if (byMeanY[iMeanY] === undefined) {
byMeanY[iMeanY] = {};
}
if (byMeanY[iMeanY][pair[0].x] === undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].x]++;
}
}
}
}
let diamonds = 0;
for (let y of Object.keys(byMeanY)) {
for (let x of Object.keys(byMeanY[y])) {
// console.log('y, x byMeanX, byMeanXx:', y, x, byMeanX, byMeanX[x]);
if (byMeanX.hasOwnProperty(x) && byMeanX[x].hasOwnProperty(y)) {
diamonds += byMeanX[x][y] * byMeanY[y][x];
}
}
}
return diamonds;
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 10:21:33 UTC,
js,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
// check if y values are equal
if (pair[0].y === pair[1].y) {
// calculate the mean of x values
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
// check the mean is an int and not the same
if (meanX !== pair[0].x && meanX === iMeanX) {
if (byMeanX[iMeanX] === undefined) {
byMeanX[iMeanX] = {};
}
if (byMeanX[iMeanX][pair[0].y] === undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
// check if x values are equal
} else if (pair[0].x === pair[1].x) {
// console.log('x equal')
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
if (byMeanY[iMeanY] === undefined) {
byMeanY[iMeanY] = {};
}
if (byMeanY[iMeanY][pair[0].x] === undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].x]++;
}
}
}
}
let diamonds = 0;
for (let y of Object.keys(byMeanY)) {
for (let x of Object.keys(byMeanY[y])) {
// console.log('y, x byMeanX, byMeanXx:', y, x, byMeanX, byMeanX[x]);
if (byMeanX.hasOwnProperty(x) && byMeanX[x].hasOwnProperty(y)) {
diamonds += byMeanX[x][y] * byMeanY[y][x];
}
}
}
return diamonds;
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 10:21:47 UTC,
js,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
// check if y values are equal
if (pair[0].y === pair[1].y) {
// calculate the mean of x values
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
// check the mean is an int and is a different value
if (meanX !== pair[0].x && meanX === iMeanX) {
if (byMeanX[iMeanX] === undefined) {
byMeanX[iMeanX] = {};
}
if (byMeanX[iMeanX][pair[0].y] === undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
// check if x values are equal
} else if (pair[0].x === pair[1].x) {
// console.log('x equal')
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
if (byMeanY[iMeanY] === undefined) {
byMeanY[iMeanY] = {};
}
if (byMeanY[iMeanY][pair[0].x] === undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].x]++;
}
}
}
}
let diamonds = 0;
for (let y of Object.keys(byMeanY)) {
for (let x of Object.keys(byMeanY[y])) {
// console.log('y, x byMeanX, byMeanXx:', y, x, byMeanX, byMeanX[x]);
if (byMeanX.hasOwnProperty(x) && byMeanX[x].hasOwnProperty(y)) {
diamonds += byMeanX[x][y] * byMeanY[y][x];
}
}
}
return diamonds;
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 10:22:11 UTC,
js,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
// check if y values are equal
if (pair[0].y === pair[1].y) {
// calculate the mean of x values
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
// check the mean is an int and is a different value (not same position)
if (meanX !== pair[0].x && meanX === iMeanX) {
if (byMeanX[iMeanX] === undefined) {
byMeanX[iMeanX] = {};
}
if (byMeanX[iMeanX][pair[0].y] === undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
// check if x values are equal
} else if (pair[0].x === pair[1].x) {
// console.log('x equal')
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
if (byMeanY[iMeanY] === undefined) {
byMeanY[iMeanY] = {};
}
if (byMeanY[iMeanY][pair[0].x] === undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].x]++;
}
}
}
}
let diamonds = 0;
for (let y of Object.keys(byMeanY)) {
for (let x of Object.keys(byMeanY[y])) {
// console.log('y, x byMeanX, byMeanXx:', y, x, byMeanX, byMeanX[x]);
if (byMeanX.hasOwnProperty(x) && byMeanX[x].hasOwnProperty(y)) {
diamonds += byMeanX[x][y] * byMeanY[y][x];
}
}
}
return diamonds;
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 10:25:01 UTC,
js,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
// check if y values are equal
if (pair[0].y === pair[1].y) {
// calculate the mean of x values
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
// check the mean is an int and is a different value (not same position)
if (meanX !== pair[0].x && meanX === iMeanX) {
if (byMeanX[iMeanX] === undefined) {
byMeanX[iMeanX] = {};
}
if (byMeanX[iMeanX][pair[0].y] === undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
// check if x values are equal
} else if (pair[0].x === pair[1].x) {
// console.log('x equal')
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
if (byMeanY[iMeanY] === undefined) {
byMeanY[iMeanY] = {};
}
if (byMeanY[iMeanY][pair[0].x] === undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].x]++;
}
}
}
}
let diamonds = 0; /
for (let y of Object.keys(byMeanY)) {
for (let x of Object.keys(byMeanY[y])) {
// console.log('y, x byMeanX, byMeanXx:', y, x, byMeanX, byMeanX[x]);
if (byMeanX.hasOwnProperty(x) && byMeanX[x].hasOwnProperty(y)) {
diamonds += byMeanX[x][y] * byMeanY[y][x];
}
}
}
return diamonds;
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 10:25:12 UTC,
js,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
// check if y values are equal
if (pair[0].y === pair[1].y) {
// calculate the mean of x values
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
// check the mean is an int and is a different value (not same position)
if (meanX !== pair[0].x && meanX === iMeanX) {
if (byMeanX[iMeanX] === undefined) {
byMeanX[iMeanX] = {};
}
if (byMeanX[iMeanX][pair[0].y] === undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
// check if x values are equal
} else if (pair[0].x === pair[1].x) {
// console.log('x equal')
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
if (byMeanY[iMeanY] === undefined) {
byMeanY[iMeanY] = {};
}
if (byMeanY[iMeanY][pair[0].x] === undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].x]++;
}
}
}
}
let diamonds = 0;
// check
for (let y of Object.keys(byMeanY)) {
for (let x of Object.keys(byMeanY[y])) {
// console.log('y, x byMeanX, byMeanXx:', y, x, byMeanX, byMeanX[x]);
if (byMeanX.hasOwnProperty(x) && byMeanX[x].hasOwnProperty(y)) {
diamonds += byMeanX[x][y] * byMeanY[y][x];
}
}
}
return diamonds;
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 10:26:00 UTC,
js,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
// check if y values are equal
if (pair[0].y === pair[1].y) {
// calculate the mean of x values
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
// check the mean is an int and is a different value (not same position)
if (meanX !== pair[0].x && meanX === iMeanX) {
if (byMeanX[iMeanX] === undefined) {
byMeanX[iMeanX] = {};
}
if (byMeanX[iMeanX][pair[0].y] === undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
// check if x values are equal
} else if (pair[0].x === pair[1].x) {
// console.log('x equal')
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
if (byMeanY[iMeanY] === undefined) {
byMeanY[iMeanY] = {};
}
if (byMeanY[iMeanY][pair[0].x] === undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].x]++;
}
}
}
}
let diamonds = 0;
// check the
for (let y of Object.keys(byMeanY)) {
for (let x of Object.keys(byMeanY[y])) {
// console.log('y, x byMeanX, byMeanXx:', y, x, byMeanX, byMeanX[x]);
if (byMeanX.hasOwnProperty(x) && byMeanX[x].hasOwnProperty(y)) {
diamonds += byMeanX[x][y] * byMeanY[y][x];
}
}
}
return diamonds;
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 10:26:10 UTC,
js,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
// check if y values are equal
if (pair[0].y === pair[1].y) {
// calculate the mean of x values
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
// check the mean is an int and is a different value (not same position)
if (meanX !== pair[0].x && meanX === iMeanX) {
if (byMeanX[iMeanX] === undefined) {
byMeanX[iMeanX] = {};
}
if (byMeanX[iMeanX][pair[0].y] === undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
// check if x values are equal
} else if (pair[0].x === pair[1].x) {
// console.log('x equal')
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
if (byMeanY[iMeanY] === undefined) {
byMeanY[iMeanY] = {};
}
if (byMeanY[iMeanY][pair[0].x] === undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].x]++;
}
}
}
}
let diamonds = 0;
// check there are two
for (let y of Object.keys(byMeanY)) {
for (let x of Object.keys(byMeanY[y])) {
// console.log('y, x byMeanX, byMeanXx:', y, x, byMeanX, byMeanX[x]);
if (byMeanX.hasOwnProperty(x) && byMeanX[x].hasOwnProperty(y)) {
diamonds += byMeanX[x][y] * byMeanY[y][x];
}
}
}
return diamonds;
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 10:26:20 UTC,
js,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
// check if y values are equal
if (pair[0].y === pair[1].y) {
// calculate the mean of x values
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
// check the mean is an int and is a different value (not same position)
if (meanX !== pair[0].x && meanX === iMeanX) {
if (byMeanX[iMeanX] === undefined) {
byMeanX[iMeanX] = {};
}
if (byMeanX[iMeanX][pair[0].y] === undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
// check if x values are equal
} else if (pair[0].x === pair[1].x) {
// console.log('x equal')
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
if (byMeanY[iMeanY] === undefined) {
byMeanY[iMeanY] = {};
}
if (byMeanY[iMeanY][pair[0].x] === undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].x]++;
}
}
}
}
let diamonds = 0;
// check there are two values
for (let y of Object.keys(byMeanY)) {
for (let x of Object.keys(byMeanY[y])) {
// console.log('y, x byMeanX, byMeanXx:', y, x, byMeanX, byMeanX[x]);
if (byMeanX.hasOwnProperty(x) && byMeanX[x].hasOwnProperty(y)) {
diamonds += byMeanX[x][y] * byMeanY[y][x];
}
}
}
return diamonds;
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 10:26:35 UTC,
js,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
// check if y values are equal
if (pair[0].y === pair[1].y) {
// calculate the mean of x values
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
// check the mean is an int and is a different value (not same position)
if (meanX !== pair[0].x && meanX === iMeanX) {
if (byMeanX[iMeanX] === undefined) {
byMeanX[iMeanX] = {};
}
if (byMeanX[iMeanX][pair[0].y] === undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
// check if x values are equal
} else if (pair[0].x === pair[1].x) {
// console.log('x equal')
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
if (byMeanY[iMeanY] === undefined) {
byMeanY[iMeanY] = {};
}
if (byMeanY[iMeanY][pair[0].x] === undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].x]++;
}
}
}
}
let diamonds = 0;
// check there is
for (let y of Object.keys(byMeanY)) {
for (let x of Object.keys(byMeanY[y])) {
// console.log('y, x byMeanX, byMeanXx:', y, x, byMeanX, byMeanX[x]);
if (byMeanX.hasOwnProperty(x) && byMeanX[x].hasOwnProperty(y)) {
diamonds += byMeanX[x][y] * byMeanY[y][x];
}
}
}
return diamonds;
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 10:26:55 UTC,
js,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
// check if y values are equal
if (pair[0].y === pair[1].y) {
// calculate the mean of x values
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
// check the mean is an int and is a different value (not same position)
if (meanX !== pair[0].x && meanX === iMeanX) {
if (byMeanX[iMeanX] === undefined) {
byMeanX[iMeanX] = {};
}
if (byMeanX[iMeanX][pair[0].y] === undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
// check if x values are equal
} else if (pair[0].x === pair[1].x) {
// console.log('x equal')
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
if (byMeanY[iMeanY] === undefined) {
byMeanY[iMeanY] = {};
}
if (byMeanY[iMeanY][pair[0].x] === undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].x]++;
}
}
}
}
let diamonds = 0;
for (let y of Object.keys(byMeanY)) {
for (let x of Object.keys(byMeanY[y])) {
// console.log('y, x byMeanX, byMeanXx:', y, x, byMeanX, byMeanX[x]);
if (byMeanX.hasOwnProperty(x) && byMeanX[x].hasOwnProperty(y)) {
diamonds += byMeanX[x][y] * byMeanY[y][x];
}
}
}
return diamonds;
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 10:27:11 UTC,
js,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
// check if y values are equal
if (pair[0].y === pair[1].y) {
// calculate the mean of x values
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
// check the mean is an int and is a different value (not same position)
if (meanX !== pair[0].x && meanX === iMeanX) {
if (byMeanX[iMeanX] === undefined) {
byMeanX[iMeanX] = {};
}
if (byMeanX[iMeanX][pair[0].y] === undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
// check if x values are equal
} else if (pair[0].x === pair[1].x) {
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
if (byMeanY[iMeanY] === undefined) {
byMeanY[iMeanY] = {};
}
if (byMeanY[iMeanY][pair[0].x] === undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].x]++;
}
}
}
}
let diamonds = 0;
for (let y of Object.keys(byMeanY)) {
for (let x of Object.keys(byMeanY[y])) {
// console.log('y, x byMeanX, byMeanXx:', y, x, byMeanX, byMeanX[x]);
if (byMeanX.hasOwnProperty(x) && byMeanX[x].hasOwnProperty(y)) {
diamonds += byMeanX[x][y] * byMeanY[y][x];
}
}
}
return diamonds;
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 10:27:21 UTC,
js,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
// check if y values are equal
if (pair[0].y === pair[1].y) {
// calculate the mean of x values
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
// check the mean is an int and is a different value (not same position)
if (meanX !== pair[0].x && meanX === iMeanX) {
if (byMeanX[iMeanX] === undefined) {
byMeanX[iMeanX] = {};
}
if (byMeanX[iMeanX][pair[0].y] === undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
// check if x values are equal
} else if (pair[0].x === pair[1].x) {
// calculate the mean of y values
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
if (meanY !== pair[0].y && meanY === iMeanY) {
if (byMeanY[iMeanY] === undefined) {
byMeanY[iMeanY] = {};
}
if (byMeanY[iMeanY][pair[0].x] === undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].x]++;
}
}
}
}
let diamonds = 0;
for (let y of Object.keys(byMeanY)) {
for (let x of Object.keys(byMeanY[y])) {
// console.log('y, x byMeanX, byMeanXx:', y, x, byMeanX, byMeanX[x]);
if (byMeanX.hasOwnProperty(x) && byMeanX[x].hasOwnProperty(y)) {
diamonds += byMeanX[x][y] * byMeanY[y][x];
}
}
}
return diamonds;
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 10:27:31 UTC,
js,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
// check if y values are equal
if (pair[0].y === pair[1].y) {
// calculate the mean of x values
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
// check the mean is an int and is a different value (not same position)
if (meanX !== pair[0].x && meanX === iMeanX) {
if (byMeanX[iMeanX] === undefined) {
byMeanX[iMeanX] = {};
}
if (byMeanX[iMeanX][pair[0].y] === undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
// check if x values are equal
} else if (pair[0].x === pair[1].x) {
// calculate the mean of y values
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
// check the mean is an int and is a different value (not same position)
if (meanY !== pair[0].y && meanY === iMeanY) {
if (byMeanY[iMeanY] === undefined) {
byMeanY[iMeanY] = {};
}
if (byMeanY[iMeanY][pair[0].x] === undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].x]++;
}
}
}
}
let diamonds = 0;
for (let y of Object.keys(byMeanY)) {
for (let x of Object.keys(byMeanY[y])) {
// console.log('y, x byMeanX, byMeanXx:', y, x, byMeanX, byMeanX[x]);
if (byMeanX.hasOwnProperty(x) && byMeanX[x].hasOwnProperty(y)) {
diamonds += byMeanX[x][y] * byMeanY[y][x];
}
}
}
return diamonds;
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 10:28:01 UTC,
js,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
// check if y values are equal
if (pair[0].y === pair[1].y) {
// calculate the mean of x values
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
// check the mean is an int and is a different value (not same position)
if (meanX !== pair[0].x && meanX === iMeanX) {
if (byMeanX[iMeanX] === undefined) {
byMeanX[iMeanX] = {};
}
if (byMeanX[iMeanX][pair[0].y] === undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
// check if x values are equal
} else if (pair[0].x === pair[1].x) {
// calculate the mean of y values
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
// check the mean is an int and is a different value (not same position)
if (meanY !== pair[0].y && meanY === iMeanY) {
// store values in byMeanY object of objects
if (byMeanY[iMeanY] === undefined) {
byMeanY[iMeanY] = {};
}
if (byMeanY[iMeanY][pair[0].x] === undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].x]++;
}
}
}
}
let diamonds = 0;
for (let y of Object.keys(byMeanY)) {
for (let x of Object.keys(byMeanY[y])) {
// console.log('y, x byMeanX, byMeanXx:', y, x, byMeanX, byMeanX[x]);
if (byMeanX.hasOwnProperty(x) && byMeanX[x].hasOwnProperty(y)) {
diamonds += byMeanX[x][y] * byMeanY[y][x];
}
}
}
return diamonds;
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 10:28:11 UTC,
js,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
// check if y values are equal
if (pair[0].y === pair[1].y) {
// calculate the mean of x values
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
// check the mean is an int and is a different value (not same position)
if (meanX !== pair[0].x && meanX === iMeanX) {
// store values in byMeanX object of objects
if (byMeanX[iMeanX] === undefined) {
byMeanX[iMeanX] = {};
}
if (byMeanX[iMeanX][pair[0].y] === undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
// check if x values are equal
} else if (pair[0].x === pair[1].x) {
// calculate the mean of y values
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
// check the mean is an int and is a different value (not same position)
if (meanY !== pair[0].y && meanY === iMeanY) {
// store values in byMeanY object of objects
if (byMeanY[iMeanY] === undefined) {
byMeanY[iMeanY] = {};
}
if (byMeanY[iMeanY][pair[0].x] === undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].x]++;
}
}
}
}
let diamonds = 0;
for (let y of Object.keys(byMeanY)) {
for (let x of Object.keys(byMeanY[y])) {
// console.log('y, x byMeanX, byMeanXx:', y, x, byMeanX, byMeanX[x]);
if (byMeanX.hasOwnProperty(x) && byMeanX[x].hasOwnProperty(y)) {
diamonds += byMeanX[x][y] * byMeanY[y][x];
}
}
}
return diamonds;
}
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 10:28:41 UTC,
js,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
// check if y values are equal
if (pair[0].y === pair[1].y) {
// calculate the mean of x values
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
// check the mean is an int and is a different value (not same position)
if (meanX !== pair[0].x && meanX === iMeanX) {
// store values in byMeanX object of objects
if (byMeanX[iMeanX] === undefined) {
byMeanX[iMeanX] = {};
}
if (byMeanX[iMeanX][pair[0].y] === undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
// check if x values are equal
} else if (pair[0].x === pair[1].x) {
// calculate the mean of y values
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
// check the mean is an int and is a different value (not same position)
if (meanY !== pair[0].y && meanY === iMeanY) {
// store values in byMeanY object of objects
if (byMeanY[iMeanY] === undefined) {
byMeanY[iMeanY] = {};
}
if (byMeanY[iMeanY][pair[0].x] === undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].x]++;
}
}
}
}
let diamonds = 0;
for (let y of Object.keys(byMeanY)) {
for (let x of Object.keys(byMeanY[y])) {
// console.log('y, x byMeanX, byMeanXx:', y, x, byMeanX, byMeanX[x]);
if (byMeanX.hasOwnProperty(x) && byMeanX[x].hasOwnProperty(y)) {
diamonds += byMeanX[x][y] * byMeanY[y][x];
}
}
}
return diamonds;
}
// return all the different combinations of two points
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Code: 10:28:42 UTC,
js,
verify,
result: Passed
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
// check if y values are equal
if (pair[0].y === pair[1].y) {
// calculate the mean of x values
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
// check the mean is an int and is a different value (not same position)
if (meanX !== pair[0].x && meanX === iMeanX) {
// store values in byMeanX object of objects
if (byMeanX[iMeanX] === undefined) {
byMeanX[iMeanX] = {};
}
if (byMeanX[iMeanX][pair[0].y] === undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
// check if x values are equal
} else if (pair[0].x === pair[1].x) {
// calculate the mean of y values
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
// check the mean is an int and is a different value (not same position)
if (meanY !== pair[0].y && meanY === iMeanY) {
// store values in byMeanY object of objects
if (byMeanY[iMeanY] === undefined) {
byMeanY[iMeanY] = {};
}
if (byMeanY[iMeanY][pair[0].x] === undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].x]++;
}
}
}
}
let diamonds = 0;
for (let y of Object.keys(byMeanY)) {
for (let x of Object.keys(byMeanY[y])) {
// console.log('y, x byMeanX, byMeanXx:', y, x, byMeanX, byMeanX[x]);
if (byMeanX.hasOwnProperty(x) && byMeanX[x].hasOwnProperty(y)) {
diamonds += byMeanX[x][y] * byMeanY[y][x];
}
}
}
return diamonds;
}
// return all the different combinations of two points
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Analysis
Code: 10:28:46 UTC,
js,
verify,
result: Passed
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
// check if y values are equal
if (pair[0].y === pair[1].y) {
// calculate the mean of x values
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
// check the mean is an int and is a different value (not same position)
if (meanX !== pair[0].x && meanX === iMeanX) {
// store values in byMeanX object of objects
if (byMeanX[iMeanX] === undefined) {
byMeanX[iMeanX] = {};
}
if (byMeanX[iMeanX][pair[0].y] === undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
// check if x values are equal
} else if (pair[0].x === pair[1].x) {
// calculate the mean of y values
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
// check the mean is an int and is a different value (not same position)
if (meanY !== pair[0].y && meanY === iMeanY) {
// store values in byMeanY object of objects
if (byMeanY[iMeanY] === undefined) {
byMeanY[iMeanY] = {};
}
if (byMeanY[iMeanY][pair[0].x] === undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].x]++;
}
}
}
}
let diamonds = 0;
for (let y of Object.keys(byMeanY)) {
for (let x of Object.keys(byMeanY[y])) {
// console.log('y, x byMeanX, byMeanXx:', y, x, byMeanX, byMeanX[x]);
if (byMeanX.hasOwnProperty(x) && byMeanX[x].hasOwnProperty(y)) {
diamonds += byMeanX[x][y] * byMeanY[y][x];
}
}
}
return diamonds;
}
// return all the different combinations of two points
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Analysis
Code: 10:28:48 UTC,
js,
final,
score:
44
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576
// you can write to stdout for debugging purposes, e.g.
// console.log('this is a debug message');
function solution(X, Y) {
// write your code in JavaScript (Node.js 8.9.4)
let points = [];
for (let i = 0; i < X.length; i++) {
points.push({x:X[i], y:Y[i]});
}
let max = Math.max(...X, ...Y);
let byMeanX = {};
let byMeanY = {};
let combinations = combinationsOfTwo(points);
for (let pair of combinations) {
// check if y values are equal
if (pair[0].y === pair[1].y) {
// calculate the mean of x values
let meanX = (pair[0].x + pair[1].x) / 2;
let iMeanX = parseInt(meanX);
// check the mean is an int and is a different value (not same position)
if (meanX !== pair[0].x && meanX === iMeanX) {
// store values in byMeanX object of objects
if (byMeanX[iMeanX] === undefined) {
byMeanX[iMeanX] = {};
}
if (byMeanX[iMeanX][pair[0].y] === undefined) {
byMeanX[iMeanX][pair[0].y] = 1;
} else {
byMeanX[iMeanX][pair[0].y]++;
}
}
// check if x values are equal
} else if (pair[0].x === pair[1].x) {
// calculate the mean of y values
let meanY = (pair[0].y + pair[1].y) / 2;
let iMeanY = parseInt(meanY);
// check the mean is an int and is a different value (not same position)
if (meanY !== pair[0].y && meanY === iMeanY) {
// store values in byMeanY object of objects
if (byMeanY[iMeanY] === undefined) {
byMeanY[iMeanY] = {};
}
if (byMeanY[iMeanY][pair[0].x] === undefined) {
byMeanY[iMeanY][pair[0].x] = 1;
} else {
byMeanY[iMeanY][pair[0].x]++;
}
}
}
}
let diamonds = 0;
for (let y of Object.keys(byMeanY)) {
for (let x of Object.keys(byMeanY[y])) {
// console.log('y, x byMeanX, byMeanXx:', y, x, byMeanX, byMeanX[x]);
if (byMeanX.hasOwnProperty(x) && byMeanX[x].hasOwnProperty(y)) {
diamonds += byMeanX[x][y] * byMeanY[y][x];
}
}
}
return diamonds;
}
// return all the different combinations of two points
function combinationsOfTwo(A) {
let comb = []
for (let i = 0; i < A.length - 1; i++) {
for (let j = i+1; j < A.length; j++) {
comb.push([A[i],A[j]]);
}
}
return comb;
}
Analysis summary
The following issues have been detected: timeout errors.
Analysis
Detected time complexity:
O(N**4)
expand all
Correctness tests
1.
0.068 s
OK
2.
0.068 s
OK
1.
0.068 s
OK
1.
0.068 s
OK
2.
0.068 s
OK
3.
0.068 s
OK
4.
0.068 s
OK
1.
0.068 s
OK
2.
0.068 s
OK
expand all
Performance tests
1.
0.568 s
TIMEOUT ERROR,
running time: 0.568 sec., time limit: 0.528 sec.
2.
0.572 s
TIMEOUT ERROR,
running time: 0.572 sec., time limit: 0.544 sec.
3.
0.484 s
TIMEOUT ERROR,
running time: 0.484 sec., time limit: 0.464 sec.
1.
0.564 s
TIMEOUT ERROR,
running time: 0.564 sec., time limit: 0.560 sec.
2.
0.604 s
TIMEOUT ERROR,
running time: 0.604 sec., time limit: 0.544 sec.
3.
0.560 s
TIMEOUT ERROR,
running time: 0.560 sec., time limit: 0.528 sec.
max_one_line
max tests with many points in one line
max tests with many points in one line
✘
TIMEOUT ERROR
running time: 0.740 sec., time limit: 0.512 sec.
running time: 0.740 sec., time limit: 0.512 sec.
1.
0.740 s
TIMEOUT ERROR,
running time: 0.740 sec., time limit: 0.512 sec.
2.
0.752 s
TIMEOUT ERROR,
running time: 0.752 sec., time limit: 0.496 sec.
max_cross_square
points arranged in a cross or square
points arranged in a cross or square
✘
TIMEOUT ERROR
running time: 0.700 sec., time limit: 0.480 sec.
running time: 0.700 sec., time limit: 0.480 sec.
1.
0.700 s
TIMEOUT ERROR,
running time: 0.700 sec., time limit: 0.480 sec.
2.
0.616 s
TIMEOUT ERROR,
running time: 0.616 sec., time limit: 0.528 sec.
3.
0.640 s
TIMEOUT ERROR,
running time: 0.640 sec., time limit: 0.512 sec.
max_three_lines
max tests with points in three parallel lines
max tests with points in three parallel lines
✘
TIMEOUT ERROR
running time: 0.608 sec., time limit: 0.528 sec.
running time: 0.608 sec., time limit: 0.528 sec.
1.
0.608 s
TIMEOUT ERROR,
running time: 0.608 sec., time limit: 0.528 sec.
2.
0.612 s
TIMEOUT ERROR,
running time: 0.612 sec., time limit: 0.512 sec.