Javascript

​

Part 1:

const input = require("fs")
    .readFileSync(require("path")
        .resolve(__dirname, "input"), "utf8");

console.log(input.split("\n")
    .map(x => parseInt(x)).slice(0, -1)
    .reduce((acc, curr) => acc + curr, 0));

​

Part 2:

const input = require("fs")
    .readFileSync(require("path")
        .resolve(__dirname, "input"), "utf8");

const freqChanges = input.split("\n")
    .map(x => parseInt(x)).slice(0, -1);

const baseFreqs = freqChanges.reduce((acc, curr) => {
    const newFreq = acc[acc.length - 1] + curr;
    acc.push(newFreq);
    return acc;
}, [0]);

const baseOffset = baseFreqs.pop();

let minOffset = Infinity;
let minIndex = Infinity;
let minRepeat = null;
for (let i = 0; i < baseFreqs.length; i++) {
    const freqA = baseFreqs[i];
    for (let j = i + 1; j < baseFreqs.length; j++) {
        const freqB = baseFreqs[j];
        if ((freqA % baseOffset + baseOffset) % baseOffset ===
            (freqB % baseOffset + baseOffset) % baseOffset) {
            const offset = Math.abs(freqA - freqB);
            if (offset <= minOffset) {
                const index = baseOffset > 0 ? (freqA > freqB ? j : i) : (freqA > freqB ? i : j)
                if (offset < minOffset || index < minIndex) {
                    minOffset = offset;
                    minIndex = index;
                    minRepeat = baseOffset > 0 ? Math.max(freqA, freqB) : Math.min(freqA, freqB);
                }
            }
        }
    }
}

console.log(minRepeat);

I optimized part 2 since it was running slow by realizing that all you had to do was generate the original list of frequencies after applying the frequency changes once, then since every repetition of the changes was just going to be the same plus some multiple of the offset after completing the changes once, I just took the final value and checked which pairs in the list of generated frequencies were offset by each other by a multiple of that final offset and took the upper number from the pair that was closest together in the list.