🌟 Advent of Code (AoC) 2020 🌟

Imports System.IO

Module Program
    Sub Main(args As String())
        Dim input As New List(Of Long)
        For Each line In File.ReadAllLines("input.txt")
            If Not String.IsNullOrWhiteSpace(line) Then input.Add(Long.Parse(line))
        Next

        Dim partOne = input(FindInvalidIndex(25, input))
        Dim partTwo = FindContiguous(FindInvalidIndex(25, input), input)

        Console.WriteLine("Part 1: " & partOne.ToString())
        Console.WriteLine("Part 2: " & partTwo.ToString())
    End Sub

    Function FindContiguous(index As Integer, input As List(Of Long)) As Long
        For i = 0 To index - 1
            Dim sum As Integer = input(i)
            For j = i + 1 To index - 1
                sum += input(j)
                If sum = input(index) Then Return input(i) + input(j)
            Next
        Next
        Return 0
    End Function

    Function FindInvalidIndex(preamble As Integer, input As List(Of Long)) As Long
        For i = preamble To input.Count - 1
            If Not isValid(preamble, input, i) Then Return i
        Next
        Return 0
    End Function

    Function isValid(preamble As Integer, input As List(Of Long), indexToTest As Integer)
        For i = indexToTest - preamble To indexToTest - 1
            For j = i + 1 To indexToTest - 1
                If input(i) + input(j) = input(indexToTest) Then Return True
            Next
        Next
        Return False
    End Function
End Module

part1$ <in sort -n | awk '$1 - x == 1 { a += 1 } $1 - x == 3 { b += 1 } { x = $1 } END { print a * (b + 1) }'
part2$ <in sort -n | awk '{ n[NR] = $1 } END { print ff(0, 1) }
function ff(c, i) { if (c in s) { return s[c] } else { return s[c] = f(c, i) } }
function f(c, i) {
	if (n[i] - c <= 3) {
		if (i == NR) { return 1 }
		return ff(n[i], i + 1) + ff(c, i + 1)
	}
}'

<in sort -n | awk '{ n[NR] = $1 } END { print f(0, 1) } function f(c, i) { return c in s ? s[c] : s[c] = n[i] - c <= 3 ? i == NR ? 1 : f(n[i], i + 1) + f(c, i + 1) : 0 }'

function calculate(list) {
    let one = 0;
    let three = 0;
    let part2Array = [];
    let tempArray = [];

    list.push(0);
    list.sort(function (a, b) { return a - b });
    list.push(list[list.length - 1] + 3);

    for (let i = 1; i < list.length; i++) {
        tempArray.push(list[i - 1]);

        if (list[i] - list[i - 1] === 1) {
            one++;
        }
        else if (list[i] - list[i - 1] === 3) {
            three++;
            part2Array.push(tempArray);
            tempArray = [];
        }
    }
    console.log("Part 1: " + one * three);

    let res = 1;
    for (let i = 0; i < part2Array.length; i++) {
        res *= countAlternatives(part2Array[i]);
    }
    console.log("Part 2: " + res);
}


function countAlternatives(list) {
    if (list.length <= 1) { return 1; }
    let res = 0;
    for (let j = 1; j < 4; j++) {
        if ((list[j] - list[0]) <= 3) {
            res += countAlternatives(list.slice(j));
        }
        else { break; }
    }
    return res;
}

async function fetchInput() {
    var response = await fetch('input.txt');
    var text = await response.text();
    const list = text.split("\n").map(function (x) { return parseInt(x, 10); });

    calculate(list);
}

fetchInput();

from numpy import prod

input = set(map(int, open("input","r")))
limit = max(input) + 3
s = [0] + sorted(input) + [limit]
l = [s[i+1] - s[i] for i in range(len(input) - 1)]

def combinations(j, l):
    if j == l[-1]:
        yield 1
    else:
        for a in filter(lambda v: j+1 <= v <= j+3, l):
            yield from combinations(a, l)

def split_on_3s(l):
    start = 0
    for i in range(len(l) - 1):
        if l[i] + 3 == l[i+1]:
            yield l[start:i + 1]
            start = i + 1
    yield l[start:]
    

print(l.count(1) * l.count(3),
      prod([sum([x for x in combinations(l[0], l)])
            for l in filter(lambda x:len(x) > 2, split_on_3s(s))]))

from numpy import prod
from collections import Counter

input = set(map(int, open("input","r")))
s = [0] + sorted(input) + [max(input) + 3]
l = [s[i+1] - s[i] for i in range(len(s) - 1)]
print(l.count(1) * l.count(3),
      prod([prod([[1,1,2,4,7][k]] * v)
            for k,v in Counter(map(len,"".join(map(chr, l)).split(chr(3)))).items()]))