AdventOfCode2020

AdventOfCode2020.md

Advent of Code 2020

D1.ts

const findProduct = (input: number[], target) => {
	let product = 0;
	input.some((num) => {
		const otherNum = target - num;
		const otherNumIndex = input.indexOf(otherNum);
		if (otherNumIndex > -1) {
			product = num * otherNum;
			return true;
		}
		return false;
	});
	return product;
};

const findTripleSumProduct = (input: number[], target: number) => {
	let product = 0;
	input.sort().some((a, index) => {
		const slicedArr = input.slice(index + 1);
		product = a * findProduct(slicedArr, target - a);
		return product;
	});
	return product;
};

// https://codesandbox.io/s/ecstatic-sinoussi-tgmi1?file=/src/index.ts

D2.ts

const isValid = (str: string, char: string, min: number, max: number) => {
	const letterFrequency = (str.match(new RegExp(char, "gi")) || []).length;
	return letterFrequency >= min && letterFrequency <= max;
};

const isValidPartTwo = (
	str: string,
	char: string,
	first: number,
	second: number
) => {
	const res1 = str[first - 1] === char;
	const res2 = str[second - 1] === char;

	if (res1 && res2) return false;
	if (!res1 && !res2) return false;
	return true;
};

const getValidPaswords = (input: string[]) => {
	let validPasswords = 0;
	let validPasswordsPartTwo = 0;
	input.forEach((line) => {
		const [counts, letter, password] = line.split(" ");
		const [start, end] = counts.split("-");

		if (isValid(password, letter.slice(0, -1), Number(start), Number(end)))
			validPasswords += 1;
		if (
			isValidPartTwo(
				password,
				letter.slice(0, -1),
				Number(start),
				Number(end)
			)
		)
			validPasswordsPartTwo += 1;
	});

	return [validPasswords, validPasswordsPartTwo];
};

// https://codesandbox.io/s/agitated-mcnulty-vsohb?file=/src/index.ts

D3.ts

const moveSquares = (
	count: [number, number],
	matrix: string[],
	curr: [number, number],
	[x, y]: [number, number]
): [boolean, [number, number]] => {
	const newPos: [number, number] = [
		Math.floor(curr[0] + count[0]),
		curr[1] + count[1]
	];
	if (newPos[0] >= x) newPos[0] %= x;

	const isTree = matrix[newPos[1]][newPos[0]] === "#";
	return [isTree, newPos];
};

const countTrees = (input: string) => {
	const rows = input.split("\n");
	const width = rows[0].length,
		height = rows.length;

	let current: [number, number] = [0, 0];

	let treeCount = 0;
	while (current[1] < height - 2) {
		const [isTree, newPos] = moveSquares([3, 1], rows, current, [
			width,
			height
		]);

		if (isTree) {
			treeCount += 1;
		}
		current = newPos;
	}
	return treeCount;
};
                            
// https://codesandbox.io/s/brave-faraday-7wm9z?file=/src/index.ts

D4.ts

const REQUIRED_FIELDS = [
	"byr",
	"iyr",
	"eyr",
	"hgt",
	"hcl",
	"ecl",
	"pid"
	// "cid"
];

const replaceAtIndex = (s: string, x: string, index: number) => {
	return s.substring(0, index) + x + s.substring(index + 1);
};

const checkIfValidValue = (index: number, value: string) => {
	if (index === 0) {
		return (
			value.match(/^\d{4}$/) &&
			Number(value) >= 1920 &&
			Number(value) <= 2002
		);
	}
	if (index === 1) {
		return (
			value.match(/^\d{4}$/) &&
			Number(value) >= 2010 &&
			Number(value) <= 2020
		);
	}
	if (index === 2) {
		return (
			value.match(/^\d{4}$/) &&
			Number(value) >= 2020 &&
			Number(value) <= 2030
		);
	}
	if (index === 3) {
		if (value.slice(-2) === "cm")
			return (
				Number(value.slice(0, -2)) >= 150 &&
				Number(value.slice(0, -2)) <= 193
			);
		if (value.slice(-2) === "in")
			return (
				Number(value.slice(0, -2)) >= 59 &&
				Number(value.slice(0, -2)) <= 76
			);
		return false;
	}
	if (index === 4) {
		return value[0] === "#" && value.slice(1).match(/^[a-f0-9]{6}$/);
	}
	if (index === 5) {
		return ["amb", "blu", "brn", "gry", "grn", "hzl", "oth"].includes(
			value
		);
	}
	if (index === 6) {
		return value.match(/^\d{9}$/);
	}
};

const checkIsValid = (input: string) => {
	const fields: string[] = input.replaceAll("\n", " ").split(" ");
	if (fields.length < REQUIRED_FIELDS.length) return false;

	let fieldPresentMap = "00000000";

	fields.forEach((fieldEntry) => {
		const key = fieldEntry.split(":")[0];
		const index = REQUIRED_FIELDS.indexOf(key);

		if (index > -1 && !checkIfValidValue(index, fieldEntry.split(":")[1]))
			return false;

		if (index > -1) {
			const toReplace = (Number(fieldPresentMap[index]) + 1).toString();
			fieldPresentMap = replaceAtIndex(fieldPresentMap, toReplace, index);
		} else return false;
	});

	if (fieldPresentMap.slice(0, -1).indexOf("0") > -1) return false;

	return true;
};

const getValidPasspors = (input: string) => {
	let count = 0;
	const entries = input.split("\n\n");
	console.log(entries.length);

	entries.forEach((entry) => {
		if (checkIsValid(entry)) {
			count += 1;
		}
	});

	return count;
};
        
// https://codesandbox.io/s/dazzling-galois-vjiw0?file=/src/index.ts

D5.ts

const calculateSeat = (input: string) => {
	const row = parseInt(
		input.slice(0, 7).replaceAll("F", "0").replaceAll("B", "1"),
		2
	);
	const col = parseInt(
		input.slice(7).replaceAll("L", "0").replaceAll("R", "1"),
		2
	);
	return [row, col];
};

const getSeatID = (input: string[]) => {
	let highestSeatID = 0,
		seatIDs: number[] = [],
		lastID = 0;
	input.forEach((line) => {
		const [row, col] = calculateSeat(line);

		const seatID = row * 8 + col;
		seatIDs.push(seatID);

		if (seatID > highestSeatID) highestSeatID = seatID;
	});

	seatIDs
		.sort((a, b) => a - b)
		.forEach((seat) => {
			if (seat === lastID + 2) {
				console.log(`Part two: ${seat - 1}`);
			}
			lastID = seat;
		});
	return `Part one: ${highestSeatID}`;
};

// https://codesandbox.io/s/compassionate-dream-q6s5i?file=/src/index.ts

D6.ts

const second = (input: string[]) => {
	let set = new Set(input[0]);
	input.forEach((_person, i) => {
		if (i < input.length - 1)
			set = new Set([...set].filter((a) => new Set(input[i + 1]).has(a)));
	});
	return set.size;
};

const getCount = (input: string) => {
	const normalized = input.replaceAll("\n", "").replace(/(.)(?=.*\1)/g, "");
	return [...normalized].length;
};

const calculate = (input: string) => {
	let total = 0,
		total2 = 0;
	const groups = input.split("\n\n");
	groups.forEach((group) => {
		const count = getCount(group);
		total += count;
		const count2 = second(
			group.split("\n").filter((person) => person.length <= 26)
		);
		total2 += count2;
	});

	return [total, total2];
};
                                                              
// https://codesandbox.io/s/magical-hermann-3hnmv?file=/src/index.ts

D7.ts

const OURS = "shiny gold";

const createMap = (input: string[]) => {
	const map: Object = input.reduce((map, rule) => {
		const [outer, inner] = rule
			.replaceAll(".", "")
			.replaceAll("bags", "")
			.replaceAll("bag", "")
			.trim()
			.split("contain");
		const innerBags: string[] = inner
			.split(",")
			.map((entry) => entry.trim());

		// console.log(innerBags);

		return { ...map, [outer.trim()]: innerBags };
	}, {});
	return map;
};

const findBags = (input: string, allBags: Object, alreadyDone = []) => {
	let count = 0;
	Object.keys(allBags).forEach((outer) => {
		// console.log(outer, allBags[outer]);

		if (allBags[outer].indexOf(input) > -1) {
			if (alreadyDone && alreadyDone.includes(outer)) return 0;
			count += 1;
			alreadyDone.push(outer);
			// other bags
			const otherCount = findBags(outer, allBags, alreadyDone);
			count += otherCount;
		}
	});
	// console.log(count);
	return count;
};

const countInnerBags = (bags: Object, bag: string) => {
	if (!bags[bag]) {
		return 0;
	}
	let innerBags = 0;
	for (const innerBag of bags[bag]) {
		innerBags +=
			innerBag[0] + innerBag[0] * countInnerBags(bags, innerBag[1]);
	}
	return innerBags;
};

const get = (input: string) => {
	const rules = input.split("\n");
	const map = createMap(rules);

	const res1 = findBags(OURS, map);

	let bags = {};

	for (const line of rules) {
		let innerBagTypes = line.replace(/.*?bags/, "").split(",");

		innerBagTypes = innerBagTypes.map((x) => [
			Number(x.replace(/[^\d]+/g, "")),
			x
				.replace(/(bags|bag)/, "")
				.replace(/.*\d /, "")
				.replace(/[^a-zA-Z ]/g, "")
				.trim()
		]);
		bags[line.replace(/bags.*/, "").trim()] = innerBagTypes;
	}

	return countInnerBags(bags, OURS);
};

// https://codesandbox.io/s/jovial-firefly-h5cnj?file=/src/index.ts

D8-1.ts

const checkMap = (map: string) => {
	return map.split("").every((int) => int === "0" || int === "1");
};

const updateMap = (str: string, index: number) => {
	return str.substr(0, index) + `${+str[index] + 1}` + str.substr(index + 1);
};

const getMap = (length: number) => {
	return Array.from(Array(length), () => "0").join("");
};

const makeMove = (move: string, counter: number): [number, number] => {
	const [type, count_] = move.split(" ");
	const sign = count_[0] === "-" ? -1 : 1;
	const count = +count_.slice(1) * sign;

	// console.log(type, count);
	if (type === "nop") return [counter, 1];
	if (type === "acc") return [counter + count, 1];
	if (type === "jmp") return [counter, count];

	return [counter, count];
};

const get = (input: string) => {
	const instructions = input.split("\n");
	let map = getMap(instructions.length);

	let counter = 0,
		i = 0,
		last = 0;

	while (checkMap(map)) {
		last = counter;
		const move = instructions[i];
		const [counter_, index] = makeMove(move, counter);

		counter = counter_;
		map = updateMap(map, i);
		i += index;
	}

	return last;
};

// https://codesandbox.io/s/friendly-antonelli-d7y2o?file=/src/index.ts

D8-2.ts

const get = (input) => {
	const instructions = input.split("\n").map((line) => {
		const [, operation, value] = /(\w+) ([+-]\d+)/.exec(line.trim());

		return [operation, parseInt(value)];
	});

	for (let i = 0; i < instructions.length; i++) {
		const patched = instructions.map(([operation, value]) => [
			operation,
			value
		]);

		if (instructions[i][0] === "jmp") {
			patched[i][0] = "nop";
		} else if (instructions[i][0] === "nop") {
			patched[i][0] = "jmp";
		} else {
			continue;
		}

		const executed = new Set();

		let acc = 0;
		let p = 0;

		while (!executed.has(p)) {
			executed.add(p);

			const [operation, argument] = patched[p];

			switch (operation) {
				case "acc":
					acc += argument;
					p++;

					break;
				case "jmp":
					p += argument;

					break;
				case "nop":
					p++;

					break;
			}

			if (p >= patched.length) {
				return acc;
			}
		}
	}
};
    
// https://codesandbox.io/s/wild-microservice-sqrq5?file=/src/index.ts

D9.ts

const PREV = 5;

const findContiguousSumRange = (num: number, data: number[]) => {
	let l = -1;
	for (let m = 0; m < data.length; m++) {
		l++;
		for (let i = 3; i < data.length - 3; i++) {
			let j = data.slice(m, l + i);
			let el = j.reduce((a, b) => a + b);
			if (el === num) {
				console.log(Math.min(...j), Math.max(...j));
				i = data.length;
			} else if (el > num) {
				i = data.length;
			}
		}
	}
};

const checkIfSumOf = (num: number, input: number[]) => {
	const res = input.some((str) => {
		if (input.indexOf(num - str) > -1) return true;
		return false;
	});
	return res;
};

const get = (input: string) => {
	const lines = input.split("\n").map(Number);
	lines.slice(PREV).forEach((num, index) => {
		const check = checkIfSumOf(num, lines.slice(index, index + PREV));

		if (!check) {
			console.log(num);
			findContiguousSumRange(num, lines.slice(0, index));
		}
	});
};

// https://codesandbox.io/s/relaxed-shaw-ot4wo?file=/src/index.ts