AdventOfCode/19

var transformations = [
    p => [ p[0], p[1], p[2] ],
    p => [ p[0], p[2], p[1] ],
    p => [ p[1], p[0], p[2] ],
    p => [ p[1], p[2], p[0] ],
    p => [ p[2], p[0], p[1] ],
    p => [ p[2], p[1], p[0] ],

    p => [ -p[0], p[1], p[2] ],
    p => [ -p[0], p[2], p[1] ],
    p => [ -p[1], p[0], p[2] ],
    p => [ -p[1], p[2], p[0] ],
    p => [ -p[2], p[0], p[1] ],
    p => [ -p[2], p[1], p[0] ],

    p => [ p[0], -p[1], p[2] ],
    p => [ p[0], -p[2], p[1] ],
    p => [ p[1], -p[0], p[2] ],
    p => [ p[1], -p[2], p[0] ],
    p => [ p[2], -p[0], p[1] ],
    p => [ p[2], -p[1], p[0] ],

    p => [ p[0], p[1], -p[2] ],
    p => [ p[0], p[2], -p[1] ],
    p => [ p[1], p[0], -p[2] ],
    p => [ p[1], p[2], -p[0] ],
    p => [ p[2], p[0], -p[1] ],
    p => [ p[2], p[1], -p[0] ],

    p => [ -p[0], -p[1], p[2] ],
    p => [ -p[0], -p[2], p[1] ],
    p => [ -p[1], -p[0], p[2] ],
    p => [ -p[1], -p[2], p[0] ],
    p => [ -p[2], -p[0], p[1] ],
    p => [ -p[2], -p[1], p[0] ],

    p => [ p[0], -p[1], -p[2] ],
    p => [ p[0], -p[2], -p[1] ],
    p => [ p[1], -p[0], -p[2] ],
    p => [ p[1], -p[2], -p[0] ],
    p => [ p[2], -p[0], -p[1] ],
    p => [ p[2], -p[1], -p[0] ],

    p => [ -p[0], p[1], -p[2] ],
    p => [ -p[0], p[2], -p[1] ],
    p => [ -p[1], p[0], -p[2] ],
    p => [ -p[1], p[2], -p[0] ],
    p => [ -p[2], p[0], -p[1] ],
    p => [ -p[2], p[1], -p[0] ],

    p => [ -p[0], -p[1], -p[2] ],
    p => [ -p[0], -p[2], -p[1] ],
    p => [ -p[1], -p[0], -p[2] ],
    p => [ -p[1], -p[2], -p[0] ],
    p => [ -p[2], -p[0], -p[1] ],
    p => [ -p[2], -p[1], -p[0] ]
]

var pyt = (p1, p2) => {
    var d = 0;
    for (var i = 0; i < p1.length; i++) {
        d += Math.pow(p2[i] - p1[i], 2)
    }
    return d;
}

var fnFromStringToArray = str => str.split(',').map(v => parseInt(v));

var fnOverlap = (index_pos, index_map, i, j) =>
    index_map[i].map((absolute_distances, absolute_index) => {
        var relative_index;
        index_map[j].forEach((e, i) => {
            if (absolute_distances.filter(v => e.find(w => v.d === w.d)).length >= 11) relative_index = i;
        });
        if (relative_index === undefined) return undefined;
        return ({
            absolute_point: index_pos[i][absolute_index],
            relative_point: index_pos[j][relative_index]
        });
    }).filter(m => m);

var offset_point = (p, o) => [ p[0] + o[0], p[1] + o[1], p[2] + o[2] ];

var equ = (arr1, arr2) => {
    for (var i = 0; i < arr1.length; i++) {
        if (arr1[i] !== arr2[i]) return false;
    }
    return true;
}

export function execute(input_data) {
    var input = input_data.split('\n\n').map(i => i.split('\n').slice(1).map(v => v.split(',').map(v => parseInt(v))));
    var dist = [];
    input.forEach((i, s) => i.forEach((from, index_from) => i.filter(to => to !== from).forEach((to, index_to) => {
        if (!dist[s]) dist[s] = [];
        if (!dist[s][index_from]) dist[s][index_from] = [];
        dist[s][index_from].push({ d: pyt(from, to), to: index_to });
    })));
    var trans = [ 0 ];
    var offsets = [ [0,0,0] ];
    var beacons = {};
    while (trans.length < input.length) {
        trans.push(trans.shift());
        var m = trans[0];
        for (var n = 0; n < input.length; n++) {
            if (n !== m && !trans.includes(n)) {
                var overlap = fnOverlap(input, dist, m, n);
                if (overlap.length > 0) {
                    overlap.forEach(p => {
                        transformations.forEach((t, i) => {
                            if (trans.includes(n)) return;
                            var offset = offset_point(p.absolute_point, t(p.relative_point).map(c => -c));
                            if (overlap.filter(o => equ(offset_point(t(o.relative_point), offset), o.absolute_point)).length === overlap.length) {
                                trans.push(n);
                                input[n] = input[n].map(i => offset_point(t(i), offset));
                                offsets.push(offset);
                            }
                        });
                    });
                }
            }
        }
    }
    console.log('Transforming ...');
    input.forEach((s, d) => s.forEach(p => beacons[p] = true));
    return [
        Object.keys(beacons).length,
        Math.max(...offsets.flatMap((o, i) => offsets.slice(i + 1).map(u => Math.abs(u[0] - o[0]) + Math.abs(u[1] - o[1]) + Math.abs(u[2] - o[2]))))
    ]
}