public int getTrees(int xStep, int yStep)
{
string[] inputsRaw = AoCUtils.readInputFile(this.GetType().Name.Substring(3));
int width = inputsRaw[0].Length;
int currX = 0;
int currY = 0;
int countTree = 0;
while (currY < inputsRaw.Length - 1)
{
currX += xStep;
currY += yStep;
if (currX > width - 1)
{
currX = currX % width;
}
if (inputsRaw[currY][currX] == '#')
{
countTree++;
}
}
return(countTree);
}
/// <inheritdoc cref="Solver.Run"/>
public override void Run()
{
int part1 = 0;
int part2 = 0;
foreach ((int min, int max, char target, string password) in this.Data)
{
//Part 1
int occurrences = password.Count(c => c == target);
if (occurrences >= min && occurrences <= max)
{
part1++;
}
//Part 2
if (password[min - 1] == target)
{
if (password[max - 1] != target)
{
part2++;
}
}
else if (password[max - 1] == target)
{
part2++;
}
}
AoCUtils.LogPart1(part1);
AoCUtils.LogPart2(part2);
}
public string SolveP2()
{
int target = 2020;
List <string> inputsRaw = AoCUtils.readInputFile(this.GetType().Name.Substring(3)).ToList();
List <int> inputs = inputsRaw.Select(x => Int32.Parse(x)).Where(x => x < target).ToList();
for (int ii = 0; ii < inputs.Count; ii++)
{
for (int jj = 0; jj < inputs.Count; jj++)
{
for (int kk = 0; kk < inputs.Count; kk++)
{
if (ii == jj || ii == kk || jj == kk)
{
continue;
}
if (inputs[ii] + inputs[jj] + inputs[kk] == target)
{
return((inputs[ii] * inputs[jj] * inputs[kk]).ToString());
}
}
}
}
return(null);
}
public string SolveP3()
{
int target = 3232322;
List <string> inputsRaw = AoCUtils.readInputFile("01_3").ToList();
List <int> inputs = inputsRaw.Select(x => Int32.Parse(x)).Where(x => x < target).ToList();
for (int ii = 0; ii < inputs.Count; ii++)
{
for (int jj = 0; jj < inputs.Count; jj++)
{
for (int kk = 0; kk < inputs.Count; kk++)
{
if (ii == jj || ii == kk || jj == kk)
{
continue;
}
if (inputs[ii] + inputs[jj] + inputs[kk] == target)
{
long temp1 = inputs[ii];
long temp2 = inputs[jj];
long temp3 = inputs[kk];
long prodResult = temp1 * temp2 * temp3;
return(prodResult.ToString());
}
}
}
}
return(null);
}
public string SolveP2()
{
int count = 0;
List <string> inputsRaw = AoCUtils.readInputFile(this.GetType().Name.Substring(3)).ToList();
foreach (string currPair in inputsRaw)
{
string[] components = currPair.Split(' ');
string[] passLengths = components[0].Split('-');
int min = Int32.Parse(passLengths[0]);
int max = Int32.Parse(passLengths[1]);
char reqChar = components[1].ToCharArray().First();
char[] password = components[2].ToCharArray();
List <char> charsAtInd = new List <char>()
{
password[min - 1], password[max - 1]
};
int charCount = charsAtInd.Where(x => x == reqChar).Count();
if (charCount == 1)
{
count++;
}
}
return(count.ToString());
}
/// <inheritdoc cref="Solver.Run"/>
public override void Run()
{
// Search for best path to the end
Vector2 <int> start = Vector2 <int> .Zero, end = (this.Grid.Width - 1, this.Grid.Height - 1);
// ReSharper disable once AccessToModifiedClosure
Vector2 <int>[] path = SearchUtils.Search(start, end, p => Vector2 <int> .ManhattanDistance(p, end), node => FindNeighbours(node, this.Grid), MinSearchComparer.Comparer) !;
int total = path.Sum(p => this.Grid[p]);
AoCUtils.LogPart1(total);
// Create scaled map
Grid <byte> fullMap = new(this.Data.Width * FULL_SIZE, this.Data.Height * FULL_SIZE);
foreach (Vector2 <int> position in Vector2 <int> .Enumerate(this.Data.Width, this.Data.Height))
{
int risk = this.Data[position];
foreach (Vector2 <int> offset in Vector2 <int> .Enumerate(FULL_SIZE, FULL_SIZE))
{
Vector2 <int> pos = position + offset.Scale(this.Data.Width, this.Data.Height);
int newRisk = risk + offset.X + offset.Y;
fullMap[pos] = (byte)(newRisk > 9 ? newRisk - 9 : newRisk);
}
}
// Search for new best path
end = (fullMap.Width - 1, fullMap.Height - 1);
path = SearchUtils.Search(start, end, p => Vector2 <int> .ManhattanDistance(p, end), node => FindNeighbours(node, fullMap), MinSearchComparer.Comparer) !;
total = path.Sum(p => fullMap[p]);
AoCUtils.LogPart2(total);
}
public string SolveP2()
{
string[] inputsRaw = AoCUtils.readInputFile(this.GetType().Name.Substring(3));
List <int> seatIds = new List <int>();
int maxRow = 127;
int maxCol = 7;
foreach (string currLine in inputsRaw)
{
double rowStart = 0;
double rowEnd = maxRow;
for (int ii = 0; ii < 7; ii++)
{
if (currLine[ii] == 'F')
{
rowEnd = rowEnd - Math.Ceiling((rowEnd - rowStart) / 2);
}
else
{
rowStart = rowStart + Math.Ceiling((rowEnd - rowStart) / 2);
}
}
double colStart = 0;
double colEnd = maxCol;
for (int ii = 7; ii < currLine.Length; ii++)
{
if (currLine[ii] == 'L')
{
colEnd = colEnd - Math.Ceiling((colEnd - colStart) / 2);
}
else
{
colStart = colStart + Math.Ceiling((colEnd - colStart) / 2);
}
}
seatIds.Add((int)(rowStart * 8 + colStart));
}
int theSeat = 0;
seatIds.Sort();
for (int ii = 0; ii < seatIds.Count() - 1; ii++)
{
if (seatIds[ii + 1] - seatIds[ii] != 1)
{
theSeat = seatIds[ii] + 1;
}
}
return(theSeat.ToString());
}
/// <inheritdoc cref="Solver.Run"/>
public override void Run()
{
this.VM.AddInput(1L);
this.VM.Run();
AoCUtils.LogPart1(this.VM.GetNextOutput());
this.VM.Reset();
this.VM.AddInput(2L);
this.VM.Run();
AoCUtils.LogPart2(this.VM.GetNextOutput());
}
/// <inheritdoc cref="Solver.Run"/>
public override void Run()
{
this.VM.AddInput(1L);
this.VM.Run();
AoCUtils.LogPart1(string.Join(' ', this.Data.GetOutput()));
this.VM.Reset();
this.VM.AddInput(5L);
this.VM.Run();
AoCUtils.LogPart2(this.Data.GetNextOutput());
}
public string SolveP3()
{
List <char> resultChar = new List <char>();
List <string> inputsRaw = AoCUtils.readInputFile("02_3").ToList();
foreach (string currPair in inputsRaw)
{
string[] components = currPair.Split(' ');
string[] passLengths = components[0].Split('-');
int startInd = Int32.Parse(passLengths[0]) - 1;
int endInd = Int32.Parse(passLengths[1]) - 1;
char reqChar = components[1].ToCharArray().First();
string passwordFrag = components[2].Substring(startInd, endInd - startInd + 1);
Boolean isPalindrone = true;
for (int ii = 0; ii < passwordFrag.Length / 2; ii++)
{
if (passwordFrag[ii] != passwordFrag[passwordFrag.Length - 1 - ii])
{
isPalindrone = false;
}
}
// A = 65 : Z = 90
// a = 97 : z = 122
if (isPalindrone)
{
char rot13Char;
int tempCode = (int)reqChar + 13;
if (reqChar <= 122 && reqChar >= 97 && tempCode > 122)
{
int offset = tempCode - 122;
rot13Char = (char)(97 + offset - 1);
}
else if (reqChar <= 90 && reqChar >= 65 && tempCode > 90)
{
int offset = tempCode - 90;
rot13Char = (char)(65 + offset - 1);
}
else
{
rot13Char = (char)tempCode;
}
resultChar.Add(rot13Char);
}
}
return(new string(resultChar.ToArray()));
}
/// <inheritdoc cref="Solver.Run"/>
public override void Run()
{
//Get all existing ingredients and allergens
Dictionary <string, int> ingredientCount = new();
HashSet <string> allergens = new();
foreach (IngredientList list in this.Data)
{
//Loop through list ingredients
foreach (string ingredient in list.Ingredients)
{
//Keep track of how many times we've seen the ingredient
ingredientCount.TryGetValue(ingredient, out int amount);
ingredientCount[ingredient] = amount + 1;
}
//Add all children allergens
allergens.UnionWith(list.Allergens);
}
//Get impossible ingredients
HashSet <string> impossible = new(ingredientCount.Keys);
Dictionary <string, HashSet <string> > possibilities = new();
foreach (string allergen in allergens)
{
//Remove all ingredients not present every time
HashSet <string> ingredients = new(ingredientCount.Keys);
foreach (IngredientList list in this.Data.Where(l => l.Allergens.Contains(allergen)))
{
ingredients.IntersectWith(list.Ingredients);
}
//Remove possible ingredients from impossible list
impossible.ExceptWith(ingredients);
possibilities.Add(allergen, ingredients);
}
AoCUtils.LogPart1(impossible.Sum(i => ingredientCount[i]));
//Get definitive allergens
SortedDictionary <string, string> sortedAllergens = new();
while (!possibilities.IsEmpty())
{
//Get first known allergen
(string allergen, HashSet <string> ingredients) = possibilities.First(p => p.Value.Count is 1);
possibilities.Remove(allergen);
string ingredient = ingredients.First();
//Add to final sorted list and remove from other lists
sortedAllergens.Add(allergen, ingredient);
possibilities.ForEach(p => p.Value.Remove(ingredient));
}
AoCUtils.LogPart2(string.Join(',', sortedAllergens.Values));
}
public string SolveP1()
{
string[] inputsRaw = AoCUtils.readInputFile(this.GetType().Name.Substring(3));
char shipDir = 'E';
int[] currCoords = new int[2] {
0, 0
};
foreach (string currInstr in inputsRaw)
{
char instr = currInstr[0];
int value = Int32.Parse(currInstr.Substring(1));
int turns, ind;
switch (instr)
{
case 'N':
case 'E':
case 'S':
case 'W':
currCoords[0] += value * dirVectors[instr].Item1;
currCoords[1] += value * dirVectors[instr].Item2;
break;
case 'F':
currCoords[0] += value * dirVectors[shipDir].Item1;
currCoords[1] += value * dirVectors[shipDir].Item2;
break;
case 'R':
turns = value / 90;
ind = directions.IndexOf(shipDir);
ind += turns;
ind %= 4;
shipDir = directions[ind];
break;
case 'L':
turns = value / 90;
ind = revDirections.IndexOf(shipDir);
ind += turns;
ind %= 4;
shipDir = revDirections[ind];
break;
}
}
int result = Math.Abs(currCoords[0]) + Math.Abs(currCoords[1]);
return(result.ToString());
}
/// <inheritdoc cref="Solver.Run"/>
public override void Run()
{
// Get maximum crab value
int max = this.Data.Max();
// Minimize distance to any point within the crabs
long best = (..^ max).AsEnumerable().Min(position => this.Data.Sum(crab => Math.Abs(position - crab)));
AoCUtils.LogPart1(best);
// Minimize the distance of triangular value
best = (..^ max).AsEnumerable().Min(position => this.Data.Sum(crab => Math.Abs(position - crab).Triangular()));
AoCUtils.LogPart2(best);
}
/// <inheritdoc cref="Solver.Run"/>
public override void Run()
{
int risk = 0;
List <Vector2 <int> > lowPoints = new();
foreach (Vector2 <int> position in Vector2 <int> .Enumerate(this.Grid.Width, this.Grid.Height))
{
// Check if the position is a low point
byte value = this.Grid[position];
if (position.Adjacent()
.Where(this.Grid.WithinGrid)
.Any(pos => value >= this.Grid[pos]))
{
continue;
}
lowPoints.Add(position);
risk += value + 1;
}
AoCUtils.LogPart1(risk);
Queue <Vector2 <int> > search = new();
HashSet <Vector2 <int> > basin = new();
PriorityQueue <int> sizes = new(DescendingComparer <int> .Comparer);
// Start from all low points
foreach (Vector2 <int> lowPoint in lowPoints)
{
// Fill out basin
search.Enqueue(lowPoint);
basin.Add(search.Peek());
while (search.TryDequeue(out Vector2 <int> current))
{
// Add adjacent not already searched
current.Adjacent()
.Where(pos => this.Grid.WithinGrid(pos) && this.Grid[pos] is not 9 && basin.Add(pos))
.ForEach(search.Enqueue);
}
// Add basin size to sizes
sizes.Enqueue(basin.Count);
basin.Clear();
}
// Get three largest sizes
int final = sizes.Dequeue() * sizes.Dequeue() * sizes.Dequeue();
AoCUtils.LogPart2(final);
}
/// <inheritdoc cref="Solver.Run"/>
public override void Run()
{
//Part one
long result = CheckSlope((3, 1));
AoCUtils.LogPart1(result);
//Part two
result *= CheckSlope((1, 1));
result *= CheckSlope((5, 1));
result *= CheckSlope((7, 1));
result *= CheckSlope((1, 2));
AoCUtils.LogPart2(result);
}
public string SolveP2()
{
long[] inputsRaw = AoCUtils.readInputFile(this.GetType().Name.Substring(3)).ToList().Select(x => long.Parse(x)).ToArray();
// Invalid number from previous part
long invalidNum = inputsRaw[539];
Boolean foundWeakness = false;
long runningSum = 0;
long runningCount = 0;
int lastId = 0;
List <long> weaknessList = new List <long>();
// Iterate through list while looking for consecutive numbers that will sum to the target (invalidNum)
for (int ii = 0; ii < inputsRaw.Length; ii++)
{
if (foundWeakness)
{
break;
}
runningSum = 0;
runningCount = 0;
for (int jj = ii; jj < inputsRaw.Length; jj++)
{
if (runningSum > invalidNum)
{
break;
}
runningSum += inputsRaw[jj];
runningCount++;
if (runningSum == invalidNum)
{
lastId = jj;
foundWeakness = true;
break;
}
}
}
// Add to list to get min/max
for (int ii = 0; ii < runningCount; ii++)
{
weaknessList.Add(inputsRaw[lastId - ii]);
}
long weakness = weaknessList.Min() + weaknessList.Max();
return(weakness.ToString());
}
public string SolveP1()
{
long[] inputsRaw = AoCUtils.readInputFile(this.GetType().Name.Substring(3)).ToList().Select(x => long.Parse(x)).ToArray();
int preambleCount = 25;
long invalidNum = long.MinValue;
// Iterate through array starting from the 25th (preamble) element
// On each element, iterate the preceeding 25 elements while checking to see if any two elements sum up to next number
for (int ii = preambleCount - 1; ii < inputsRaw.Length - 1; ii++)
{
Boolean validNext = false;
for (int jj = 0; jj < preambleCount; jj++)
{
// If a previous number is larger than target number, skip (no negatives so impossible to sum)
if (inputsRaw[ii - jj] > inputsRaw[ii + 1])
{
continue;
}
for (int kk = 1; kk < preambleCount; kk++)
{
// If indices are the same or a previous number is larger than target number, skip (no negatives so impossible to sum)
if (jj == kk || inputsRaw[ii - kk] > inputsRaw[ii + 1])
{
continue;
}
if (inputsRaw[ii - jj] + inputsRaw[ii - kk] == inputsRaw[ii + 1])
{
validNext = true;
break;
}
}
if (validNext)
{
break;
}
}
if (!validNext)
{
invalidNum = inputsRaw[ii + 1];
break;
}
}
return(invalidNum.ToString());
}
public string SolveP2_Old()
{
List <int> inputsRaw = AoCUtils.readInputFile(this.GetType().Name.Substring(3)).Select(x => Int32.Parse(x)).ToList();
inputsRaw.Add(0);
inputsRaw.Add(inputsRaw.Max() + 3);
inputsRaw.Sort();
// Makes a dictionary of dependencies
// key: adapter joltage | value: list of valid adapters in list of adapters
Dictionary <int, List <int> > adapterDependencies = new Dictionary <int, List <int> >();
for (int ii = 0; ii < inputsRaw.Count(); ii++)
{
int currMax = inputsRaw[ii] + 3;
List <int> validNums = new List <int>();
int jj = ii + 1;
while (jj < inputsRaw.Count() && inputsRaw[jj] <= currMax)
{
validNums.Add(inputsRaw[jj]);
jj++;
}
adapterDependencies.Add(inputsRaw[ii], validNums);
}
// Use a queue to maintain dependencies
// Enqueue all dependencies of a "node" | Dequeue on processed
// Only viable for small inputs, slow and space consuming
Queue <int> queue = new Queue <int>();
queue.Enqueue(0);
int count = 1;
while (queue.Count > 0)
{
int currAdapter = queue.Dequeue();
if (adapterDependencies[currAdapter].Count() > 1)
{
count += adapterDependencies[currAdapter].Count() - 1;
}
foreach (int currDepends in adapterDependencies[currAdapter])
{
queue.Enqueue(currDepends);
}
}
return(count.ToString());
}
/// <inheritdoc cref="Solver.Run"/>
public override void Run()
{
//Setup
int last = 0;
bool wasFirst = true;
int turn = this.Data.Values.Max();
Dictionary <int, int> previous = new();
//Part 1
GetToTarget(ref turn, ref wasFirst, ref last, FIRST_TARGET, previous);
AoCUtils.LogPart1(last);
//Part 2 (takes a couple seconds but who cares)
GetToTarget(ref turn, ref wasFirst, ref last, SECOND_TARGET, previous);
AoCUtils.LogPart2(last);
}
/// <inheritdoc cref="Solver.Run"/>
public override void Run()
{
//Part one decoding
Dictionary <long, long> memory = new();
Bitmask bitmask = default;
this.Data.ForEach(i => i.Execute(memory, ref bitmask));
AoCUtils.LogPart1(memory.Values.Sum());
//Part two decoding
memory.Clear();
Bitmask bitmaskV2 = default;
this.Data.ForEach(i => i.ExecuteV2(memory, ref bitmaskV2));
AoCUtils.LogPart2(memory.Values.Sum());
}
public string SolveP1()
{
string[] inputsRaw = AoCUtils.readInputFile(this.GetType().Name.Substring(3));
int maxId = 0;
int maxRow = 127;
int maxCol = 7;
foreach (string currLine in inputsRaw)
{
double rowStart = 0;
double rowEnd = maxRow;
for (int ii = 0; ii < 7; ii++)
{
if (currLine[ii] == 'F')
{
rowEnd = rowEnd - Math.Ceiling((rowEnd - rowStart) / 2);
}
else
{
rowStart = rowStart + Math.Ceiling((rowEnd - rowStart) / 2);
}
}
double colStart = 0;
double colEnd = maxCol;
for (int ii = 7; ii < currLine.Length; ii++)
{
if (currLine[ii] == 'L')
{
colEnd = colEnd - Math.Ceiling((colEnd - colStart) / 2);
}
else
{
colStart = colStart + Math.Ceiling((colEnd - colStart) / 2);
}
}
int currId = (int)(rowStart * 8 + colStart);
if (currId > maxId)
{
maxId = currId;
}
}
return(maxId.ToString());
}
/// <inheritdoc cref="Solver.Run"/>
public override void Run()
{
// Check the one window differences
int total = 0;
foreach (int i in 1..Data.Length)
{
if (Data[i] > Data[i - 1])
{
total++;
}
}
AoCUtils.LogPart1(total);
// Check the three window differences
total = 0;
int previous = Data[..3].Sum();
public string SolveP2()
{
string[] inputsRaw = AoCUtils.readInputFile(this.GetType().Name.Substring(3), true);
int runningSum = 0;
int groupMemCount = 0;
Dictionary <char, int> groupAnswers = new Dictionary <char, int>();
foreach (string currLine in inputsRaw)
{
if (currLine == "")
{
int groupSum = 0;
foreach (KeyValuePair <char, int> kvp in groupAnswers)
{
if (kvp.Value == groupMemCount)
{
groupSum++;
}
}
runningSum += groupSum;
groupMemCount = 0;
groupAnswers.Clear();
continue;
}
groupMemCount++;
foreach (char currAns in currLine)
{
if (groupAnswers.ContainsKey(currAns))
{
groupAnswers[currAns]++;
}
else
{
groupAnswers.Add(currAns, 1);
}
}
}
return(runningSum.ToString());
}
public string SolveP2()
{
List <int> inputsRaw = AoCUtils.readInputFile(this.GetType().Name.Substring(3)).Select(x => Int32.Parse(x)).ToList();
inputsRaw.Add(0);
inputsRaw.Add(inputsRaw.Max() + 3);
inputsRaw.Sort();
// Makes a dictionary of dependencies
// key: adapter joltage | value: list of valid adapters in list of adapters
Dictionary <int, List <int> > adapterDependencies = new Dictionary <int, List <int> >();
for (int ii = 0; ii < inputsRaw.Count(); ii++)
{
int currMax = inputsRaw[ii] + 3;
List <int> validNums = new List <int>();
int jj = ii + 1;
while (jj < inputsRaw.Count() && inputsRaw[jj] <= currMax)
{
validNums.Add(inputsRaw[jj]);
jj++;
}
adapterDependencies.Add(inputsRaw[ii], validNums);
}
// Iterate while maintaining a list of possible permutations
// Working backwards, combine the sum of each dependency until the first
// Math approach the only viable method for larger inputs
Dictionary <int, long> permutations = new Dictionary <int, long>();
permutations.Add(inputsRaw.Max(), 1);
for (int ii = inputsRaw.Count() - 2; ii >= 0; ii--)
{
long currCount = 0;
foreach (int depend in adapterDependencies[inputsRaw[ii]])
{
currCount += permutations[depend];
}
permutations.Add(inputsRaw[ii], currCount);
}
return(permutations[0].ToString());;
}
/// <inheritdoc cref="Solver.Run"/>
public override void Run()
{
long max = long.MinValue;
//Go through all permutations of part 1 settings
foreach (long[] perm in AoCUtils.Permutations(part1Phase))
{
//Add phase settings
foreach (int i in..AMPS)
{
this.Data[i].AddInput(perm[i]);
}
//Add input value
this.Data[0].AddInput(0L);
//Run all amplifiers
this.Data.ForEach(amp => amp.Run());
//Get value from last amplifier
max = Math.Max(max, this.Data[^ 1].GetNextOutput());
public Dictionary <string, List <Tuple <string, int> > > createBagOfMadness()
{
string[] inputsRaw = AoCUtils.readInputFile(this.GetType().Name.Substring(3));
Dictionary <string, List <Tuple <string, int> > > bagsOfMadness = new Dictionary <string, List <Tuple <string, int> > >();
foreach (string currLine in inputsRaw)
{
string[] components = currLine.Replace(".", "").Split(new string[] { "contain" }, StringSplitOptions.None);
string mainBag = components[0].Trim();
if (mainBag.EndsWith("s"))
{
mainBag = mainBag.Substring(0, mainBag.Length - 1);
}
if (!bagsOfMadness.ContainsKey(mainBag))
{
List <Tuple <string, int> > contents = new List <Tuple <string, int> >();
string[] contentsRaw = components[1].Split(',');
if (components[1].Trim() == "no other bags")
{
bagsOfMadness.Add(mainBag, new List <Tuple <string, int> >());
}
else
{
foreach (string currContent in contentsRaw)
{
int numInd = currContent.Trim().IndexOf(' ');
int numBag = Int32.Parse(currContent.Trim().Substring(0, numInd));
string bag = currContent.Trim().Substring(numInd + 1);
if (bag.EndsWith("s"))
{
bag = bag.Substring(0, bag.Length - 1);
}
contents.Add(new Tuple <string, int>(bag, numBag));
}
bagsOfMadness.Add(mainBag, contents);
}
}
}
return(bagsOfMadness);
}
/// <inheritdoc cref="Solver.Run"/>
public override void Run()
{
//Start moving the cups
LinkedListNode <int> current = MoveCups(this.Data, PART1_MOVES).NextCircular();
//Get resulting string
StringBuilder builder = new(this.Data.Length - 1);
while (current.Value is not 1)
{
builder.Append(current.Value);
current = current.NextCircular();
}
AoCUtils.LogPart1(builder);
//Create large cups array
int[] largeData = Enumerable.Range(1, AMOUNT).ToArray();
this.Data.CopyTo(largeData, 0);
//Move cups and get result
current = MoveCups(largeData, PART2_MOVES).NextCircular();
AoCUtils.LogPart2((long)current.Value * current.NextCircular().Value);
}
public string SolveP1()
{
string[] inputsRaw = AoCUtils.readInputFile(this.GetType().Name.Substring(3));
int[] instStatus = new int[inputsRaw.Length];
int currLine = 0;
int accumulator = 0;
while (instStatus[currLine] == 0)
{
instStatus[currLine] = 1;
if (inputsRaw[currLine].StartsWith("nop"))
{
currLine++;
continue;
}
string[] components = inputsRaw[currLine].Split(' ');
int multiplier = 1;
if (components[1][0] == '-')
{
multiplier = -1;
}
int num = Int32.Parse(components[1].Substring(1)) * multiplier;
switch (components[0])
{
case "acc":
accumulator += num;
currLine++;
break;
case "jmp":
currLine += num;
break;
}
}
return(accumulator.ToString());
}
/// <inheritdoc cref="Solver.Run"/>
public override void Run()
{
(this.VM[1], this.VM[2]) = (12L, 2L);
this.VM.Run();
AoCUtils.LogPart1(this.VM[0]);
foreach (int noun in..MAX)
{
foreach (int verb in..MAX)
{
this.VM.Reset();
(this.VM[1], this.VM[2]) = (noun, verb);
this.VM.Run();
if (this.VM[0] is not TARGET)
{
continue;
}
AoCUtils.LogPart2((100 * noun) + verb);
return;
}
}
}
public string SolveP1()
{
List <int> inputsRaw = AoCUtils.readInputFile(this.GetType().Name.Substring(3)).Select(x => Int32.Parse(x)).ToList();
inputsRaw.Sort();
int joltDiff1 = 0;
int joltDiff3 = 0;
int currentJolt = 0;
// Since maximum number of adapters needs to be used, sort list first
// Iterate and make sure each adapter is "valid" (at most three away)
// while counting the instances of diff1 and diff3
foreach (int iterJolt in inputsRaw)
{
int currDiff = iterJolt - currentJolt;
if (currDiff <= 3)
{
switch (currDiff)
{
case 1:
joltDiff1++;
break;
case 3:
joltDiff3++;
break;
}
currentJolt = iterJolt;
}
}
// Plus one to diff3 in order to account for device adapter
int result = joltDiff1 * (joltDiff3 + 1);
return(result.ToString());
}
