From edcc3caf916a476b53d5a1a8a676619ba26f954d Mon Sep 17 00:00:00 2001
From: Bram <bram@noordstar.me>
Date: Thu, 28 Dec 2023 12:05:45 +0100
Subject: [PATCH] Add Elm day 2

---
 elm/elm.json             |    1 +
 elm/index.html           | 1036 ++++++++++++++++++++++++++++++++++++--
 elm/src/Main.elm         |  115 +++--
 elm/src/Puzzles/Day1.elm |   21 +-
 elm/src/Puzzles/Day2.elm |  150 ++++++
 elm/src/Puzzles/DayX.elm |   11 +
 elm/src/Tools/Colors.elm |    1 +
 7 files changed, 1227 insertions(+), 108 deletions(-)
 create mode 100644 elm/src/Puzzles/Day2.elm
 create mode 100644 elm/src/Puzzles/DayX.elm

diff --git a/elm/elm.json b/elm/elm.json
index 17064ad..80043c2 100644
--- a/elm/elm.json
+++ b/elm/elm.json
@@ -11,6 +11,7 @@
             "elm/browser": "1.0.2",
             "elm/core": "1.0.5",
             "elm/html": "1.0.0",
+            "elm/parser": "1.1.0",
             "elm/svg": "1.0.1",
             "mdgriffith/elm-ui": "1.1.8",
             "miniBill/elm-fast-dict": "1.1.0"
diff --git a/elm/index.html b/elm/index.html
index 06ab891..7b20911 100644
--- a/elm/index.html
+++ b/elm/index.html
@@ -4387,6 +4387,136 @@ function _Browser_load(url)
 
 
 
+
+// STRINGS
+
+
+var _Parser_isSubString = F5(function(smallString, offset, row, col, bigString)
+{
+	var smallLength = smallString.length;
+	var isGood = offset + smallLength <= bigString.length;
+
+	for (var i = 0; isGood && i < smallLength; )
+	{
+		var code = bigString.charCodeAt(offset);
+		isGood =
+			smallString[i++] === bigString[offset++]
+			&& (
+				code === 0x000A /* \n */
+					? ( row++, col=1 )
+					: ( col++, (code & 0xF800) === 0xD800 ? smallString[i++] === bigString[offset++] : 1 )
+			)
+	}
+
+	return _Utils_Tuple3(isGood ? offset : -1, row, col);
+});
+
+
+
+// CHARS
+
+
+var _Parser_isSubChar = F3(function(predicate, offset, string)
+{
+	return (
+		string.length <= offset
+			? -1
+			:
+		(string.charCodeAt(offset) & 0xF800) === 0xD800
+			? (predicate(_Utils_chr(string.substr(offset, 2))) ? offset + 2 : -1)
+			:
+		(predicate(_Utils_chr(string[offset]))
+			? ((string[offset] === '\n') ? -2 : (offset + 1))
+			: -1
+		)
+	);
+});
+
+
+var _Parser_isAsciiCode = F3(function(code, offset, string)
+{
+	return string.charCodeAt(offset) === code;
+});
+
+
+
+// NUMBERS
+
+
+var _Parser_chompBase10 = F2(function(offset, string)
+{
+	for (; offset < string.length; offset++)
+	{
+		var code = string.charCodeAt(offset);
+		if (code < 0x30 || 0x39 < code)
+		{
+			return offset;
+		}
+	}
+	return offset;
+});
+
+
+var _Parser_consumeBase = F3(function(base, offset, string)
+{
+	for (var total = 0; offset < string.length; offset++)
+	{
+		var digit = string.charCodeAt(offset) - 0x30;
+		if (digit < 0 || base <= digit) break;
+		total = base * total + digit;
+	}
+	return _Utils_Tuple2(offset, total);
+});
+
+
+var _Parser_consumeBase16 = F2(function(offset, string)
+{
+	for (var total = 0; offset < string.length; offset++)
+	{
+		var code = string.charCodeAt(offset);
+		if (0x30 <= code && code <= 0x39)
+		{
+			total = 16 * total + code - 0x30;
+		}
+		else if (0x41 <= code && code <= 0x46)
+		{
+			total = 16 * total + code - 55;
+		}
+		else if (0x61 <= code && code <= 0x66)
+		{
+			total = 16 * total + code - 87;
+		}
+		else
+		{
+			break;
+		}
+	}
+	return _Utils_Tuple2(offset, total);
+});
+
+
+
+// FIND STRING
+
+
+var _Parser_findSubString = F5(function(smallString, offset, row, col, bigString)
+{
+	var newOffset = bigString.indexOf(smallString, offset);
+	var target = newOffset < 0 ? bigString.length : newOffset + smallString.length;
+
+	while (offset < target)
+	{
+		var code = bigString.charCodeAt(offset++);
+		code === 0x000A /* \n */
+			? ( col=1, row++ )
+			: ( col++, (code & 0xF800) === 0xD800 && offset++ )
+	}
+
+	return _Utils_Tuple3(newOffset, row, col);
+});
+
+
+
 var _Bitwise_and = F2(function(a, b)
 {
 	return a & b;
@@ -5357,6 +5487,796 @@ var $author$project$Puzzles$Day1$puzzle1 = function (input) {
 					$author$project$Puzzles$Day1$puzzle1Nums,
 					A2($elm$core$String$split, '\n', input)))));
 };
+var $elm$core$List$any = F2(
+	function (isOkay, list) {
+		any:
+		while (true) {
+			if (!list.b) {
+				return false;
+			} else {
+				var x = list.a;
+				var xs = list.b;
+				if (isOkay(x)) {
+					return true;
+				} else {
+					var $temp$isOkay = isOkay,
+						$temp$list = xs;
+					isOkay = $temp$isOkay;
+					list = $temp$list;
+					continue any;
+				}
+			}
+		}
+	});
+var $elm$core$Basics$composeL = F3(
+	function (g, f, x) {
+		return g(
+			f(x));
+	});
+var $elm$core$Basics$not = _Basics_not;
+var $elm$core$List$all = F2(
+	function (isOkay, list) {
+		return !A2(
+			$elm$core$List$any,
+			A2($elm$core$Basics$composeL, $elm$core$Basics$not, isOkay),
+			list);
+	});
+var $elm$core$Debug$log = _Debug_log;
+var $author$project$Puzzles$Day2$maxAllowed = {blue: 14, green: 13, red: 12};
+var $elm$parser$Parser$Done = function (a) {
+	return {$: 'Done', a: a};
+};
+var $elm$parser$Parser$Loop = function (a) {
+	return {$: 'Loop', a: a};
+};
+var $elm$parser$Parser$Advanced$Bad = F2(
+	function (a, b) {
+		return {$: 'Bad', a: a, b: b};
+	});
+var $elm$parser$Parser$Advanced$Good = F3(
+	function (a, b, c) {
+		return {$: 'Good', a: a, b: b, c: c};
+	});
+var $elm$parser$Parser$Advanced$Parser = function (a) {
+	return {$: 'Parser', a: a};
+};
+var $elm$parser$Parser$Advanced$map2 = F3(
+	function (func, _v0, _v1) {
+		var parseA = _v0.a;
+		var parseB = _v1.a;
+		return $elm$parser$Parser$Advanced$Parser(
+			function (s0) {
+				var _v2 = parseA(s0);
+				if (_v2.$ === 'Bad') {
+					var p = _v2.a;
+					var x = _v2.b;
+					return A2($elm$parser$Parser$Advanced$Bad, p, x);
+				} else {
+					var p1 = _v2.a;
+					var a = _v2.b;
+					var s1 = _v2.c;
+					var _v3 = parseB(s1);
+					if (_v3.$ === 'Bad') {
+						var p2 = _v3.a;
+						var x = _v3.b;
+						return A2($elm$parser$Parser$Advanced$Bad, p1 || p2, x);
+					} else {
+						var p2 = _v3.a;
+						var b = _v3.b;
+						var s2 = _v3.c;
+						return A3(
+							$elm$parser$Parser$Advanced$Good,
+							p1 || p2,
+							A2(func, a, b),
+							s2);
+					}
+				}
+			});
+	});
+var $elm$parser$Parser$Advanced$ignorer = F2(
+	function (keepParser, ignoreParser) {
+		return A3($elm$parser$Parser$Advanced$map2, $elm$core$Basics$always, keepParser, ignoreParser);
+	});
+var $elm$parser$Parser$ignorer = $elm$parser$Parser$Advanced$ignorer;
+var $elm$parser$Parser$Advanced$keeper = F2(
+	function (parseFunc, parseArg) {
+		return A3($elm$parser$Parser$Advanced$map2, $elm$core$Basics$apL, parseFunc, parseArg);
+	});
+var $elm$parser$Parser$keeper = $elm$parser$Parser$Advanced$keeper;
+var $elm$parser$Parser$Advanced$loopHelp = F4(
+	function (p, state, callback, s0) {
+		loopHelp:
+		while (true) {
+			var _v0 = callback(state);
+			var parse = _v0.a;
+			var _v1 = parse(s0);
+			if (_v1.$ === 'Good') {
+				var p1 = _v1.a;
+				var step = _v1.b;
+				var s1 = _v1.c;
+				if (step.$ === 'Loop') {
+					var newState = step.a;
+					var $temp$p = p || p1,
+						$temp$state = newState,
+						$temp$callback = callback,
+						$temp$s0 = s1;
+					p = $temp$p;
+					state = $temp$state;
+					callback = $temp$callback;
+					s0 = $temp$s0;
+					continue loopHelp;
+				} else {
+					var result = step.a;
+					return A3($elm$parser$Parser$Advanced$Good, p || p1, result, s1);
+				}
+			} else {
+				var p1 = _v1.a;
+				var x = _v1.b;
+				return A2($elm$parser$Parser$Advanced$Bad, p || p1, x);
+			}
+		}
+	});
+var $elm$parser$Parser$Advanced$loop = F2(
+	function (state, callback) {
+		return $elm$parser$Parser$Advanced$Parser(
+			function (s) {
+				return A4($elm$parser$Parser$Advanced$loopHelp, false, state, callback, s);
+			});
+	});
+var $elm$parser$Parser$Advanced$map = F2(
+	function (func, _v0) {
+		var parse = _v0.a;
+		return $elm$parser$Parser$Advanced$Parser(
+			function (s0) {
+				var _v1 = parse(s0);
+				if (_v1.$ === 'Good') {
+					var p = _v1.a;
+					var a = _v1.b;
+					var s1 = _v1.c;
+					return A3(
+						$elm$parser$Parser$Advanced$Good,
+						p,
+						func(a),
+						s1);
+				} else {
+					var p = _v1.a;
+					var x = _v1.b;
+					return A2($elm$parser$Parser$Advanced$Bad, p, x);
+				}
+			});
+	});
+var $elm$parser$Parser$map = $elm$parser$Parser$Advanced$map;
+var $elm$parser$Parser$Advanced$Done = function (a) {
+	return {$: 'Done', a: a};
+};
+var $elm$parser$Parser$Advanced$Loop = function (a) {
+	return {$: 'Loop', a: a};
+};
+var $elm$parser$Parser$toAdvancedStep = function (step) {
+	if (step.$ === 'Loop') {
+		var s = step.a;
+		return $elm$parser$Parser$Advanced$Loop(s);
+	} else {
+		var a = step.a;
+		return $elm$parser$Parser$Advanced$Done(a);
+	}
+};
+var $elm$parser$Parser$loop = F2(
+	function (state, callback) {
+		return A2(
+			$elm$parser$Parser$Advanced$loop,
+			state,
+			function (s) {
+				return A2(
+					$elm$parser$Parser$map,
+					$elm$parser$Parser$toAdvancedStep,
+					callback(s));
+			});
+	});
+var $elm$parser$Parser$Advanced$Empty = {$: 'Empty'};
+var $elm$parser$Parser$Advanced$Append = F2(
+	function (a, b) {
+		return {$: 'Append', a: a, b: b};
+	});
+var $elm$parser$Parser$Advanced$oneOfHelp = F3(
+	function (s0, bag, parsers) {
+		oneOfHelp:
+		while (true) {
+			if (!parsers.b) {
+				return A2($elm$parser$Parser$Advanced$Bad, false, bag);
+			} else {
+				var parse = parsers.a.a;
+				var remainingParsers = parsers.b;
+				var _v1 = parse(s0);
+				if (_v1.$ === 'Good') {
+					var step = _v1;
+					return step;
+				} else {
+					var step = _v1;
+					var p = step.a;
+					var x = step.b;
+					if (p) {
+						return step;
+					} else {
+						var $temp$s0 = s0,
+							$temp$bag = A2($elm$parser$Parser$Advanced$Append, bag, x),
+							$temp$parsers = remainingParsers;
+						s0 = $temp$s0;
+						bag = $temp$bag;
+						parsers = $temp$parsers;
+						continue oneOfHelp;
+					}
+				}
+			}
+		}
+	});
+var $elm$parser$Parser$Advanced$oneOf = function (parsers) {
+	return $elm$parser$Parser$Advanced$Parser(
+		function (s) {
+			return A3($elm$parser$Parser$Advanced$oneOfHelp, s, $elm$parser$Parser$Advanced$Empty, parsers);
+		});
+};
+var $elm$parser$Parser$oneOf = $elm$parser$Parser$Advanced$oneOf;
+var $elm$parser$Parser$Advanced$isSubChar = _Parser_isSubChar;
+var $elm$core$Basics$negate = function (n) {
+	return -n;
+};
+var $elm$parser$Parser$Advanced$chompWhileHelp = F5(
+	function (isGood, offset, row, col, s0) {
+		chompWhileHelp:
+		while (true) {
+			var newOffset = A3($elm$parser$Parser$Advanced$isSubChar, isGood, offset, s0.src);
+			if (_Utils_eq(newOffset, -1)) {
+				return A3(
+					$elm$parser$Parser$Advanced$Good,
+					_Utils_cmp(s0.offset, offset) < 0,
+					_Utils_Tuple0,
+					{col: col, context: s0.context, indent: s0.indent, offset: offset, row: row, src: s0.src});
+			} else {
+				if (_Utils_eq(newOffset, -2)) {
+					var $temp$isGood = isGood,
+						$temp$offset = offset + 1,
+						$temp$row = row + 1,
+						$temp$col = 1,
+						$temp$s0 = s0;
+					isGood = $temp$isGood;
+					offset = $temp$offset;
+					row = $temp$row;
+					col = $temp$col;
+					s0 = $temp$s0;
+					continue chompWhileHelp;
+				} else {
+					var $temp$isGood = isGood,
+						$temp$offset = newOffset,
+						$temp$row = row,
+						$temp$col = col + 1,
+						$temp$s0 = s0;
+					isGood = $temp$isGood;
+					offset = $temp$offset;
+					row = $temp$row;
+					col = $temp$col;
+					s0 = $temp$s0;
+					continue chompWhileHelp;
+				}
+			}
+		}
+	});
+var $elm$parser$Parser$Advanced$chompWhile = function (isGood) {
+	return $elm$parser$Parser$Advanced$Parser(
+		function (s) {
+			return A5($elm$parser$Parser$Advanced$chompWhileHelp, isGood, s.offset, s.row, s.col, s);
+		});
+};
+var $elm$parser$Parser$chompWhile = $elm$parser$Parser$Advanced$chompWhile;
+var $author$project$Puzzles$Day2$onlySpaces = $elm$parser$Parser$chompWhile(
+	function (c) {
+		return _Utils_eq(
+			c,
+			_Utils_chr(' '));
+	});
+var $elm$parser$Parser$Advanced$succeed = function (a) {
+	return $elm$parser$Parser$Advanced$Parser(
+		function (s) {
+			return A3($elm$parser$Parser$Advanced$Good, false, a, s);
+		});
+};
+var $elm$parser$Parser$succeed = $elm$parser$Parser$Advanced$succeed;
+var $elm$parser$Parser$Expecting = function (a) {
+	return {$: 'Expecting', a: a};
+};
+var $elm$parser$Parser$Advanced$Token = F2(
+	function (a, b) {
+		return {$: 'Token', a: a, b: b};
+	});
+var $elm$parser$Parser$toToken = function (str) {
+	return A2(
+		$elm$parser$Parser$Advanced$Token,
+		str,
+		$elm$parser$Parser$Expecting(str));
+};
+var $elm$parser$Parser$Advanced$AddRight = F2(
+	function (a, b) {
+		return {$: 'AddRight', a: a, b: b};
+	});
+var $elm$parser$Parser$Advanced$DeadEnd = F4(
+	function (row, col, problem, contextStack) {
+		return {col: col, contextStack: contextStack, problem: problem, row: row};
+	});
+var $elm$parser$Parser$Advanced$fromState = F2(
+	function (s, x) {
+		return A2(
+			$elm$parser$Parser$Advanced$AddRight,
+			$elm$parser$Parser$Advanced$Empty,
+			A4($elm$parser$Parser$Advanced$DeadEnd, s.row, s.col, x, s.context));
+	});
+var $elm$parser$Parser$Advanced$isSubString = _Parser_isSubString;
+var $elm$parser$Parser$Advanced$token = function (_v0) {
+	var str = _v0.a;
+	var expecting = _v0.b;
+	var progress = !$elm$core$String$isEmpty(str);
+	return $elm$parser$Parser$Advanced$Parser(
+		function (s) {
+			var _v1 = A5($elm$parser$Parser$Advanced$isSubString, str, s.offset, s.row, s.col, s.src);
+			var newOffset = _v1.a;
+			var newRow = _v1.b;
+			var newCol = _v1.c;
+			return _Utils_eq(newOffset, -1) ? A2(
+				$elm$parser$Parser$Advanced$Bad,
+				false,
+				A2($elm$parser$Parser$Advanced$fromState, s, expecting)) : A3(
+				$elm$parser$Parser$Advanced$Good,
+				progress,
+				_Utils_Tuple0,
+				{col: newCol, context: s.context, indent: s.indent, offset: newOffset, row: newRow, src: s.src});
+		});
+};
+var $elm$parser$Parser$token = function (str) {
+	return $elm$parser$Parser$Advanced$token(
+		$elm$parser$Parser$toToken(str));
+};
+var $author$project$Puzzles$Day2$andOneMore = function (_v0) {
+	var separator = _v0.separator;
+	var item = _v0.item;
+	return A2(
+		$elm$parser$Parser$loop,
+		_List_Nil,
+		function (xs) {
+			return A2(
+				$elm$parser$Parser$keeper,
+				A2(
+					$elm$parser$Parser$keeper,
+					$elm$parser$Parser$succeed(
+						F2(
+							function (x, state) {
+								return state(
+									A2($elm$core$List$cons, x, xs));
+							})),
+					A2($elm$parser$Parser$ignorer, item, $author$project$Puzzles$Day2$onlySpaces)),
+				A2(
+					$elm$parser$Parser$ignorer,
+					$elm$parser$Parser$oneOf(
+						_List_fromArray(
+							[
+								A2(
+								$elm$parser$Parser$ignorer,
+								$elm$parser$Parser$succeed($elm$parser$Parser$Loop),
+								$elm$parser$Parser$token(separator)),
+								$elm$parser$Parser$succeed($elm$parser$Parser$Done)
+							])),
+					$author$project$Puzzles$Day2$onlySpaces));
+		});
+};
+var $author$project$Puzzles$Day2$Game = F2(
+	function (number, games) {
+		return {games: games, number: number};
+	});
+var $elm$parser$Parser$ExpectingInt = {$: 'ExpectingInt'};
+var $elm$parser$Parser$Advanced$consumeBase = _Parser_consumeBase;
+var $elm$parser$Parser$Advanced$consumeBase16 = _Parser_consumeBase16;
+var $elm$parser$Parser$Advanced$bumpOffset = F2(
+	function (newOffset, s) {
+		return {col: s.col + (newOffset - s.offset), context: s.context, indent: s.indent, offset: newOffset, row: s.row, src: s.src};
+	});
+var $elm$parser$Parser$Advanced$chompBase10 = _Parser_chompBase10;
+var $elm$parser$Parser$Advanced$isAsciiCode = _Parser_isAsciiCode;
+var $elm$parser$Parser$Advanced$consumeExp = F2(
+	function (offset, src) {
+		if (A3($elm$parser$Parser$Advanced$isAsciiCode, 101, offset, src) || A3($elm$parser$Parser$Advanced$isAsciiCode, 69, offset, src)) {
+			var eOffset = offset + 1;
+			var expOffset = (A3($elm$parser$Parser$Advanced$isAsciiCode, 43, eOffset, src) || A3($elm$parser$Parser$Advanced$isAsciiCode, 45, eOffset, src)) ? (eOffset + 1) : eOffset;
+			var newOffset = A2($elm$parser$Parser$Advanced$chompBase10, expOffset, src);
+			return _Utils_eq(expOffset, newOffset) ? (-newOffset) : newOffset;
+		} else {
+			return offset;
+		}
+	});
+var $elm$parser$Parser$Advanced$consumeDotAndExp = F2(
+	function (offset, src) {
+		return A3($elm$parser$Parser$Advanced$isAsciiCode, 46, offset, src) ? A2(
+			$elm$parser$Parser$Advanced$consumeExp,
+			A2($elm$parser$Parser$Advanced$chompBase10, offset + 1, src),
+			src) : A2($elm$parser$Parser$Advanced$consumeExp, offset, src);
+	});
+var $elm$parser$Parser$Advanced$finalizeInt = F5(
+	function (invalid, handler, startOffset, _v0, s) {
+		var endOffset = _v0.a;
+		var n = _v0.b;
+		if (handler.$ === 'Err') {
+			var x = handler.a;
+			return A2(
+				$elm$parser$Parser$Advanced$Bad,
+				true,
+				A2($elm$parser$Parser$Advanced$fromState, s, x));
+		} else {
+			var toValue = handler.a;
+			return _Utils_eq(startOffset, endOffset) ? A2(
+				$elm$parser$Parser$Advanced$Bad,
+				_Utils_cmp(s.offset, startOffset) < 0,
+				A2($elm$parser$Parser$Advanced$fromState, s, invalid)) : A3(
+				$elm$parser$Parser$Advanced$Good,
+				true,
+				toValue(n),
+				A2($elm$parser$Parser$Advanced$bumpOffset, endOffset, s));
+		}
+	});
+var $elm$parser$Parser$Advanced$fromInfo = F4(
+	function (row, col, x, context) {
+		return A2(
+			$elm$parser$Parser$Advanced$AddRight,
+			$elm$parser$Parser$Advanced$Empty,
+			A4($elm$parser$Parser$Advanced$DeadEnd, row, col, x, context));
+	});
+var $elm$core$String$toFloat = _String_toFloat;
+var $elm$parser$Parser$Advanced$finalizeFloat = F6(
+	function (invalid, expecting, intSettings, floatSettings, intPair, s) {
+		var intOffset = intPair.a;
+		var floatOffset = A2($elm$parser$Parser$Advanced$consumeDotAndExp, intOffset, s.src);
+		if (floatOffset < 0) {
+			return A2(
+				$elm$parser$Parser$Advanced$Bad,
+				true,
+				A4($elm$parser$Parser$Advanced$fromInfo, s.row, s.col - (floatOffset + s.offset), invalid, s.context));
+		} else {
+			if (_Utils_eq(s.offset, floatOffset)) {
+				return A2(
+					$elm$parser$Parser$Advanced$Bad,
+					false,
+					A2($elm$parser$Parser$Advanced$fromState, s, expecting));
+			} else {
+				if (_Utils_eq(intOffset, floatOffset)) {
+					return A5($elm$parser$Parser$Advanced$finalizeInt, invalid, intSettings, s.offset, intPair, s);
+				} else {
+					if (floatSettings.$ === 'Err') {
+						var x = floatSettings.a;
+						return A2(
+							$elm$parser$Parser$Advanced$Bad,
+							true,
+							A2($elm$parser$Parser$Advanced$fromState, s, invalid));
+					} else {
+						var toValue = floatSettings.a;
+						var _v1 = $elm$core$String$toFloat(
+							A3($elm$core$String$slice, s.offset, floatOffset, s.src));
+						if (_v1.$ === 'Nothing') {
+							return A2(
+								$elm$parser$Parser$Advanced$Bad,
+								true,
+								A2($elm$parser$Parser$Advanced$fromState, s, invalid));
+						} else {
+							var n = _v1.a;
+							return A3(
+								$elm$parser$Parser$Advanced$Good,
+								true,
+								toValue(n),
+								A2($elm$parser$Parser$Advanced$bumpOffset, floatOffset, s));
+						}
+					}
+				}
+			}
+		}
+	});
+var $elm$parser$Parser$Advanced$number = function (c) {
+	return $elm$parser$Parser$Advanced$Parser(
+		function (s) {
+			if (A3($elm$parser$Parser$Advanced$isAsciiCode, 48, s.offset, s.src)) {
+				var zeroOffset = s.offset + 1;
+				var baseOffset = zeroOffset + 1;
+				return A3($elm$parser$Parser$Advanced$isAsciiCode, 120, zeroOffset, s.src) ? A5(
+					$elm$parser$Parser$Advanced$finalizeInt,
+					c.invalid,
+					c.hex,
+					baseOffset,
+					A2($elm$parser$Parser$Advanced$consumeBase16, baseOffset, s.src),
+					s) : (A3($elm$parser$Parser$Advanced$isAsciiCode, 111, zeroOffset, s.src) ? A5(
+					$elm$parser$Parser$Advanced$finalizeInt,
+					c.invalid,
+					c.octal,
+					baseOffset,
+					A3($elm$parser$Parser$Advanced$consumeBase, 8, baseOffset, s.src),
+					s) : (A3($elm$parser$Parser$Advanced$isAsciiCode, 98, zeroOffset, s.src) ? A5(
+					$elm$parser$Parser$Advanced$finalizeInt,
+					c.invalid,
+					c.binary,
+					baseOffset,
+					A3($elm$parser$Parser$Advanced$consumeBase, 2, baseOffset, s.src),
+					s) : A6(
+					$elm$parser$Parser$Advanced$finalizeFloat,
+					c.invalid,
+					c.expecting,
+					c._int,
+					c._float,
+					_Utils_Tuple2(zeroOffset, 0),
+					s)));
+			} else {
+				return A6(
+					$elm$parser$Parser$Advanced$finalizeFloat,
+					c.invalid,
+					c.expecting,
+					c._int,
+					c._float,
+					A3($elm$parser$Parser$Advanced$consumeBase, 10, s.offset, s.src),
+					s);
+			}
+		});
+};
+var $elm$parser$Parser$Advanced$int = F2(
+	function (expecting, invalid) {
+		return $elm$parser$Parser$Advanced$number(
+			{
+				binary: $elm$core$Result$Err(invalid),
+				expecting: expecting,
+				_float: $elm$core$Result$Err(invalid),
+				hex: $elm$core$Result$Err(invalid),
+				_int: $elm$core$Result$Ok($elm$core$Basics$identity),
+				invalid: invalid,
+				octal: $elm$core$Result$Err(invalid)
+			});
+	});
+var $elm$parser$Parser$int = A2($elm$parser$Parser$Advanced$int, $elm$parser$Parser$ExpectingInt, $elm$parser$Parser$ExpectingInt);
+var $elm$parser$Parser$ExpectingKeyword = function (a) {
+	return {$: 'ExpectingKeyword', a: a};
+};
+var $elm$parser$Parser$Advanced$keyword = function (_v0) {
+	var kwd = _v0.a;
+	var expecting = _v0.b;
+	var progress = !$elm$core$String$isEmpty(kwd);
+	return $elm$parser$Parser$Advanced$Parser(
+		function (s) {
+			var _v1 = A5($elm$parser$Parser$Advanced$isSubString, kwd, s.offset, s.row, s.col, s.src);
+			var newOffset = _v1.a;
+			var newRow = _v1.b;
+			var newCol = _v1.c;
+			return (_Utils_eq(newOffset, -1) || (0 <= A3(
+				$elm$parser$Parser$Advanced$isSubChar,
+				function (c) {
+					return $elm$core$Char$isAlphaNum(c) || _Utils_eq(
+						c,
+						_Utils_chr('_'));
+				},
+				newOffset,
+				s.src))) ? A2(
+				$elm$parser$Parser$Advanced$Bad,
+				false,
+				A2($elm$parser$Parser$Advanced$fromState, s, expecting)) : A3(
+				$elm$parser$Parser$Advanced$Good,
+				progress,
+				_Utils_Tuple0,
+				{col: newCol, context: s.context, indent: s.indent, offset: newOffset, row: newRow, src: s.src});
+		});
+};
+var $elm$parser$Parser$keyword = function (kwd) {
+	return $elm$parser$Parser$Advanced$keyword(
+		A2(
+			$elm$parser$Parser$Advanced$Token,
+			kwd,
+			$elm$parser$Parser$ExpectingKeyword(kwd)));
+};
+var $author$project$Puzzles$Day2$RGB = F3(
+	function (red, green, blue) {
+		return {blue: blue, green: green, red: red};
+	});
+var $elm$parser$Parser$Advanced$spaces = $elm$parser$Parser$Advanced$chompWhile(
+	function (c) {
+		return _Utils_eq(
+			c,
+			_Utils_chr(' ')) || (_Utils_eq(
+			c,
+			_Utils_chr('\n')) || _Utils_eq(
+			c,
+			_Utils_chr('\r')));
+	});
+var $elm$parser$Parser$spaces = $elm$parser$Parser$Advanced$spaces;
+var $author$project$Puzzles$Day2$rgbStmt = A2(
+	$elm$parser$Parser$keeper,
+	A2(
+		$elm$parser$Parser$keeper,
+		$elm$parser$Parser$succeed($elm$core$Basics$apR),
+		A2($elm$parser$Parser$ignorer, $elm$parser$Parser$int, $elm$parser$Parser$spaces)),
+	$elm$parser$Parser$oneOf(
+		_List_fromArray(
+			[
+				A2(
+				$elm$parser$Parser$ignorer,
+				$elm$parser$Parser$succeed(
+					F2(
+						function (i, rgb) {
+							return _Utils_update(
+								rgb,
+								{red: i});
+						})),
+				$elm$parser$Parser$keyword('red')),
+				A2(
+				$elm$parser$Parser$ignorer,
+				$elm$parser$Parser$succeed(
+					F2(
+						function (i, rgb) {
+							return _Utils_update(
+								rgb,
+								{blue: i});
+						})),
+				$elm$parser$Parser$keyword('blue')),
+				A2(
+				$elm$parser$Parser$ignorer,
+				$elm$parser$Parser$succeed(
+					F2(
+						function (i, rgb) {
+							return _Utils_update(
+								rgb,
+								{green: i});
+						})),
+				$elm$parser$Parser$keyword('green'))
+			])));
+var $author$project$Puzzles$Day2$rgbParser = A2(
+	$elm$parser$Parser$keeper,
+	$elm$parser$Parser$succeed(
+		A2(
+			$elm$core$List$foldl,
+			$elm$core$Basics$apL,
+			A3($author$project$Puzzles$Day2$RGB, 0, 0, 0))),
+	$author$project$Puzzles$Day2$andOneMore(
+		{item: $author$project$Puzzles$Day2$rgbStmt, separator: ','}));
+var $author$project$Puzzles$Day2$rgbLines = $author$project$Puzzles$Day2$andOneMore(
+	{item: $author$project$Puzzles$Day2$rgbParser, separator: ';'});
+var $elm$parser$Parser$ExpectingSymbol = function (a) {
+	return {$: 'ExpectingSymbol', a: a};
+};
+var $elm$parser$Parser$Advanced$symbol = $elm$parser$Parser$Advanced$token;
+var $elm$parser$Parser$symbol = function (str) {
+	return $elm$parser$Parser$Advanced$symbol(
+		A2(
+			$elm$parser$Parser$Advanced$Token,
+			str,
+			$elm$parser$Parser$ExpectingSymbol(str)));
+};
+var $author$project$Puzzles$Day2$gameParser = A2(
+	$elm$parser$Parser$keeper,
+	A2(
+		$elm$parser$Parser$keeper,
+		A2(
+			$elm$parser$Parser$ignorer,
+			A2(
+				$elm$parser$Parser$ignorer,
+				$elm$parser$Parser$succeed($author$project$Puzzles$Day2$Game),
+				$elm$parser$Parser$keyword('Game')),
+			$elm$parser$Parser$spaces),
+		A2(
+			$elm$parser$Parser$ignorer,
+			A2(
+				$elm$parser$Parser$ignorer,
+				$elm$parser$Parser$int,
+				$elm$parser$Parser$symbol(':')),
+			$elm$parser$Parser$spaces)),
+	$author$project$Puzzles$Day2$rgbLines);
+var $author$project$Puzzles$Day2$parser = $author$project$Puzzles$Day2$andOneMore(
+	{item: $author$project$Puzzles$Day2$gameParser, separator: '\n'});
+var $elm$parser$Parser$DeadEnd = F3(
+	function (row, col, problem) {
+		return {col: col, problem: problem, row: row};
+	});
+var $elm$parser$Parser$problemToDeadEnd = function (p) {
+	return A3($elm$parser$Parser$DeadEnd, p.row, p.col, p.problem);
+};
+var $elm$parser$Parser$Advanced$bagToList = F2(
+	function (bag, list) {
+		bagToList:
+		while (true) {
+			switch (bag.$) {
+				case 'Empty':
+					return list;
+				case 'AddRight':
+					var bag1 = bag.a;
+					var x = bag.b;
+					var $temp$bag = bag1,
+						$temp$list = A2($elm$core$List$cons, x, list);
+					bag = $temp$bag;
+					list = $temp$list;
+					continue bagToList;
+				default:
+					var bag1 = bag.a;
+					var bag2 = bag.b;
+					var $temp$bag = bag1,
+						$temp$list = A2($elm$parser$Parser$Advanced$bagToList, bag2, list);
+					bag = $temp$bag;
+					list = $temp$list;
+					continue bagToList;
+			}
+		}
+	});
+var $elm$parser$Parser$Advanced$run = F2(
+	function (_v0, src) {
+		var parse = _v0.a;
+		var _v1 = parse(
+			{col: 1, context: _List_Nil, indent: 1, offset: 0, row: 1, src: src});
+		if (_v1.$ === 'Good') {
+			var value = _v1.b;
+			return $elm$core$Result$Ok(value);
+		} else {
+			var bag = _v1.b;
+			return $elm$core$Result$Err(
+				A2($elm$parser$Parser$Advanced$bagToList, bag, _List_Nil));
+		}
+	});
+var $elm$parser$Parser$run = F2(
+	function (parser, source) {
+		var _v0 = A2($elm$parser$Parser$Advanced$run, parser, source);
+		if (_v0.$ === 'Ok') {
+			var a = _v0.a;
+			return $elm$core$Result$Ok(a);
+		} else {
+			var problems = _v0.a;
+			return $elm$core$Result$Err(
+				A2($elm$core$List$map, $elm$parser$Parser$problemToDeadEnd, problems));
+		}
+	});
+var $elm$core$List$sum = function (numbers) {
+	return A3($elm$core$List$foldl, $elm$core$Basics$add, 0, numbers);
+};
+var $author$project$Puzzles$Day2$puzzle1 = function (input) {
+	var _v0 = A2($elm$parser$Parser$run, $author$project$Puzzles$Day2$parser, input);
+	if (_v0.$ === 'Err') {
+		var a = _v0.a;
+		return A2(
+			$elm$core$Basics$always,
+			$elm$core$Result$Err('Invalid input'),
+			A2($elm$core$Debug$log, 'Output', a));
+	} else {
+		var g = _v0.a;
+		return $elm$core$Result$Ok(
+			$elm$core$String$fromInt(
+				$elm$core$List$sum(
+					A2(
+						$elm$core$List$map,
+						function (_v1) {
+							var number = _v1.number;
+							var games = _v1.games;
+							var isLegal = A2(
+								$elm$core$List$all,
+								function (rgb) {
+									return A2(
+										$elm$core$List$all,
+										function (f) {
+											return _Utils_cmp(
+												f(rgb),
+												f($author$project$Puzzles$Day2$maxAllowed)) < 1;
+										},
+										_List_fromArray(
+											[
+												function ($) {
+												return $.red;
+											},
+												function ($) {
+												return $.green;
+											},
+												function ($) {
+												return $.blue;
+											}
+											]));
+								},
+								games);
+							return isLegal ? number : 0;
+						},
+						g))));
+	}
+};
 var $elm$core$String$replace = F3(
 	function (before, after, string) {
 		return A2(
@@ -5404,6 +6324,63 @@ var $author$project$Puzzles$Day1$puzzle2 = function (input) {
 											'o1ne',
 											A3($elm$core$String$replace, 'zero', 'z0ero', input)))))))))));
 };
+var $elm$core$List$maximum = function (list) {
+	if (list.b) {
+		var x = list.a;
+		var xs = list.b;
+		return $elm$core$Maybe$Just(
+			A3($elm$core$List$foldl, $elm$core$Basics$max, x, xs));
+	} else {
+		return $elm$core$Maybe$Nothing;
+	}
+};
+var $elm$core$List$product = function (numbers) {
+	return A3($elm$core$List$foldl, $elm$core$Basics$mul, 1, numbers);
+};
+var $author$project$Puzzles$Day2$puzzle2 = function (input) {
+	var _v0 = A2($elm$parser$Parser$run, $author$project$Puzzles$Day2$parser, input);
+	if (_v0.$ === 'Err') {
+		var a = _v0.a;
+		return A2(
+			$elm$core$Basics$always,
+			$elm$core$Result$Err('Invalid input'),
+			A2($elm$core$Debug$log, 'Output', a));
+	} else {
+		var g = _v0.a;
+		return $elm$core$Result$Ok(
+			$elm$core$String$fromInt(
+				$elm$core$List$sum(
+					A2(
+						$elm$core$List$map,
+						function (_v1) {
+							var games = _v1.games;
+							var getMaximumFor = function (f) {
+								return A2(
+									$elm$core$Maybe$withDefault,
+									0,
+									$elm$core$List$maximum(
+										A2($elm$core$List$map, f, games)));
+							};
+							return $elm$core$List$product(
+								A2(
+									$elm$core$List$map,
+									getMaximumFor,
+									_List_fromArray(
+										[
+											function ($) {
+											return $.red;
+										},
+											function ($) {
+											return $.green;
+										},
+											function ($) {
+											return $.blue;
+										}
+										])));
+						},
+						g))));
+	}
+};
 var $author$project$Main$getFunctions = function (window) {
 	if (window.$ === 'Home') {
 		return _Utils_Tuple2(
@@ -5412,14 +6389,17 @@ var $author$project$Main$getFunctions = function (window) {
 			$elm$core$Basics$always(
 				$elm$core$Result$Err('There is no puzzle for this page!')));
 	} else {
-		if (window.a === 1) {
-			return _Utils_Tuple2($author$project$Puzzles$Day1$puzzle1, $author$project$Puzzles$Day1$puzzle2);
-		} else {
-			return _Utils_Tuple2(
-				$elm$core$Basics$always(
-					$elm$core$Result$Err('This puzzle has no implementation yet!')),
-				$elm$core$Basics$always(
-					$elm$core$Result$Err('This puzzle has no implementation yet!')));
+		switch (window.a) {
+			case 1:
+				return _Utils_Tuple2($author$project$Puzzles$Day1$puzzle1, $author$project$Puzzles$Day1$puzzle2);
+			case 2:
+				return _Utils_Tuple2($author$project$Puzzles$Day2$puzzle1, $author$project$Puzzles$Day2$puzzle2);
+			default:
+				return _Utils_Tuple2(
+					$elm$core$Basics$always(
+						$elm$core$Result$Err('This puzzle has no implementation yet!')),
+					$elm$core$Basics$always(
+						$elm$core$Result$Err('This puzzle has no implementation yet!')));
 		}
 	}
 };
@@ -8302,27 +9282,6 @@ var $elm$json$Json$Encode$object = function (pairs) {
 			_Json_emptyObject(_Utils_Tuple0),
 			pairs));
 };
-var $elm$core$List$any = F2(
-	function (isOkay, list) {
-		any:
-		while (true) {
-			if (!list.b) {
-				return false;
-			} else {
-				var x = list.a;
-				var xs = list.b;
-				if (isOkay(x)) {
-					return true;
-				} else {
-					var $temp$isOkay = isOkay,
-						$temp$list = xs;
-					isOkay = $temp$isOkay;
-					list = $temp$list;
-					continue any;
-				}
-			}
-		}
-	});
 var $mdgriffith$elm_ui$Internal$Model$fontName = function (font) {
 	switch (font.$) {
 		case 'Serif':
@@ -8369,9 +9328,6 @@ var $elm$core$Basics$min = F2(
 	function (x, y) {
 		return (_Utils_cmp(x, y) < 0) ? x : y;
 	});
-var $elm$core$Basics$negate = function (n) {
-	return -n;
-};
 var $mdgriffith$elm_ui$Internal$Model$renderProps = F3(
 	function (force, _v0, existing) {
 		var key = _v0.a;
@@ -9067,16 +10023,6 @@ var $elm$core$List$filter = F2(
 			_List_Nil,
 			list);
 	});
-var $elm$core$List$maximum = function (list) {
-	if (list.b) {
-		var x = list.a;
-		var xs = list.b;
-		return $elm$core$Maybe$Just(
-			A3($elm$core$List$foldl, $elm$core$Basics$max, x, xs));
-	} else {
-		return $elm$core$Maybe$Nothing;
-	}
-};
 var $elm$core$List$minimum = function (list) {
 	if (list.b) {
 		var x = list.a;
@@ -9371,7 +10317,6 @@ var $elm$virtual_dom$VirtualDom$keyedNode = function (tag) {
 	return _VirtualDom_keyedNode(
 		_VirtualDom_noScript(tag));
 };
-var $elm$core$Basics$not = _Basics_not;
 var $elm$html$Html$p = _VirtualDom_node('p');
 var $elm$core$Bitwise$and = _Bitwise_and;
 var $mdgriffith$elm_ui$Internal$Flag$present = F2(
@@ -11300,11 +12245,6 @@ var $mdgriffith$elm_ui$Element$Input$hasFocusStyle = function (attr) {
 var $mdgriffith$elm_ui$Element$Input$focusDefault = function (attrs) {
 	return A2($elm$core$List$any, $mdgriffith$elm_ui$Element$Input$hasFocusStyle, attrs) ? $mdgriffith$elm_ui$Internal$Model$NoAttribute : $mdgriffith$elm_ui$Internal$Model$htmlClass('focusable');
 };
-var $elm$core$Basics$composeL = F3(
-	function (g, f, x) {
-		return g(
-			f(x));
-	});
 var $elm$virtual_dom$VirtualDom$Normal = function (a) {
 	return {$: 'Normal', a: a};
 };
diff --git a/elm/src/Main.elm b/elm/src/Main.elm
index 18789ae..a04def5 100644
--- a/elm/src/Main.elm
+++ b/elm/src/Main.elm
@@ -2,16 +2,16 @@ module Main exposing (main)
 
 import Browser
 import Element
-import Tools.Colors as C
-import Widget
-import Widget.Material as Material
-import Widget.Material.Typography as Typography
 import Element.Background
 import Element.Input
-import Task
-
 import Puzzles.Day1 as Day1
+import Puzzles.Day2 as Day2
+import Task
+import Tools.Colors as C
+import Widget
 import Widget.Customize
+import Widget.Material as Material
+import Widget.Material.Typography as Typography
 
 
 main : Program () Model Msg
@@ -31,17 +31,22 @@ type alias Model =
     , output2 : Calculating
     }
 
+
 type Calculating
     = Outcome String
     | Calculating
     | InvalidInput String
     | NoInput
 
+
 type Window
     = Home
     | Day Int
 
-type alias Puzzle = String -> Result String String
+
+type alias Puzzle =
+    String -> Result String String
+
 
 getFunctions : Window -> ( Puzzle, Puzzle )
 getFunctions window =
@@ -50,15 +55,19 @@ getFunctions window =
             ( always <| Err "There is no puzzle for this page!"
             , always <| Err "There is no puzzle for this page!"
             )
-        
+
         Day 1 ->
             ( Day1.puzzle1, Day1.puzzle2 )
-        
+
+        Day 2 ->
+            ( Day2.puzzle1, Day2.puzzle2 )
+
         _ ->
             ( always <| Err "This puzzle has no implementation yet!"
             , always <| Err "This puzzle has no implementation yet!"
             )
 
+
 init : () -> ( Model, Cmd Msg )
 init () =
     ( { view = Home
@@ -89,16 +98,17 @@ update msg model =
               }
             , Cmd.none
             )
-        
+
         OnInput input ->
             ( { model
-              | input = input
-              , output1 = Calculating
-              , output2 = Calculating
+                | input = input
+                , output1 = Calculating
+                , output2 = Calculating
               }
             , if input == model.input then
                 Cmd.none
-            else
+
+              else
                 Cmd.batch
                     [ Task.succeed input
                         |> Task.map (getFunctions model.view |> Tuple.first)
@@ -108,48 +118,47 @@ update msg model =
                         |> Task.perform (Calculate2 model.view)
                     ]
             )
-        
+
         DoNothing ->
             ( model, Cmd.none )
-        
+
         Calculate1 w (Ok s) ->
             if w /= model.view then
                 ( model, Cmd.none )
-            
+
             else
                 ( { model | output1 = Outcome s }
                 , Cmd.none
                 )
-        
+
         Calculate1 w (Err s) ->
             if w /= model.view then
                 ( model, Cmd.none )
-            
+
             else
                 ( { model | output1 = InvalidInput s }
                 , Cmd.none
                 )
-        
+
         Calculate2 w (Ok s) ->
             if w /= model.view then
                 ( model, Cmd.none )
-            
+
             else
                 ( { model | output2 = Outcome s }
                 , Cmd.none
                 )
-        
+
         Calculate2 w (Err s) ->
             if w /= model.view then
                 ( model, Cmd.none )
-            
+
             else
                 ( { model | output2 = InvalidInput s }
                 , Cmd.none
                 )
 
 
-
 subscriptions : Model -> Sub Msg
 subscriptions model =
     Sub.none
@@ -160,7 +169,7 @@ view model =
     { title = "Document Title"
     , body =
         [ Widget.menuBar
-            ( Material.menuBar palette )
+            (Material.menuBar palette)
             { title =
                 "aoc2023"
                     |> Element.text
@@ -180,10 +189,10 @@ view model =
                     |> Element.width
                 , Element.alignTop
                 ]
-                ( List.map
-                    (\(window, text) ->
+                (List.map
+                    (\( window, text ) ->
                         Widget.fullBleedItem
-                            ( Material.fullBleedItem palette )
+                            (Material.fullBleedItem palette)
                             { text = text
                             , onPress = Just (ChangeWindow window)
                             , icon = always Element.none
@@ -203,32 +212,34 @@ view model =
                 , Element.padding 20
                 , Element.spacing 20
                 ]
-                ( case model.view of
+                (case model.view of
                     Home ->
                         [ "Advent of Code 2023"
                             |> Element.text
                             |> Element.el Typography.h3
                         ]
-                    
+
                     Day i ->
-                        [ [ "Using the following input for day " ++ String.fromInt i ++  ": "
-                              |> Element.text
+                        [ [ "Using the following input for day "
+                                ++ String.fromInt i
+                                ++ ": "
+                                |> Element.text
                           , Element.Input.multiline
-                              [ Element.fill
+                                [ Element.fill
                                     |> Element.maximum 500
                                     |> Element.height
-                              , Element.scrollbarX
-                              ]
-                              { onChange = OnInput
-                              , text = model.input
-                              , placeholder =
-                                  "Insert puzzle input here..."
-                                      |> Element.text
-                                      |> Element.Input.placeholder []
-                                      |> Just
-                              , label = Element.Input.labelHidden "input"
-                              , spellcheck = False
-                              }
+                                , Element.scrollbarX
+                                ]
+                                { onChange = OnInput
+                                , text = model.input
+                                , placeholder =
+                                    "Insert puzzle input here..."
+                                        |> Element.text
+                                        |> Element.Input.placeholder []
+                                        |> Just
+                                , label = Element.Input.labelHidden "input"
+                                , spellcheck = False
+                                }
                           ]
                         , case model.output1 of
                             Outcome s ->
@@ -243,12 +254,12 @@ view model =
                                     , spellcheck = False
                                     }
                                 ]
-                            
+
                             Calculating ->
                                 [ "Calculating part 1..."
                                     |> Element.text
                                 ]
-                            
+
                             InvalidInput s ->
                                 [ "INVALID INPUT FOR PART 1"
                                     |> Element.text
@@ -261,7 +272,7 @@ view model =
                                     , spellcheck = False
                                     }
                                 ]
-                            
+
                             NoInput ->
                                 List.singleton Element.none
                         , case model.output2 of
@@ -277,12 +288,12 @@ view model =
                                     , spellcheck = False
                                     }
                                 ]
-                            
+
                             Calculating ->
                                 [ "Calculating part 2..."
                                     |> Element.text
                                 ]
-                            
+
                             InvalidInput s ->
                                 [ "INVALID INPUT FOR PART 2"
                                     |> Element.text
@@ -295,7 +306,7 @@ view model =
                                     , spellcheck = False
                                     }
                                 ]
-                            
+
                             NoInput ->
                                 List.singleton Element.none
                         ]
@@ -308,10 +319,12 @@ view model =
             |> List.singleton
     }
 
+
 picker : C.Picker
 picker =
     C.get C.Trichromatic C.LightMode
 
+
 palette : Material.Palette
 palette =
     C.defaultPalette picker
diff --git a/elm/src/Puzzles/Day1.elm b/elm/src/Puzzles/Day1.elm
index b64606e..8882bd9 100644
--- a/elm/src/Puzzles/Day1.elm
+++ b/elm/src/Puzzles/Day1.elm
@@ -1,5 +1,6 @@
 module Puzzles.Day1 exposing (puzzle1, puzzle2)
 
+
 puzzle1 : String -> Result String String
 puzzle1 input =
     input
@@ -10,25 +11,25 @@ puzzle1 input =
                 case items of
                     head :: tail ->
                         Ok (calibrationValue head tail)
-                    
+
                     [] ->
                         Err i
             )
         |> List.foldl
             (\value sum ->
-                case (value, sum) of
-                    (_, Err _) ->
+                case ( value, sum ) of
+                    ( _, Err _ ) ->
                         sum
-                    
-                    (Err i, Ok _) ->
+
+                    ( Err i, Ok _ ) ->
                         Err ("Line" ++ (String.fromInt <| i + 1) ++ "does not contain any numbers")
-                    
-                    (Ok a, Ok b) ->
+
+                    ( Ok a, Ok b ) ->
                         Ok (a + b)
             )
             (Ok 0)
         |> Result.map String.fromInt
-        
+
 
 puzzle1Nums : String -> List Int
 puzzle1Nums s =
@@ -37,13 +38,15 @@ puzzle1Nums s =
         |> List.map String.fromChar
         |> List.filterMap String.toInt
 
+
 calibrationValue : Int -> List Int -> Int
 calibrationValue head tail =
     tail
         |> List.reverse
         |> List.head
         |> Maybe.withDefault head
-        |> (+) ( head * 10 )
+        |> (+) (head * 10)
+
 
 puzzle2 : String -> Result String String
 puzzle2 input =
diff --git a/elm/src/Puzzles/Day2.elm b/elm/src/Puzzles/Day2.elm
new file mode 100644
index 0000000..549c6c1
--- /dev/null
+++ b/elm/src/Puzzles/Day2.elm
@@ -0,0 +1,150 @@
+module Puzzles.Day2 exposing (puzzle1, puzzle2)
+
+import Parser as P exposing ((|.), (|=), Parser)
+
+
+type alias Game =
+    { number : Int, games : List RGB }
+
+
+type alias RGB =
+    { red : Int, green : Int, blue : Int }
+
+
+maxAllowed : RGB
+maxAllowed =
+    { red = 12, green = 13, blue = 14 }
+
+
+puzzle1 : String -> Result String String
+puzzle1 input =
+    case P.run parser input of
+        Err a ->
+            Debug.log "Output" a
+                |> always (Err "Invalid input")
+
+        Ok g ->
+            g
+                |> List.map
+                    (\{ number, games } ->
+                        let
+                            isLegal : Bool
+                            isLegal =
+                                List.all
+                                    (\rgb ->
+                                        List.all
+                                            (\f -> f rgb <= f maxAllowed)
+                                            [ .red, .green, .blue ]
+                                    )
+                                    games
+                        in
+                        if isLegal then
+                            number
+
+                        else
+                            0
+                    )
+                |> List.sum
+                |> String.fromInt
+                |> Ok
+
+
+puzzle2 : String -> Result String String
+puzzle2 input =
+    case P.run parser input of
+        Err a ->
+            Debug.log "Output" a
+                |> always (Err "Invalid input")
+
+        -- 179502 too high
+        Ok g ->
+            g
+                |> List.map
+                    (\{ games } ->
+                        let
+                            getMaximumFor : (RGB -> Int) -> Int
+                            getMaximumFor f =
+                                games
+                                    |> List.map f
+                                    |> List.maximum
+                                    |> Maybe.withDefault 0
+                        in
+                        [ .red, .green, .blue ]
+                            |> List.map getMaximumFor
+                            |> List.product
+                    )
+                |> List.sum
+                |> String.fromInt
+                |> Ok
+
+
+parser : Parser (List Game)
+parser =
+    andOneMore
+        { separator = "\n"
+        , item = gameParser
+        }
+
+
+gameParser : Parser Game
+gameParser =
+    P.succeed Game
+        |. P.keyword "Game"
+        |. P.spaces
+        |= P.int
+        |. P.symbol ":"
+        |. P.spaces
+        |= rgbLines
+
+
+rgbLines : Parser (List RGB)
+rgbLines =
+    andOneMore
+        { separator = ";"
+        , item = rgbParser
+        }
+
+
+rgbParser : Parser RGB
+rgbParser =
+    P.succeed (List.foldl (<|) (RGB 0 0 0))
+        |= andOneMore
+            { separator = ","
+            , item = rgbStmt
+            }
+
+
+rgbStmt : Parser (RGB -> RGB)
+rgbStmt =
+    P.succeed (|>)
+        |= P.int
+        |. P.spaces
+        |= P.oneOf
+            [ P.succeed (\i rgb -> { rgb | red = i })
+                |. P.keyword "red"
+            , P.succeed (\i rgb -> { rgb | blue = i })
+                |. P.keyword "blue"
+            , P.succeed (\i rgb -> { rgb | green = i })
+                |. P.keyword "green"
+            ]
+
+
+andOneMore : { separator : String, item : Parser a } -> Parser (List a)
+andOneMore { separator, item } =
+    P.loop []
+        (\xs ->
+            P.succeed (\x state -> state (x :: xs))
+                |= item
+                |. onlySpaces
+                |= P.oneOf
+                    [ P.succeed P.Loop
+                        |. P.token separator
+                    , P.succeed P.Done
+                    ]
+                |. onlySpaces
+        )
+
+
+onlySpaces : Parser ()
+onlySpaces =
+    P.chompWhile (\c -> c == ' ')
diff --git a/elm/src/Puzzles/DayX.elm b/elm/src/Puzzles/DayX.elm
new file mode 100644
index 0000000..10c62a5
--- /dev/null
+++ b/elm/src/Puzzles/DayX.elm
@@ -0,0 +1,11 @@
+module Puzzles.DayX exposing (puzzle1, puzzle2)
+
+
+puzzle1 : String -> Result String String
+puzzle1 _ =
+    Err "Not implemented yet!"
+
+
+puzzle2 : String -> Result String String
+puzzle2 _ =
+    Err "Not implemented yet!"
diff --git a/elm/src/Tools/Colors.elm b/elm/src/Tools/Colors.elm
index a8debc1..156bf86 100644
--- a/elm/src/Tools/Colors.elm
+++ b/elm/src/Tools/Colors.elm
@@ -409,6 +409,7 @@ transparent =
     Color.rgba 0 0 0 0
 
 
+
 -- PRIMARY COLOR