Petey Pattern RNG Source Code

'use strict'

if (!Array.prototype.flatMap)
    Array.prototype.flatMap = function (callback, self) { return this.reduce((acc, x, i, a) => acc.concat(callback.call(self || this, x, i, a)), []) }

function stepPattern(p) {
    if (!p || !p.pat || !p.pat.length)  return []

    const prev = p.pat[p.pat.length - 2],
        curr = p.pat[p.pat.length - 1],
        nb = neighbors[curr],
        prevNb = nb.findIndex(n => n.node === prev)

    if (nb.length === 2 && ~prevNb) {
        const next = nb[0].node === prev ? nb[1] : nb[0]
        return [{pat: p.pat.concat(next.node), time: p.time + next.time, prob: p.prob}]
    }

    const baseProb = p.prob / nb.length

    return nb.map(({node: n, time: t}, i) => ({
            pat: p.pat.concat(n),
            time: p.time + t,
            prob: n === prev ? 0 : (i === 0 && prevNb === nb.length - 1 || i === nb.length - 1 && ~prevNb)
                ? baseProb * 2
                : baseProb
        })).filter(p => p.prob)
}

// Timed by Chockrit: https://docs.google.com/spreadsheets/d/1DPyOlO2szc7D3GnhY9RJXwX1j6aM7XgKMhDthwqJE8E/
const neighbors = {
    'N1': [{node: 'S1', time: 5.072}, {node: 'N2', time: 4.771}, {node: 'S8', time: 4.12}, {node: 'S4', time: 5.956}],
    'N2': [{node: 'S5', time: 7.04}, {node: 'S1', time: 5.555}, {node: 'N5', time: 4.838}, {node: 'N1', time: 4.771}],
    'N3': [{node: 'S3', time: 9.926}, {node: 'N5', time: 6.573}, {node: 'S2', time: 3.904}, {node: 'S7', time: 9.909}],
    'N4': [{node: 'S1', time: 9.66}, {node: 'S2', time: 8.709}, {node: 'S8', time: 7.875}, {node: 'N6', time: 6.74}],
    'N5': [{node: 'N3', time: 6.573}, {node: 'S5', time: 6.246}, {node: 'S7', time: 6.923}, {node: 'N2', time: 4.838}],
    'N6': [{node: 'N4', time: 6.74}, {node: 'S3', time: 5.922}],
    'N7': [{node: 'S3', time: 14.381}, {node: 'S7', time: 14.398}], // no data, using S3 <-> S7 instead
    'S1': [{node: 'N1', time: 6.974}, {node: 'S2', time: 7.641}, {node: 'N2', time: 7.457}, {node: 'N4', time: 11.562}],
    'S2': [{node: 'S1', time: 7.958}, {node: 'S3', time: 11.694}, {node: 'N4', time: 10.928}, {node: 'N3', time: 6.123}],
    'S3': [{node: 'S2', time: 11.328}, {node: 'N3', time: 11.779}, {node: 'N6', time: 7.775}, {node: 'N7', time: 3.137}],
    'S4': [{node: 'S5', time: 10.577}, {node: 'N1', time: 7.908}],
    'S5': [{node: 'N5', time: 8.345}, {node: 'N2', time: 9.139}, {node: 'S6', time: 11.341}, {node: 'S4', time: 10.724}],
    'S6': [{node: 'S7', time: 10.043}, {node: 'S5', time: 11.511}],
    'S7': [{node: 'N3', time: 12.008}, {node: 'N5', time: 9.022}, {node: 'N7', time: 3.4}, {node: 'S6', time: 9.873}],
    'S8': [{node: 'N1', time: 6.056}, {node: 'N4', time: 9.811}]
}

let patterns = [{pat: ['N1'], time: 0, prob: 1}], completePatterns = []

while (patterns.length) {
    [patterns, completePatterns] = patterns.flatMap(stepPattern)
        .reduce(([pending, done], p) => p.pat.some(function (n) { return !(this.cnt -= n.startsWith('S')) }, {cnt: 3}) // if a pattern has at least 3 stops, it's complete
            ? [pending, done.concat(p)]
            : [pending.concat(p), done],
        [[], completePatterns])
}

console.table(completePatterns.sort((a, b) => a.time - b.time)
        .map(({pat, prob, time}) => ({pat: pat.join(' '), time: time.toFixed(3), invProb: 1 / prob})))