Day 6 Part A

Once you decode the problem, it essentially comes down to the number of unique answered questions within a group. Easiest solution (to be of my knowledge here) is to a use a HashSet, which will only allow unique values in.

Following the pattern to an earlier puzzle in the week, essentially a loop to store the answers and then add to the counter when a blank line is found. Also, note to handle the final line which probably isn’t ended with a blank line. Again, might be a nicer way to do this with LINQ.

So onto the Tests (always start with tests! – whether solving problems in spare time, or on paid time):

     [TestMethod]
     public void ExampleInput()
     {
         var inputList = new List<string>()
         {
             "abc", "", "a", "b", "c", "", "ab", "ac", "", 
              "a", "a", "a", "a", "", "b"
         };

         int sumOfCounts = new Day6PartA().GetSumOfAnswers(inputList);
         Assert.AreEqual(11, sumOfCounts);
     }

     [TestMethod]
     public void FileInput()
     {
         var filename = @"C:\_path_\Day6\input.txt";
         var inputList = File.ReadAllLines(filename).ToList();
         int sumOfCounts = new Day6PartA().GetSumOfAnswers(inputList);
         Assert.AreEqual(6443, sumOfCounts);
     }

The implementation then follows as this:

     public int GetSumOfAnswers(List<string> input)
     {
         int sum = 0;
         HashSet<char> charactersFound = new HashSet<char>();

         foreach (var line in input)
         {
             if (line.Trim().Length == 0)
             {
                 // End of processing, so process here:
                 sum += charactersFound.Count;
                 charactersFound = new HashSet<char>();
             }
             else
             {
                 // Need to process this line, 
                 // splitting into characters and then adding to the set                 
                 // Set should handle not adding duplicates automatically.                 
                 // Could probably do this with LINQ.
                 for (int i = 0; i < line.Length; i++)
                 {
                     charactersFound.Add(line[i]);
                 }
             }
         }

         // Don't forgot the final line!
         sum += charactersFound.Count;
         return sum;
     }

Day 6 Part B

So Part B is all about finding the consistent entries from the entire group, which makes it a little more interesting. With a few other commitments I quickly churned the following solution out, but it felt a bit over worked and I thought there might be a nicer way.

     public int GetAnswersGivenByEveryoneInGroup(List<string> input)
     {
         int sum = 0;
         List<string> tempCollection = new List<string>();

         foreach (var line in input)
         {
             if (line.Trim().Length == 0)
             {
                 if (tempCollection.Count == 1)
                 {
                     sum += tempCollection[0].Length;
                 }
                 else
                 {
                     Dictionary<char, int> countOfChars = new Dictionary<char, int>();
                     foreach (var tempLine in tempCollection)
                     {
                         for (int i = 0; i < tempLine.Length; i++)
                         {
                             var currentValue = countOfChars.GetValueOrDefault(tempLine[i], 0);
                             countOfChars[tempLine[i]] = ++currentValue;
                         }
                     }

                     foreach (var entry in countOfChars)
                     {
                         if (entry.Value == tempCollection.Count)
                         {
                             sum++;
                         }
                     }
                 }
                 tempCollection = new List<string>();
             }
             else
             {
                 tempCollection.Add(line);
             }
         }

         if (tempCollection.Count == 1)
         {
             sum += tempCollection[0].Length;
         }
         else
         {
             Dictionary<char, int> countOfChars = new Dictionary<char, int>();

             foreach (var tempLine in tempCollection)
             {
                 for (int i = 0; i < tempLine.Length; i++)
                 {
                     var currentValue = countOfChars.GetValueOrDefault(tempLine[i], 0);
                     countOfChars[tempLine[i]] = ++currentValue;
                 }
             }

             foreach (var entry in countOfChars)
             {
                 if (entry.Value == tempCollection.Count)
                 {
                     sum++;
                 }
             }
         }
         return sum;
     }

So it works, but there are loops within loops within loops, and its quite length (ok, I could refactor out to helper methods by still).

After a little break I came back to it, and came up with the following solution which only adds consistently appearing characters from each pass, and I think reads a bit better:

     public int GetAnswersGivenByEveryoneInGroupRefactor(List<string> input)
     {
         int sum = 0;
         string buildingList = string.Empty;
         var isFirstPass = true;

         foreach (var line in input)
         {
             if (line.Trim().Length == 0)
             {
                 sum += buildingList.Length;
                 buildingList = string.Empty;
                 isFirstPass = true;
             }
             else
             {
                 if (isFirstPass)
                 {
                     buildingList = line;
                     isFirstPass = false;
                 }
                 else
                 {
                     var tempNewList = new StringBuilder();

                     for (int i = 0; i < line.Length; i++)
                     {
                         if (buildingList.Contains(line[i]))
                         {
                             tempNewList.Append(line[i]); 
                         }
                     }

                     buildingList = tempNewList.ToString();
                 }
             }
         }

         sum += buildingList.Length;
         return sum;
     }

But I think this can still be improved on, using something like HashSet or Intersect. Indeed, I carried on for a bit longer and refactored to use LINQ Intersect, which now makes the code read as:

     public int GetAnswersGivenByEveryoneInGroupRefactor(List<string> input)
     {
         int sum = 0;
         string buildingList = string.Empty;
         var isFirstPass = true;

         foreach (var line in input)
         {
             if (line.Trim().Length == 0)
             {
                 sum += buildingList.Length;
                 buildingList = string.Empty;
                 isFirstPass = true;
             }
             else
             {
                 if (isFirstPass)
                 {
                     buildingList = line;
                     isFirstPass = false;
                 }
                 else
                 {
                     var buildingListArray = buildingList.ToCharArray();
                     var lineArray = line.ToCharArray();
                     var intersect = buildingListArray.Intersect(lineArray).ToArray();
                     buildingList = String.Join("", intersect);
                 }
             }
         }
         sum += buildingList.Length;
         return sum;
     }

I did look at if it would be possible drop the ‘isFirstPass’ boolean, but removing it stopped things from passing. On reflection I suspect its because there is a chance the ‘buildingList’ parameters empties through processing.

Day 5 Part A

So once overcoming the initial issue of understanding the problem, this is essentially removing either the top half of a range, or the bottom half, depending on the next value in the string.

I started by keeping things simple, and building confidence, so implemented 2 tests for determining Rows and Columns. This might have ended up being overkill for the final solution, and these methods wouldn’t need to be public for the longer term, but as a starting point it seemed sensible.

     [DataTestMethod]
     [DataRow("FBFBBFF", 44)]
     [DataRow("BFFFBBF", 70)]
     [DataRow("FFFBBBF", 14)]
     [DataRow("BBFFBBF", 102)]
     public void TestForRows(string input, int expectedRowId)
     {
         var rowId = new Day5PartA().GetRow(input);
         Assert.AreEqual(expectedRowId, rowId);
     }

     [DataTestMethod]
     [DataRow("RLR", 5)]
     [DataRow("RRR", 7)]
     [DataRow("RRR", 7)]
     [DataRow("RLL", 4)]
     public void TestForColumns(string input, int expectedColumnId)
     {
         var rowId = new Day5PartA().GetColumn(input);
         Assert.AreEqual(expectedColumnId, rowId);
     }

The 2 methods are identical, and could be refactored into a single method, but I decided to leave them as-is for now (a general tendency I see in S/W development is an over eagerness to implemented generic methods, which then quickly become convoluted with if…else.. and other not required complexity). I tend to stick to the principle of 3 or 5 – once its been implemented that many times, then refactor and only the common pieces.

     public int GetRow(string input)
     {
         int lowerBound = 0;
         int upperBound = 127;

         for (int i = 0; i < input.Length; i++)
         {
             var diff = (upperBound - lowerBound + 1) / 2;

             if (input[i] == 'F')
             {
                 upperBound -= diff;
             }
             else
             {
                 lowerBound += diff;
             }
         }

         if (input[6] == 'F')
         {
             return lowerBound;
         }
         return upperBound;
     }

     public int GetColumn(string input)
     {
         int lowerBound = 0;
         int upperBound = 7;

         for (int i = 0; i < input.Length; i++)
         {
             var diff = (upperBound - lowerBound + 1) / 2;

             if (input[i] == 'L')
             {
                 upperBound -= diff;
             }
             else
             {
                 lowerBound += diff;
             }
         }

         if (input[2] == 'L')
         {
             return lowerBound;
         }

         return upperBound;
     }

With in place, the GetSeatId method is a simple call of to these 2 methods and then doing the calculation:

     public int GetSeatId(string input)
     {
         var row = GetRow(input.Substring(0, 7));
         var column = GetColumn(input.Substring(7));

         return (row * 8) + column;
     }

Day 5 Part B

The hardest part of this question was working out what the question actually was. Finally I figured out it was essentially saying the range of Seat IDs is sequential, and there is a Seat ID missing – find it. NB. The range does not start at zero, so you need to handle that.

There are a few ways to implement this, but personally I find the following implementation using LINQ simplest to read (which is the important aspect of code, IMHO).

     public int MissingSeatId(List<int> seatInput)
     {
         var lowestSeatId = seatInput.Min();
         var highestSeatId = seatInput.Max();
         var missingSeatIds = Enumerable.Range(lowestSeatId, highestSeatId).Except(seatInput);

         return missingSeatIds.ElementAt(0);
     }

So onto Day 4, and a little bit quicker today, just because it’s a Friday.

Day 4 Part A

I’m sure there must be a nicer way to do this, but went for quick and dirty and implemented something with this high level thinking:

• Process each line and store parameters into an object. Object relatively simple as a Dictionary, but only allow addition of ‘Valid’ keys – and cid is not a ‘valid’ key in the current implementation.
• Need to handle the splitting of parameters on each line with a space initially (but being wary of lines with just a single entry, i.e. no space). And then split those parameters on the ‘:’.
• On a blank line being reached, check validity of the object just being processed.
• Also need to handle the last entry in the file, which probably won’t have a blank line to declare the end of its processing.
• Finally, by only allowing ‘valid’ values into the Dictionary, a simple check of Length == 7 should suffice for whether the overall passport is valid.

As such the ‘supporting’ object looks like this:

public class PassportInfo {
     private Dictionary<string, string> PassportDictionary;
     private readonly List<string> ValidKeys = new List<string>()
     {
         "byr",
         "iyr",
         "eyr",
         "hgt",
         "hcl",
         "ecl",
         "pid"
     };

     public PassportInfo()
     {
         PassportDictionary = new Dictionary<string, string>();
     }

     public void UpdateInfo(string key, string value)
     {
         if (value.Length > 0 && ValidKeys.Contains(key))
         {
             PassportDictionary.Add(key, value);
         }
     }

     public bool IsValid()
     {
         if (PassportDictionary.Count == 7)
         {
             return true;
         }
         return false;
     }
}

And then the main method to parse the file looks like this:

     public int GetNumberOfValidPassports(List<string> passportFile)
     {
         var validPassportsCount = 0;
         PassportInfo passportInfo = new PassportInfo();
         foreach (var line in passportFile)
         {
             if (line.Trim().Length == 0)
             {
                 if (passportInfo.IsValid())
                 {
                     validPassportsCount++;
                 }
                 // Reset passportInfo.
                 passportInfo = new PassportInfo();
             }
             else
             {
                 string[] comps = new string[1];
                 comps[0] = line;
                 if (line.Contains(' '))
                 {
                     comps = line.Split(' ');
                 }

                 for (int i = 0; i < comps.Length; i++)
                 {
                     string[] keyValuePair = comps[i].Split(':');
                     passportInfo.UpdateInfo(keyValuePair[0], keyValuePair[1]);
                 }
             }
         }

         if (passportInfo.IsValid())
         {
             validPassportsCount++;
         }

         return validPassportsCount;
     }

I’ll skip over posting the supporting tests as they’re very similar to previous days.

Day 4 Part B

Truly horrible implementation this one, but its getting a little late. Got lucky by introducing the PassportInfo class in Part A, so it was really fleshing out the Adding to the Dictionary in the case of valid values being determined.

A couple of things I’d consider to improve:

• Extracting each of the methods and Unit Testing to ensure they meet the requirements.
• Look at C# Pattern Matching Syntax (in fact, decided to be less lazy and did use this implementation).
• Other thing considered but not implemented was short-circuiting the processing of the passport on discovery of the 1st invalid piece of data.

But still, its got me past today’s challenge, and wraps up the working week.

     public void UpdateInfo(string key, string value)
     {
         if (ValidKeys.Contains(key))
         {
             switch (key)
             {
                 case "byr":
                     int tempBirthYear = Int16.Parse(value);
                     if (tempBirthYear >= 1920 && tempBirthYear <= 2002)
                     {
                         PassportDictionary.Add(key, value);
                     }
                     break;

                 case "iyr":
                     int tempIssueYear = Int16.Parse(value);
                     if (tempIssueYear >= 2010 && tempIssueYear <= 2020)
                     {
                         PassportDictionary.Add(key, value);
                     }
                     break;

                 case "eyr":
                     int tempExpiryYear = Int16.Parse(value);
                     if (tempExpiryYear >= 2020 && tempExpiryYear <= 2030)
                     {
                         PassportDictionary.Add(key, value);
                     }
                     break;

                 case "hgt":
                     if (value.ToLower().EndsWith("cm"))
                     {
                         var tempValue = value.Replace("cm", "");
                         int height = Int16.Parse(tempValue);
                         if (height >= 150 && height <= 193)
                         {
                             PassportDictionary.Add(key, value);
                         }
                     }
                     else if (value.ToLower().EndsWith("in"))
                     {
                         var tempValue = value.Replace("in", "");
                         int height = Int16.Parse(tempValue);
                         if (height >= 59 && height <= 76)
                         {
                             PassportDictionary.Add(key, value);
                         }
                     }
                     break;

                 case "hcl":
                     if (value.StartsWith("#") && value.Length == 7)
                     {
                         var tempValue = value.Substring(1);
                         if (tempValue.All(c => "0123456789abcdef".Contains(c)))
                         {
                             PassportDictionary.Add(key, value);
                         }
                     }
                     break;

                 case "ecl":
                     if (ValidEyeColourList.Contains(value))
                     {
                         PassportDictionary.Add(key, value);
                     }
                     break;

                 case "pid":
                     if (value.Length == 9 && Int32.TryParse(value, out _))
                     {
                         PassportDictionary.Add(key, value);
                     }
                     break;
             }
         }
     }

At first this problem concerned me. I started immediately thinking that I’d need to start duplicating the map, but then it dawned on me that I could actually just reset the line point back to the start, retaining the offset that it had gone pass the end of line.

Day 3 Part A

With that in mind, I created the test with the sample input:

     [TestMethod]
     public void SampleInputTest()
     {
         // Example Input
         var inputMap = new List<string>()
         {
             "..##.......",
             "#...#...#..",
             ".#....#..#.",
             "..#.#...#.#",
             ".#...##..#.",
             "..#.##.....",
             ".#.#.#....#",
             ".#........#",
             "#.##...#...",
             "#...##....#",
             ".#..#...#.#"
         };

         var numberOfTreesHit = new Day3PartA().GetNumberOfHits(inputMap, 3, 1);         
         Assert.AreEqual(7, numberOfTreesHit);
     }

(NB. I got lucky with declaring constants for the moves for X and Y in the initial implementation, so ended up altering the signature for Part B for the method – so this code isn’t exactly the same as it was when solving the problem).

Turning to the code itself, I felt it needed to do a couple of things:

• Declare constants for right (X) and down (Y) moves.
• Due to the 1st line not needing to be considered, the last entry could be ignored as this is when the <whatever travelling device> had got through the map.
• Needed to consider when X when passed the end of the line, and do a reset back to the start (applying the offset)
• NB. Subtle change to the for loop coming up, which was originally just incrementing by 1, but subsequently changed to handle the varying down (Y) moves, as part of Part B.
• I was considering if there was an algorithm to just calculate the series of co-ordinates and then retrieve those entries from the line entries – that may be an more efficient approach.

So the code looked very similar to this:

     public int GetNumberOfHits(List<string> inputMap, int moveX, int moveY)
     {
         var numberOfHits = 0;
         var currentX = 0;
         var currentY = 0;
         var numberOfLines = inputMap.Count;

         for (int i = 0; i < numberOfLines - 1; i = i + moveY)
         {
             currentX += moveX;
             currentY += moveY;
             var mapLine = inputMap[currentY];

             if (currentX >= mapLine.Length)
             {
                 currentX -= mapLine.Length;
             }

             if (mapLine[currentX] == '#')
             {
                 numberOfHits++;
             }
         }

         return numberOfHits;
     }

Finally, as ever, another test case to use the file as input, and find out the actual number:

     public void FileInputTest()
     {
         var filename = @"C:\_path_\Day1\Day3\input.txt";
         var inputMap = File.ReadAllLines(filename).ToList();
         var numberOfTreesHit = new Day3PartA().GetNumberOfHits(inputMap, 3, 1);
         Assert.AreEqual(242, numberOfTreesHit);
     }

Day 3 Part B

And then I got lucky with the next step. I was able to alter the signature method to take in the varying right (X) and down (Y) parameters and remove my previously declared constants. The only I change I needed to handle was the for loop index incrementing by the value for down (Y).

In order to test though, I used the DataRow method on Test Suites in MSTest, so the next test looked like:

     [DataTestMethod]
     [DataRow(1, 1, 2)]
     [DataRow(3, 1, 7)]
     [DataRow(5, 1, 3)]
     [DataRow(7, 1, 4)]
     [DataRow(1, 2, 2)]
     public void ExampleMultipleRuns(int moveX, int moveY, int expectedHits)
     {
         // Example Input
         var inputMap = new List<string>()
         {
             "..##.......",
             "#...#...#..",
             ".#....#..#.",
             "..#.#...#.#",
             ".#...##..#.",
             "..#.##.....",
             ".#.#.#....#",
             ".#........#",
             "#.##...#...",
             "#...##....#",
             ".#..#...#.#" 
         };

         var numberOfTreesHit = new Day3PartA().GetNumberOfHits(inputMap, moveX, moveY);
         Assert.AreEqual(expectedHits, numberOfTreesHit);
     }

And the finally was able to do the same test, but using the file for input:

     [DataTestMethod]
     [DataRow(1, 1, 82)]
     [DataRow(3, 1, 242)]
     [DataRow(5, 1, 71)]
     [DataRow(7, 1, 67)]
     [DataRow(1, 2, 24)]
     public void FileInputMultipleRuns(int moveX, int moveY, int expectedHits)
     {
         var filename = @"C:\_path_\Day3\input.txt";
         var inputMap = File.ReadAllLines(filename).ToList();
         var numberOfTreesHit = new Day3PartA().GetNumberOfHits(inputMap, moveX, moveY);
         Assert.AreEqual(expectedHits, numberOfTreesHit);
     }