public static void Problem1()
{
var input = FileReader.ReadLines("Inputs\\day7.txt");
var inside = new Dictionary <string, List <string> >();
foreach (var line in input)
{
var parts = line.Split(' ');
var outside = parts[0] + " " + parts[1];
if (parts[4] != "no")
{
for (int i = 1; 4 * i < parts.Length; i++)
{
var name = parts[i * 4 + 1] + " " + parts[i * 4 + 2];
if (!inside.ContainsKey(name))
{
inside[name] = new List <string>();
}
inside[name].Add(outside);
}
}
}
HashSet <string> items = new HashSet <string>();
Queue <string> q = new Queue <string>();
q.Enqueue("shiny gold");
while (q.Count > 0)
{
var item = q.Dequeue();
if (inside.ContainsKey(item))
{
foreach (var i in inside[item])
{
if (!items.Contains(i))
{
items.Add(i);
q.Enqueue(i);
}
}
}
}
Console.WriteLine($"Part 1: {items.Count}");
}
public static void Problems()
{
var input = FileReader.ReadLines("Inputs\\day6.txt");
input.Add("");
int result1 = 0;
HashSet <char> values = new HashSet <char>();
int result2 = 0;
var values2 = new int[26];
int expected = 0;
foreach (var line in input)
{
if (line != "")
{
expected++;
foreach (var c in line)
{
values.Add(c);
values2[c - 'a']++;
}
}
else
{
result1 += values.Count;
foreach (var value in values2)
{
if (value == expected)
{
result2++;
}
}
values = new HashSet <char>();
expected = 0;
values2 = new int[26];
}
}
Console.WriteLine($"Part 1: {result1}");
Console.WriteLine($"Part 2: {result2}");
}
public static void Problems()
{
var input = FileReader.ReadLines("Inputs\\day14.txt");
var mask = "";
Dictionary <long, long> memory1 = new Dictionary <long, long>();
Dictionary <long, long> memory2 = new Dictionary <long, long>();
foreach (var line in input)
{
var parts = line.Split(' ');
if (parts[0] == "mask")
{
mask = parts[2];
}
else
{
var i = Convert.ToInt64(parts[0][4..^ 1]);
public static void Problem1()
{
var inputs = FileReader.ReadLines("Inputs\\day3.txt");
int result = 0;
int column = 3;
for (int i = 1; i < inputs.Count; i++)
{
var line = inputs[i];
var c = line[column];
if (c == '#')
{
result++;
}
column += 3;
column %= line.Length;
}
Console.WriteLine(result);
}
public static void Problem1()
{
var input = FileReader.ReadLines("Inputs\\day1.txt");
HashSet <long> nums = new HashSet <long>();
long result = -1;
for (int i = 0; i < input.Count - 1 && result == -1; i++)
{
var x = Convert.ToInt64(input[i]);
if (nums.Contains(2020 - x))
{
result = (2020 - x) * x;
}
else
{
nums.Add(x);
}
}
Console.WriteLine(result);
}
public static void Problems()
{
var input = FileReader.ReadLines("Inputs\\day17.txt");
PuzzleData data1 = new PuzzleData
{
xMax = input[0].Length - 1,
yMax = input.Count - 1
};
//get starting values from puzzle input
for (int x = 0; x < input[0].Length; x++)
{
for (int y = 0; y < input.Count; y++)
{
if (input[y][x] == '#')
{
data1.Active.Add((x, y, 0, 0));
}
}
}
PuzzleData data2 = new PuzzleData
{
xMax = input[0].Length - 1,
yMax = input.Count - 1,
Active = new HashSet <(int x, int y, int z, int w)>(data1.Active)
};
for (int i = 1; i <= 6; i++)
{
data1 = GetNext(data1);
data2 = GetNext(data2, true);
}
Console.WriteLine($"Part 1: {data1.Active.Count}");
Console.WriteLine($"Part 2: {data2.Active.Count}");
}
public static void Problems()
{
var input = FileReader.ReadLines("Inputs\\day8.txt");
var(_, value1) = Test(input);
Console.WriteLine($"Part 1: {value1}");
for (int i = 0; i < input.Count; i++)
{
var instruction = input[i].Split(' ')[0];
if (instruction == "jmp" || instruction == "nop")
{
var input2 = new List <string>(input);
input2[i] = instruction == "jmp" ? input[i].Replace("jmp", "nop") : input[i].Replace("nop", "jmp");
var(completed2, value2) = Test(input2);
if (completed2)
{
Console.WriteLine($"Part 2: {value2}");
break;
}
}
}
}
public static void Problem2()
{
var inputs = FileReader.ReadLines("Inputs\\day2.txt");
int valid = 0;
foreach (var input in inputs)
{
var parts = input.Split(" ");
var indexes = parts[0].Split("-");
int indexA = Convert.ToInt32(indexes[0]);
int indexB = Convert.ToInt32(indexes[1]);
char letterNeeded = parts[1][0];
//per puzzle instructions, indexes are 1-based
if (parts[2][indexA - 1] == letterNeeded ^ parts[2][indexB - 1] == letterNeeded)
{
valid++;
}
}
Console.WriteLine(valid);
}
public static void Problems()
{
var input = FileReader.ReadLines("Inputs\\day21.txt");
//day 21 puzzle -
//puzzle input is a list of made-up nonsense words ("ingredients")
//along with a list of "allergens" for each list of ingredients
//go through list and figure out which ingredients cannot possibly be an allergen (part 1)
//note: per puzzle rules, if the allergen is listed, the made-up ingredient that
//matches it will always appear in that same line, but an ingredient
//that is an allergen may or may not have the allergen listed in that line
Dictionary <string, HashSet <string> > allergens = new Dictionary <string, HashSet <string> >();
Dictionary <string, int> ingredientCount = new Dictionary <string, int>();
foreach (var line in input)
{
var lineIngredients = line.Substring(0, line.IndexOf("(")).Split(' ');
var lineAllergens = line.Substring(line.IndexOf("contains") + 9).Replace(",", "")[0..^ 1].Split(' ');
foreach (var ingredient in lineIngredients)
{
if (!ingredientCount.ContainsKey(ingredient))
{
ingredientCount[ingredient] = 0;
}
ingredientCount[ingredient]++;
}
foreach (var allergen in lineAllergens)
{
if (!allergens.ContainsKey(allergen))
{
allergens[allergen] = new HashSet <string>(lineIngredients);
}
else
{
//remove any items from previous set that are not in current list
allergens[allergen].IntersectWith(lineIngredients);
}
}
}
HashSet <string> possibleAllergenIngredients = new HashSet <string>();
foreach (var allergen in allergens.Keys)
{
possibleAllergenIngredients.UnionWith(allergens[allergen]);
}
long result1 = 0;
foreach (var ingredient in ingredientCount.Keys)
{
if (!possibleAllergenIngredients.Contains(ingredient))
{
result1 += ingredientCount[ingredient];
}
}
Console.WriteLine($"Part 1: {result1}");
//part 2:
Isolate(allergens);
List <string> allergenList = new List <string>(allergens.Keys);
allergenList.Sort();
string result2 = "";
foreach (var ingredient in allergens[allergenList[0]])
{
result2 += ingredient;
}
for (int i = 1; i < allergenList.Count; i++)
{
foreach (var ingredient in allergens[allergenList[i]])
{
result2 += "," + ingredient;
}
}
Console.WriteLine($"Part 2: {result2}");
}
public static void Problems()
{
var input = FileReader.ReadLines("Inputs\\day18.txt");
long result1 = 0;
for (int i = 0; i < input.Count; i++)
{
long value = 0;
char operation = '+';
Stack <(long value, char operation)> stack = new Stack <(long value, char operation)>();
foreach (var c in input[i])
{
switch (c)
{
case '*':
case '+':
operation = c;
break;
case '(':
stack.Push((value, operation));
value = 0;
operation = '+';
break;
case ')':
var temp = stack.Pop();
if (temp.operation == '+')
{
value += temp.value;
}
if (temp.operation == '*')
{
value *= temp.value;
}
break;
case ' ':
break;
default:
if (operation == '+')
{
value += c - '0';
}
if (operation == '*')
{
value *= c - '0';
}
break;
}
}
result1 += value;
}
Console.WriteLine($"Part 1: {result1}");
long result2 = 0;
long result3 = 0;
//both of the methods below correctly solve part 2
//I kept both versions of my solution to compare their performance
Stopwatch stopwatch2 = new Stopwatch();
stopwatch2.Start();
for (int i = 0; i < input.Count; i++)
{
result2 += Part2(input[i]);
}
stopwatch2.Stop();
Stopwatch stopwatch3 = new Stopwatch();
stopwatch3.Start();
for (int i = 0; i < input.Count; i++)
{
result3 += Part2_Stack(input[i]);
}
stopwatch3.Stop();
Console.WriteLine($"Part 2: {result2} completed in {stopwatch2.ElapsedMilliseconds} ms");
Console.WriteLine($"Part 2 (using stack): {result3} completed in {stopwatch3.ElapsedMilliseconds} ms");
}
public static void Problem2()
{
var inputs = FileReader.ReadLines("Inputs\\day3.txt");
long result0 = 0; //right 1, down 1
long result1 = 0; //right 3, down 1
long result2 = 0; //right 5, down 1
long result3 = 0; //right 7, down 1
long result4 = 0; //right 1, down 2
int column0 = 1;
int column1 = 3;
int column2 = 5;
int column3 = 7;
int column4 = 1;
for (int i = 1; i < inputs.Count; i++)
{
var line = inputs[i];
if (line[column0] == '#')
{
result0++;
}
column0 += 1;
column0 %= line.Length;
if (line[column1] == '#')
{
result1++;
}
column1 += 3;
column1 %= line.Length;
if (line[column2] == '#')
{
result2++;
}
column2 += 5;
column2 %= line.Length;
if (line[column3] == '#')
{
result3++;
}
column3 += 7;
column3 %= line.Length;
if (i % 2 == 0)
{
if (line[column4] == '#')
{
result4++;
}
column4 += 1;
column4 %= line.Length;
}
}
Console.WriteLine(result0 * result1 * result2 * result3 * result4);
}
public static void Problems()
{
var input = FileReader.ReadLines("Inputs\\day12.txt");
(int x, int y)currentPosition = (0, 0);
int direction = 90;
foreach (var line in input)
{
var steps = Convert.ToInt32(line.Substring(1));
switch (line[0])
{
case 'N':
currentPosition.y += steps;
break;
case 'S':
currentPosition.y -= steps;
break;
case 'E':
currentPosition.x += steps;
break;
case 'W':
currentPosition.x -= steps;
break;
case 'L':
direction += 360 - steps;
direction %= 360;
break;
case 'R':
direction += steps;
direction %= 360;
break;
case 'F':
var move = GetDirection(direction);
currentPosition.x += move.x * steps;
currentPosition.y += move.y * steps;
break;
}
}
var part1 = Math.Abs(currentPosition.x) + Math.Abs(currentPosition.y);
Console.WriteLine($"Part 1: {part1}");
currentPosition = (0, 0);
(int x, int y)point = (10, 1);
foreach (var line in input)
{
var steps = Convert.ToInt32(line.Substring(1));
switch (line[0])
{
case 'N':
point.y += steps;
break;
case 'S':
point.y -= steps;
break;
case 'E':
point.x += steps;
break;
case 'W':
point.x -= steps;
break;
case 'L':
point = Rotate('L', steps, point);
break;
case 'R':
point = Rotate('R', steps, point);
break;
case 'F':
currentPosition.x += point.x * steps;
currentPosition.y += point.y * steps;
break;
}
}
var part2 = Math.Abs(currentPosition.x) + Math.Abs(currentPosition.y);
Console.WriteLine($"Part 2: {part2}");
}
public static void Problems()
{
var input = FileReader.ReadLines("Inputs\\day24.txt");
var tiles = new HashSet <(int x, int y)>();
foreach (var value in input)
{
var location = Move(value);
if (tiles.Contains(location))
{
tiles.Remove(location);
}
else
{
tiles.Add(location);
}
}
Console.WriteLine($"Part 1: {tiles.Count}");
int xMin = Int32.MaxValue;
int xMax = Int32.MinValue;
int yMin = Int32.MaxValue;
int yMax = Int32.MinValue;
foreach (var location in tiles)
{
xMin = Math.Min(xMin, location.x);
xMax = Math.Max(xMax, location.x);
yMin = Math.Min(yMin, location.y);
yMax = Math.Max(yMax, location.y);
}
for (int i = 1; i <= 100; i++)
{
xMin--;
xMax++;
yMin--;
yMax++;
int xMinNext = Int32.MaxValue;
int xMaxNext = Int32.MinValue;
int yMinNext = Int32.MaxValue;
int yMaxNext = Int32.MinValue;
HashSet <(int x, int y)> next = new HashSet <(int x, int y)>();
for (int x = xMin; x <= xMax; x++)
{
for (int y = yMin; y <= yMax; y++)
{
var tileCount = CountTiles((x, y), tiles);
if (tileCount == 2 || (tiles.Contains((x, y)) && tileCount == 1))
{
xMinNext = Math.Min(xMinNext, x);
xMaxNext = Math.Max(xMaxNext, x);
yMinNext = Math.Min(yMinNext, y);
yMaxNext = Math.Max(yMaxNext, y);
next.Add((x, y));
}
}
}
tiles = next;
xMin = xMinNext;
xMax = xMaxNext;
yMin = yMinNext;
yMax = yMaxNext;
}
Console.WriteLine($"Part 2: {tiles.Count}");
}
public static void Problems()
{
//both parts of day 4 need similar logic, so added part 2 logic to the part 1 method instead of creating 2 methods
var inputs = FileReader.ReadLines("Inputs\\day4.txt");
inputs.Add(""); //add a blank line at the end to make processing loop correctly process the last entry
long result1 = 0;
long result2 = 0;
//test for all 7 required pieces for part 1
bool b = false;
bool i = false;
bool e = false;
bool h = false;
bool hc = false;
bool ec = false;
bool p = false;
//test for all 7 required pieces for part 2
bool b2 = false;
bool i2 = false;
bool e2 = false;
bool h2 = false;
bool hc2 = false;
bool ec2 = false;
bool p2 = false;
foreach (var line in inputs)
{
if (line.Trim() != "")
{
var fields = line.Split(' ');
foreach (var field in fields)
{
var fieldType = field.Split(':')[0];
var fieldValue = field.Split(':')[1].Trim();
int value;
switch (fieldType)
{
case "byr":
b = true;
if (fieldValue.Length == 4 && int.TryParse(fieldValue, out value) && value >= 1920 && value <= 2002)
{
b2 = true;
}
break;
case "iyr":
i = true;
if (fieldValue.Length == 4 && int.TryParse(fieldValue, out value) && value >= 2010 && value <= 2020)
{
i2 = true;
}
break;
case "eyr":
e = true;
if (fieldValue.Length == 4 && int.TryParse(fieldValue, out value) && value >= 2020 && value <= 2030)
{
e2 = true;
}
break;
case "hgt":
h = true;
var hNum = fieldValue.Substring(0, fieldValue.Length - 2);
if (fieldValue.EndsWith("cm"))
{
if (int.TryParse(hNum, out value) && value >= 150 && value <= 193)
{
h2 = true;
}
}
else if (fieldValue.EndsWith("in"))
{
if (int.TryParse(hNum, out value) && value >= 59 && value <= 76)
{
h2 = true;
}
}
break;
case "hcl":
hc = true;
if (fieldValue.Length == 7 && fieldValue[0] == '#')
{
bool valid = true;
for (int j = 1; j < 7; j++)
{
if (!((fieldValue[j] - '0' >= 0 && fieldValue[j] - '0' <= 9) || (fieldValue[j] - 'a' >= 0 && fieldValue[j] - 'a' <= 6)))
{
valid = false;
}
}
if (valid)
{
hc2 = true;
}
}
break;
case "ecl":
ec = true;
if (fieldValue == "amb" || fieldValue == "blu" || fieldValue == "brn" || fieldValue == "gry" || fieldValue == "grn" || fieldValue == "hzl" || fieldValue == "oth")
{
ec2 = true;
}
break;
case "pid":
p = true;
if (fieldValue.Length == 9 && int.TryParse(fieldValue, out _))
{
p2 = true;
}
break;
default:
break;
}
}
}
else
{
if (b && i && e && h && hc && ec && p)
{
result1++;
}
if (b2 && i2 && e2 && h2 && hc2 && ec2 && p2)
{
result2++;
}
b = false;
i = false;
e = false;
h = false;
hc = false;
ec = false;
p = false;
b2 = false;
i2 = false;
e2 = false;
h2 = false;
hc2 = false;
ec2 = false;
p2 = false;
}
}
Console.WriteLine($"Part 1: {result1}");
Console.WriteLine($"Part 2: {result2}");
}
public static void Problems()
{
var input = FileReader.ReadLines("Inputs\\day16.txt");
var fieldList = new Dictionary <string, (long min1, long max1, long min2, long max2)>();
int rowNumber = 0;
while (rowNumber < input.Count && !(input[rowNumber] == ""))
{
var parts = input[rowNumber].Split(':');
var temp = parts[1].Replace("or", "-");
var r = temp.ToLongArray('-');
fieldList.Add(parts[0], (r[0], r[1], r[2], r[3]));
rowNumber++;
}
rowNumber += 2;
var t = input[rowNumber].ToLongArray();
rowNumber += 3;
List <long[]> rows = new List <long[]>();
while (rowNumber < input.Count)
{
rows.Add(input[rowNumber].ToLongArray());
rowNumber++;
}
long result1 = 0;
HashSet <int> invalid = new HashSet <int>();
for (int i = 0; i < rows.Count; i++)
{
var values = rows[i];
foreach (var value in values)
{
bool valid = false;
foreach (var r in fieldList.Values)
{
if ((value <= r.max1 && value >= r.min1) || (value <= r.max2 && value >= r.min2))
{
valid = true;
}
}
if (!valid)
{
result1 += value;
invalid.Add(i);
}
}
}
Console.WriteLine($"Part 1: {result1}");
Dictionary <int, List <string> > fields = new Dictionary <int, List <string> >();
for (int field = 0; field < rows[0].Length; field++)
{
fields[field] = new List <string>();
foreach (var n in fieldList.Keys)
{
fields[field].Add(n);
}
for (int i = 0; i < rows.Count; i++)
{
if (invalid.Contains(i))
{
continue;
}
var temp = new List <string>();
var value = rows[i][field];
foreach (var n in fields[field])
{
var r = fieldList[n];
if ((value <= r.max1 && value >= r.min1) || (value <= r.max2 && value >= r.min2))
{
temp.Add(n);
}
}
fields[field] = temp;
}
}
ReduceList(fields);
long result2 = 1;
foreach (var field in fields.Keys)
{
if (fields[field][0].StartsWith("departure"))
{
result2 *= t[field];
}
}
Console.WriteLine($"Part 1: {result2}");
}
