Test results - Codility

Code: 09:24:07 UTC, java, autosave

1 2 3 4 5 6 7 8 9 10 11

// you can also use imports, for example:
// import java.util.*;

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

class Solution {
    public int solution(int[] X, int[] Y) {
        // write your code in Java SE 8
    }
}

Code: 09:24:11 UTC, js, autosave

1 2 3 4 5 6

// 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)
}

Code: 09:26:07 UTC, js, autosave

1 2 3 4 5 6 7 8

// 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 )
}

Code: 09:26:18 UTC, js, autosave

1 2 3 4 5 6 7 8

// 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)
}

Code: 09:26:29 UTC, js, autosave

1 2 3 4 5 6 7 8

// 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)
}

Code: 09:26:51 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10

// 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([])
    }
}

Code: 09:27:21 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10

// 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],])
    }
}

Code: 09:27:31 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10

// 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]])
    }
}

Code: 09:28:28 UTC, js, autosave

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

// 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]])
    }
}

Code: 09:28:38 UTC, js, autosave

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

// 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

Code: 09:29:01 UTC, js, autosave

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

// 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

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

// 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

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

// 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

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

// 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

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

// 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

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

// 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

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

// 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

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

// 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

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

// 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

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

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

// 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

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

// 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

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

// 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

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

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

// 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;
}

The submission is being evaluated.

Code: 09:36:36 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

// 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;
}

The submission is being evaluated.

Code: 09:36:50 UTC, js, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

// 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;
}

The submission is being evaluated.

Code: 09:37:01 UTC, js, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

// 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;
}

The submission is being evaluated.

Code: 09:38:04 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

// 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;
}

The submission is being evaluated.

Code: 09:38:29 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

// 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;
}

The submission is being evaluated.

Code: 09:38:48 UTC, js, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

// 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;
}

The submission is being evaluated.

Code: 09:38:59 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

// 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;
}

The submission is being evaluated.

Code: 09:39:15 UTC, js, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

// 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;
}

The submission is being evaluated.

Code: 09:39:29 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62

// 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;
}

The submission is being evaluated.

Code: 10:01:44 UTC, js, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62

// 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;
}

The submission is being evaluated.

Code: 10:01:54 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62

// 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;
}

The submission is being evaluated.

Code: 10:02:20 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64

// 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;
}

The submission is being evaluated.

Code: 10:02:44 UTC, js, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64

// 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;
}

The submission is being evaluated.

Code: 10:02:51 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65

// 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;
}

The submission is being evaluated.

Code: 10:03:21 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66

// you can 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66

// you can 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;
}

The submission is being evaluated.

Code: 10:03:51 UTC, js, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67

// 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;
}

The submission is being evaluated.

Code: 10:04:30 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68

// 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;
}

The submission is being evaluated.

Code: 10:05:20 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68

// 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;
}

The submission is being evaluated.

Code: 10:06:11 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68

// 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;
}

The submission is being evaluated.

Code: 10:07:13 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71

// you can 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71

// you can 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;
}

The submission is being evaluated.

Code: 10:09:11 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72

// 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;
}

The submission is being evaluated.

Code: 10:09:48 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75

// 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;
}

The submission is being evaluated.

Code: 10:11:48 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75

// 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;
}

The submission is being evaluated.

Code: 10:12:12 UTC, js, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75

// 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;
}

The submission is being evaluated.

Code: 10:12:44 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75

// 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;
}

The submission is being evaluated.

Code: 10:13:47 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75

// 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;
}

The submission is being evaluated.

Code: 10:14:13 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76

// 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;
}

The submission is being evaluated.

Code: 10:14:52 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77

// 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;
}

The submission is being evaluated.

Code: 10:15:39 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76

// 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;
}

The submission is being evaluated.

Code: 10:16:30 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73

// you can 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;
}

The submission is being evaluated.

Code: 10:16:59 UTC, js, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73

// you can 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;
}

The submission is being evaluated.

Code: 10:17:33 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73

// you can 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73

// you can 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73

// you can 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;
}

The submission is being evaluated.

Code: 10:19:33 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71

// you can 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69

// 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;
}

The submission is being evaluated.

Code: 10:19:53 UTC, js, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71

// you can 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71

// you can 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71

// you can 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73

// you can 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73

// you can 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73

// you can 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73

// you can 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73

// you can 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71

// you can 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73

// you can 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76

// 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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76

// 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;
}

The submission is being evaluated.

Code: 10:28:46 UTC, js, verify, result: Passed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76

// 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;
}

The submission is being evaluated.

Code: 10:28:48 UTC, js, final, score: 44

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76

// 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;
}

The submission is being evaluated.