public static void Run() { List <string> linesInput = File.ReadAllLines(Util.ReadFromInputFolder(21)).ToList(); int controlPointer = Convert.ToInt32(linesInput.First().Between("#ip ")); linesInput.RemoveAt(0); int instructionPosition = 0; foreach (string line in linesInput) { string[] lineInstruc = line.Split(' '); Tuple <string, int[]> instruct = new Tuple <string, int[]>(lineInstruc[0], new int[6]); instruct.Item2[1] = Convert.ToInt32(lineInstruc[1]); instruct.Item2[2] = Convert.ToInt32(lineInstruc[2]); instruct.Item2[3] = Convert.ToInt32(lineInstruc[3]); dctInstructions.Add(instructionPosition, instruct); instructionPosition++; } Dictionary <int, int> uniqueValues = new Dictionary <int, int>(); bool printPartOne = false; int indexToWatch = 0; var keyInstruction = dctInstructions[28]; if (keyInstruction.Item1 == "eqrr" && (keyInstruction.Item2[1] == 0 || keyInstruction.Item2[2] == 0)) { indexToWatch = Math.Max(keyInstruction.Item2[1], keyInstruction.Item2[2]); } Console.WriteLine("Computing both parts, part 2 takes a while"); while (true) { if (baseRegister[controlPointer] == 28) { if (printPartOne == false) { Console.WriteLine("PART 1: " + baseRegister[indexToWatch]); printPartOne = true; } if (uniqueValues.ContainsKey(baseRegister[indexToWatch]) == false) { uniqueValues.Add(baseRegister[indexToWatch], baseRegister[indexToWatch]); } else { Console.WriteLine("PART 2: " + uniqueValues.Last().Key); break; } } var currRegister = dctInstructions[baseRegister[controlPointer]]; ExecuteInstruction(currRegister.Item1, currRegister.Item2); baseRegister[controlPointer] = (baseRegister[controlPointer] + 1); } Console.ReadLine(); }
public static void Run() { string[] linesInput = File.ReadAllLines(Util.ReadFromInputFolder(7)); string problem1Solution = Problem1(linesInput); Console.WriteLine(problem1Solution); Console.WriteLine(Problem2(linesInput, problem1Solution)); }
public static void Run() { string[] linesInput = File.ReadAllLines(Util.ReadFromInputFolder(8)); QuirkNode baseNode; Console.WriteLine(Problem1(linesInput, out baseNode)); Console.WriteLine(Problem2(baseNode)); }
public static void Run() { string[] linesInput = File.ReadAllLines(Util.ReadFromInputFolder(24)); ParseInput(linesInput); int minimumBoostToWin = 0; bool keepBoosting = true; List <UnitGroup> copyOfCombatants = lstCombatants.ConvertAll(Unit => new UnitGroup(Unit)); int staleMateLimit = 15; while (keepBoosting) { int staleMateCount = 0; lstCombatants = copyOfCombatants.ConvertAll(Unit => new UnitGroup(Unit)); lstCombatants.Where(r => r.faction == Faction.InmuneSystem).ForEach(r => r.attackPower = r.attackPower + minimumBoostToWin); int lastTurnTotal = lstCombatants.Sum(r => r.unitsAmount); bool gameFinished = false; while (gameFinished == false) { TargetSelectionLogic(); CombatLogic(); gameFinished = EndCondition(); if (lastTurnTotal == lstCombatants.Sum(r => r.unitsAmount)) { if (staleMateCount == staleMateLimit) { break; } else { staleMateCount++; } } else { lastTurnTotal = lstCombatants.Sum(r => r.unitsAmount); } } if (minimumBoostToWin == 0) { Console.WriteLine("PART 1: " + lstCombatants.Sum(r => r.unitsAmount)); } if (lstCombatants.All(r => r.faction == Faction.InmuneSystem)) { Console.WriteLine("DEER SURVIVES, Boost: " + minimumBoostToWin); Console.WriteLine("PART 2: " + lstCombatants.Sum(r => r.unitsAmount)); keepBoosting = false; break; } minimumBoostToWin += 1; } }
public static void Run() { dctMap.Add(new Point(500, 500), '.'); GetAllSurroundings(player); string linesInput = File.ReadAllLines(Util.ReadFromInputFolder(20))[0]; foreach (char C in linesInput) { if (C == '(') { parenthesisStack.Push('('); lastPositionStack.Push(player); } else if (C == ')') { parenthesisStack.Pop(); player = lastPositionStack.Pop(); } else if (C == '|') { player = lastPositionStack.Peek(); } else { Logic(C); GetAllSurroundings(player); } } ClearUnknown(); // Using DAY15 Pathfinding, since doors and rooms both count as open spaces we need to // cut the total of cost in half Dictionary <Point, PrevPoint> dctPoints = new Dictionary <Point, PrevPoint>(); PathFinding(new Point(500, 500), dctPoints, 0); var elementor = (dctPoints.OrderByDescending(r => r.Value.cost).First().Value.cost) / 2; Console.WriteLine("PART 1: " + elementor); // Unlike the maximum cost room, there might be multiple in this category and dividing by 2 // could produce off by 1 errors so we will have to count them manually var prelimList = dctPoints.Where(r => r.Value.cost >= 2000).ToList(); int properRoomCount = 0; foreach (var prelim in prelimList) { if (dctMap[prelim.Key] == '.') { properRoomCount++; } } Console.WriteLine("PART 2: " + properRoomCount); }
public static void Run() { string[] linesInput = File.ReadAllLines(Util.ReadFromInputFolder(9)); string INPUT = linesInput[0]; var inputArray = INPUT.Split(' '); int numberOfPlayers = Convert.ToInt32(inputArray[0]); long marbles = Convert.ToInt32(inputArray[6]); Console.WriteLine(Problem1(numberOfPlayers, marbles)); Console.WriteLine(Problem2(numberOfPlayers, marbles)); }
public static void Run() { string[] linesInput = File.ReadAllLines(Util.ReadFromInputFolder(25)); foreach (string line in linesInput) { string[] pPoint = line.Split(','); long pX = Convert.ToInt64(pPoint[0].Trim()); long pY = Convert.ToInt64(pPoint[1].Trim()); long pZ = Convert.ToInt64(pPoint[2].Trim()); long pA = Convert.ToInt64(pPoint[3].Trim()); stars.Add(new fPoint(pX, pY, pZ, pA)); } while (stars.Count() > 0) { var leStar = stars.First(); if (constellations.Count == 0) { constellations.Add(new List <fPoint>()); constellations.First().Add(leStar); } else { var starGroup = constellations.Where(r => r.Any(wr => ManhattanDist(leStar, wr) <= 3)); if (starGroup.Count() > 0) { if (starGroup.Count() > 1) { var leJoinFactor = starGroup.First(); foreach (var littleStar in starGroup.Skip(1)) { leJoinFactor.AddRange(littleStar); littleStar.Clear(); } leJoinFactor.Add(leStar); } else { starGroup.Last().Add(leStar); } } else { constellations.Add(new List <fPoint>()); constellations.Last().Add(leStar); } } stars.RemoveAt(0); } Console.WriteLine("PART 1: " + constellations.Where(r => r.Count() > 0).Count()); }
public static void Run(string path = null) { List <string> linesInput = File.ReadAllLines(Util.ReadFromInputFolder(13)).ToList(); int Height = linesInput.Count(); int Width = linesInput.OrderByDescending(r => r.Length).First().Length; int leCartID = 1; char[,] grid = new char[Width, Height]; int j = 0; foreach (string line in linesInput) { for (int w = 0; w < line.Count(); w++) { if (isCart(line[w])) { lstCarts.Add(new Minecart(leCartID, w, j, (Direction)line[w])); if ((Direction)line[w] == Direction.Down || (Direction)line[w] == Direction.Up) { grid[w, j] = '|'; } else { grid[w, j] = '-'; } leCartID++; } else { grid[w, j] = line[w]; } } j++; } while (true) { foreach (Minecart cart in lstCarts.OrderBy(r => r.positionX)) { cart.moveAhead(grid); } Ticks++; if (lstCarts.Count == 1) { //Console.WriteLine("LAST CART: [" + lstCarts.First().positionX + "][" + lstCarts.First().positionY + "]"); Console.WriteLine("PART 2: " + lstCarts.First().positionX + "," + lstCarts.First().positionY); break; } } }
public static void Run() { string[] linesInput = File.ReadAllLines(Util.ReadFromInputFolder(23)); foreach (string line in linesInput) { string[] posCoords = line.Between("<", ">").Split(','); long signalStrength = Convert.ToInt64(line.Between("r=").Trim()); long xPoint = Convert.ToInt64(posCoords[0]); long yPoint = Convert.ToInt64(posCoords[1]); long zPoint = Convert.ToInt64(posCoords[2]); fPoint BotPosition = new fPoint(xPoint, yPoint, zPoint); dctNanoBots.Add(BotPosition, signalStrength); } var strongestNano = dctNanoBots.OrderByDescending(r => r.Value).First(); Console.WriteLine("Part 1: " + dctNanoBots.Where(r => ManhattanDist(r.Key, strongestNano.Key) <= strongestNano.Value).Count()); Console.WriteLine("Loading part 2, should take 1 minute"); // Reduces the lookout on the points to make complexity manageable // Finds best match for this small region // Amplifies the result to set it up for the next factor fPoint lePoint = new fPoint(); for (int factor = 10000000; factor >= 1; factor /= 10) { lePoint = OperateDict(reduceDict(factor), lePoint); lePoint.X *= 10; lePoint.Y *= 10; lePoint.Z *= 10; } string answer = ManhattanDist(new fPoint(0, 0, 0), lePoint).ToString(); answer = answer.Remove(answer.Length - 1); //remove last character for the last extra computation Console.WriteLine("Part 2: " + answer); }
public static void Run() { string[] linesInput = File.ReadAllLines(Util.ReadFromInputFolder(2)); Console.WriteLine(Problem1(linesInput)); Console.WriteLine(Problem2(linesInput)); }
public static void Run() { string[] linesInput = File.ReadAllLines(Util.ReadFromInputFolder(18)); width = linesInput[0].Length; height = linesInput.Count(); int j = 0; foreach (string line in linesInput) { for (int w = 0; w < line.Count(); w++) { dctMap.Add(new Point(w, j), line[w]); } j++; } int Minutes = 1000000000; for (int i = 0; i < Minutes; i++) { dctFutureMap.Clear(); foreach (var element in dctMap) { MorphLogic(element.Key); } var futureGen = new Dictionary <Point, char>(dctFutureMap); dctMap = futureGen; string uniqueDct = DctAsString(); if (dctRepetitions.ContainsKey(uniqueDct) == false) { dctRepetitions.Add(uniqueDct, i); } else { int minInitial = dctRepetitions[uniqueDct]; int currRepetition = i; Console.WriteLine("Repetition detected at: " + i); Console.WriteLine("Originally found first at: " + minInitial); Console.WriteLine("Cycles each: " + (i - minInitial)); //Detecting which repetition cycle corresponds to the target //offset by -1, since 0 start index and we breakin' for (int w = minInitial; w < i; w++) { if ((Minutes - w) % (i - minInitial) == 0) { var leValue = dctRepetitions.Single(R => R.Value == w - 1).Key.ToList(); Console.WriteLine("PART 2: " + leValue.Count(r => r == lumberyard) * leValue.Count(r => r == trees)); } } break; } } //offset by -1, since 0 start index int lumberValue = dctRepetitions.Single(R => R.Value == 9).Key.ToList().Count(r => r == lumberyard); int woodValue = dctRepetitions.Single(R => R.Value == 9).Key.ToList().Count(r => r == trees); Console.WriteLine("PART 1: " + (lumberValue * woodValue)); }
public static void Run() { List <string> linesInputFirst = File.ReadAllLines(Util.ReadFromInputFolder("16_A")).Where(arg => !string.IsNullOrWhiteSpace(arg)).ToList(); List <string> linesInputSecond = File.ReadAllLines(Util.ReadFromInputFolder("16_B")).ToList(); int countBehavior = 0; string[] opBase = new string[] { "addi", "addr", "bani", "banr", "bori", "borr", "eqir", "eqri", "eqrr", "gtir", "gtri", "gtrr", "muli", "mulr", "seti", "setr" }; for (int i = 0; i < 16; i++) { opCodeDict.Add(i, new List <string>(opBase)); } //part 1 while (linesInputFirst.Count > 0) { string line1 = linesInputFirst.First(); string line2 = linesInputFirst.Skip(1).First(); string line3 = linesInputFirst.Skip(2).First(); linesInputFirst.RemoveRange(0, 3); string[] lin1array = line1.Between("[", "]").Split(','); string[] lin3array = line3.Between("[", "]").Split(','); int[] input = Array.ConvertAll(lin1array, s => Convert.ToInt32(s.Trim())); int[] instruction = Array.ConvertAll(line2.Split(' '), s => Convert.ToInt32(s.Trim())); int[] expectedOutput = Array.ConvertAll(lin3array, s => Convert.ToInt32(s.Trim())); FigureOutCodes(input, instruction, expectedOutput); if (part1Check(input, instruction, expectedOutput)) { countBehavior++; } } //part 2 figure the registers while (opCodeDict.Any(r => r.Value.Count > 1)) { var orderedCandidates = opCodeDict.OrderBy(r => r.Value.Count); foreach (var pair in orderedCandidates) { if (pair.Value.Count == 1) { opCodeDict.Where(r => r.Key != pair.Key).AsParallel().ForAll(r => r.Value.RemoveAll(w => w == pair.Value.First())); } } } //part 2 run program int[] baseRegister = new int[4] { 0, 0, 0, 0 }; foreach (string line in linesInputSecond) { int[] instruction = Array.ConvertAll(line.Split(' '), s => Convert.ToInt32(s.Trim())); string opCode = opCodeDict[instruction[0]].First(); if (opCode == "addi") { baseRegister = AsmEmu.addi(baseRegister, instruction); } else if (opCode == "addr") { baseRegister = AsmEmu.addr(baseRegister, instruction); } else if (opCode == "bani") { baseRegister = AsmEmu.bani(baseRegister, instruction); } else if (opCode == "banr") { baseRegister = AsmEmu.banr(baseRegister, instruction); } else if (opCode == "bori") { baseRegister = AsmEmu.bori(baseRegister, instruction); } else if (opCode == "borr") { baseRegister = AsmEmu.borr(baseRegister, instruction); } else if (opCode == "eqir") { baseRegister = AsmEmu.eqir(baseRegister, instruction); } else if (opCode == "eqri") { baseRegister = AsmEmu.eqri(baseRegister, instruction); } else if (opCode == "eqrr") { baseRegister = AsmEmu.eqrr(baseRegister, instruction); } else if (opCode == "gtir") { baseRegister = AsmEmu.gtir(baseRegister, instruction); } else if (opCode == "gtri") { baseRegister = AsmEmu.gtri(baseRegister, instruction); } else if (opCode == "gtrr") { baseRegister = AsmEmu.gtrr(baseRegister, instruction); } else if (opCode == "muli") { baseRegister = AsmEmu.muli(baseRegister, instruction); } else if (opCode == "mulr") { baseRegister = AsmEmu.mulr(baseRegister, instruction); } else if (opCode == "seti") { baseRegister = AsmEmu.seti(baseRegister, instruction); } else if (opCode == "setr") { baseRegister = AsmEmu.setr(baseRegister, instruction); } else { Debug.Assert(false); } } Console.WriteLine("PART 1: " + countBehavior); Console.WriteLine("PART 2: " + baseRegister[0] + " " + baseRegister[1] + " " + baseRegister[2] + " " + baseRegister[3]); }
public static void Run() { string[] linesInput = File.ReadAllLines(Util.ReadFromInputFolder(10)); List <SkyLight> lstLights = new List <SkyLight>(); Point maxPoint = new Point(999999, 999999); foreach (string line in linesInput) { var rawInfoPosition = line.Between("tion=<", "> velo"); string[] positionArray = rawInfoPosition.Split(','); var rawInfoSpeed = line.Between("velocity=<", ">"); string[] speedArray = rawInfoSpeed.Split(','); Point startPosition = new Point(Convert.ToInt32(positionArray[0].Trim()), Convert.ToInt32(positionArray[1].Trim())); Point speed = new Point(Convert.ToInt32(speedArray[0].Trim()), Convert.ToInt32(speedArray[1].Trim())); lstLights.Add(new SkyLight(startPosition, speed)); } int seconds = 0; while (true) { foreach (SkyLight light in lstLights) { light.Tick(); } int currentMaxX = lstLights.Max(r => r.position.X); int currentMaxY = lstLights.Max(r => r.position.Y); if (currentMaxX < maxPoint.X && currentMaxY < maxPoint.Y) { maxPoint = new Point(currentMaxX, currentMaxY); } else { Console.WriteLine(seconds); break; } seconds++; /* * if (lstLights.GroupBy(r => r.position.X).Where(w => w.Count() >= 10).Count() >= 10) * { * leCondition = false; * Console.WriteLine(seconds); * }*/ } foreach (SkyLight light in lstLights) { light.TickBackwards(); } int minX = lstLights.Min(r => r.position.X); int minY = lstLights.Min(r => r.position.Y); int maxX = lstLights.Max(r => r.position.X); int maxY = lstLights.Max(r => r.position.Y); StringBuilder sb = new StringBuilder(); for (int j = minY; j < maxY + 1; j++) { sb.Clear(); for (int i = minX; i < maxX + 1; i++) { if (lstLights.Where(r => r.position.X == i && r.position.Y == j).Count() > 0) { sb.Append('#'); } else { sb.Append('.'); } } Console.WriteLine(sb.ToString()); } }
public static void Run() { List <string> linesInput = File.ReadAllLines(Util.ReadFromInputFolder(19)).ToList(); int controlPointer = Convert.ToInt32(linesInput.First().Between("#ip ")); linesInput.RemoveAt(0); int instructionPosition = 0; foreach (string line in linesInput) { string[] lineInstruc = line.Split(' '); Tuple <string, int[]> instruct = new Tuple <string, int[]>(lineInstruc[0], new int[6]); instruct.Item2[1] = Convert.ToInt32(lineInstruc[1]); instruct.Item2[2] = Convert.ToInt32(lineInstruc[2]); instruct.Item2[3] = Convert.ToInt32(lineInstruc[3]); dctInstructions.Add(instructionPosition, instruct); instructionPosition++; } while (true) { if (dctInstructions.ContainsKey(baseRegister[controlPointer]) == false) { break; } var currRegister = dctInstructions[baseRegister[controlPointer]]; ExecuteInstruction(currRegister.Item1, currRegister.Item2); baseRegister[controlPointer] = (baseRegister[controlPointer] + 1); } Console.WriteLine("PART 1: " + baseRegister[0] + " " + baseRegister[1] + " " + baseRegister[2] + " " + baseRegister[3] + " " + baseRegister[4] + " " + baseRegister[5]); //Find out which register do i need the sum of factors for int chosenRegistry = 0; for (int i = 1; i < 6; i++) { if (baseRegister[0] == Util.divSum(baseRegister[i])) { chosenRegistry = i; break; } } baseRegister = new int[6]; baseRegister[0] = 1; for (int i = 0; i < 1000; i++) { if (dctInstructions.ContainsKey(baseRegister[controlPointer]) == false) { break; } var currRegister = dctInstructions[baseRegister[controlPointer]]; ExecuteInstruction(currRegister.Item1, currRegister.Item2); baseRegister[controlPointer] = (baseRegister[controlPointer] + 1); } Console.WriteLine("PART 2: " + Util.divSum(baseRegister[chosenRegistry])); }
public static bool SimulateBattle(int elvenPower = 3) { lstUnits = new List <Unit>(); FinishGame = false; string[] linesInput = File.ReadAllLines(Util.ReadFromInputFolder(15)); int Height = linesInput.Count(); int Width = linesInput.OrderByDescending(r => r.Length).First().Length; grid = new char[Width, Height]; int j = 0; int ID = 1; foreach (string line in linesInput) { for (int w = 0; w < line.Count(); w++) { if (line[w] == 'G' || line[w] == 'E') { grid[w, j] = '.'; if (line[w] == 'G') { lstUnits.Add(new Unit(ID, new Point(w, j), Faction.Goblin)); } else { lstUnits.Add(new Unit(ID, new Point(w, j), Faction.Elf, elvenPower)); } ID++; } else { grid[w, j] = line[w]; } } j++; } int originalAmountOfElves = lstUnits.Where(r => r.faction == Faction.Elf).Count(); int Round = 0; PrintMap(Width, Height, grid); while (FinishGame == false) { var orderedUnits = lstUnits.OrderBy(r => r.Position.Y).ThenBy(r => r.Position.X); foreach (Unit soldier in orderedUnits) { if (soldier.HP <= 0) { continue; } Logic(soldier); if (FinishGame == true) { break; } } PrintMap(Width, Height, grid); if (FinishGame == false) { Round++; } } if (lstUnits.Where(r => r.faction == Faction.Elf).Count() == originalAmountOfElves) { Console.WriteLine("TRUE: " + lstUnits.Sum(r => r.HP) * Round + " | ElvenPower=" + elvenPower); return(true); } else { Console.WriteLine("FALSE: " + lstUnits.Sum(r => r.HP) * Round + " | ElvenPower=" + elvenPower); return(false); } }
public static void Run() { string[] linesInput = File.ReadAllLines(Util.ReadFromInputFolder(3)); Problem1(linesInput); Problem2(linesInput); }
public static void Run(string path = null) { StringBuilder sb = new StringBuilder(); List <string> linesInput; if (path == null) { linesInput = File.ReadAllLines(Util.ReadFromInputFolder(12)).ToList(); } else { linesInput = File.ReadAllLines(path).ToList(); } string baseGeneration = linesInput[0].Between("initial state: "); //Prepare initial state int potCounter = 0; List <PotPlant> lstPots = new List <PotPlant>(); foreach (char A in baseGeneration) { lstPots.Add(new PotPlant(potCounter, A)); potCounter++; } //Get rid of consumed lines linesInput.RemoveAt(0); linesInput.RemoveAt(0); Dictionary <string, string> producePlantsCombo = new Dictionary <string, string>(); Dictionary <string, string> killPlantsCombo = new Dictionary <string, string>(); LinkedList <long> SameDifferences = new LinkedList <long>(); long mysteryConstant = 0; //Get sprout n wither combinations foreach (string line in linesInput) { //#.... => . string[] initialInput = line.Split(' '); string potCombi = initialInput[0]; //Pot Combination string producesPlant = initialInput[2]; //Produces plant or not if (producesPlant == "#") { producePlantsCombo.Add(potCombi, potCombi); } else { killPlantsCombo.Add(potCombi, potCombi); } } LinkedList <PotPlant> llBaseGeneration = new LinkedList <PotPlant>(lstPots); var firstElement = llBaseGeneration.First; //Extra room left n' right for (int i = -20; i < 0; i++) { llBaseGeneration.AddBefore(firstElement, new PotPlant(i)); } int lastPotNumber = llBaseGeneration.Last().potNumber; for (int i = lastPotNumber + 1; i < lastPotNumber + 1000; i++) { llBaseGeneration.AddLast(new PotPlant(i)); } for (long Gens = 1; Gens < 501; Gens++) { var lastGeneration = llBaseGeneration; LinkedList <PotPlant> upComingGeneration = new LinkedList <PotPlant>(); var currentNode = llBaseGeneration.First; for (int i = 0; i < llBaseGeneration.Count; i++) { string plantConfig = ConstructPotStructure(currentNode); if (producePlantsCombo.ContainsKey(plantConfig)) { PotPlant futurePlant = new PotPlant(currentNode.Value.potNumber, '#'); upComingGeneration.AddLast(futurePlant); } else { PotPlant futurePlant = new PotPlant(currentNode.Value.potNumber, '.'); upComingGeneration.AddLast(futurePlant); } currentNode = currentNode.Next; } long prevDif = upComingGeneration.Where(r => r.plant == '#').Sum(w => w.potNumber) - llBaseGeneration.Where(r => r.plant == '#').Sum(w => w.potNumber); SameDifferences.AddLast(prevDif); if (SameDifferences.Any(r => r != prevDif)) { SameDifferences.Clear(); } else { // After some point, the output seems displaced on a constant basis forever // Mystery = TOTAL - (sameDif * Gen) // so // TOTAL = Mystery + (sameDif * Gen) if (SameDifferences.Count >= 4) { long total = upComingGeneration.Where(r => r.plant == '#').Sum(w => w.potNumber); mysteryConstant = total - (SameDifferences.First() * Gens); long part2Result = mysteryConstant + (SameDifferences.First() * 50000000000); Console.WriteLine("part 2: " + part2Result); break; } } llBaseGeneration = upComingGeneration; if (Gens == 20) { Console.WriteLine("part 1: " + llBaseGeneration.Where(r => r.plant == '#').Sum(w => w.potNumber)); } } Console.ReadLine(); }
public static void Run() { string[] linesInput = File.ReadAllLines(Util.ReadFromInputFolder(17)); //build map foreach (string line in linesInput) { //x=571, y=1864..1875 //y=1700, x=570..588 int xValueFrom = -1; int xValueTo = -1; int yValueFrom = -1; int yValueTo = -1; string[] splitLine = line.Split(','); string leftValue = splitLine[0].Substring(2).Trim(); if (splitLine[0][0] == 'x') { xValueFrom = Convert.ToInt32(leftValue); string[] rightValues = splitLine[1].Trim().Substring(2).Split('.'); yValueFrom = Convert.ToInt32(rightValues[0]); yValueTo = Convert.ToInt32(rightValues[2]); for (int y = yValueFrom; y < yValueTo + 1; y++) { if (dctMap.ContainsKey(new Point(xValueFrom, y)) == false) { dctMap.Add(new Point(xValueFrom, y), '#'); } } } else { yValueFrom = Convert.ToInt32(leftValue); string[] rightValues = splitLine[1].Trim().Substring(2).Split('.'); xValueFrom = Convert.ToInt32(rightValues[0]); xValueTo = Convert.ToInt32(rightValues[2]); for (int x = xValueFrom; x < xValueTo + 1; x++) { if (dctMap.ContainsKey(new Point(x, yValueFrom)) == false) { dctMap.Add(new Point(x, yValueFrom), '#'); } } } } minYBound = dctMap.Min(r => r.Key.Y); maxYBound = dctMap.Max(r => r.Key.Y); Queue <Point> waterFlow = new Queue <Point>(); int lastHydroCount = 0; int sameCounter = 0; bool keepGoing = true; while (keepGoing) { waterFlow.Enqueue(new Point(500, minYBound - 1)); while (waterFlow.Count() > 0) { Flow(waterFlow); //Console.WriteLine(hydroCount()); <--really slows it down } if (lastHydroCount == hydroCount()) { sameCounter++; } else { sameCounter = 0; } lastHydroCount = hydroCount(); if (sameCounter >= 3) { keepGoing = false; Console.WriteLine("PART 1: " + lastHydroCount); ClearWet(); Console.WriteLine("PART 2: " + hydroCount()); } } }