2021 Advent of Code Day 3 Solution

Introduction

Advent of Code is an Advent calendar of small programming puzzles for a variety of skill sets and skill levels that can be solved in any programming language in numerous different ways. In this post I will be outlining the solutions I wrote for the Day 3 problems, called "Binary Diagnostic", written in C++ so that others may learn from this post based on my code as well as find help in creating their own solutions to the issue and grasping the concepts of what the code is doing to reach the end goal.

Part 1

The problem states:

You need to use the binary numbers in the diagnostic report to generate two new binary numbers (called the gamma rate and the epsilon rate). The power consumption can then be found by multiplying the gamma rate by the epsilon rate.

Each bit in the gamma rate can be determined by finding the most common bit in the corresponding position of all numbers in the diagnostic report. For example, given the following diagnostic report:

Considering only the first bit of each number, there are five 0 bits and seven 1 bits. Since the most common bit is 1, the first bit of the gamma rate is 1.

The most common second bit of the numbers in the diagnostic report is 0, so the second bit of the gamma rate is 0.

The most common value of the third, fourth, and fifth bits are 1, 1, and 0, respectively, and so the final three bits of the gamma rate are 110.

So, the gamma rate is the binary number 10110, or 22 in decimal.

The epsilon rate is calculated in a similar way; rather than use the most common bit, the least common bit from each position is used. So, the epsilon rate is 01001, or 9 in decimal. Multiplying the gamma rate (22) by the epsilon rate (9) produces the power consumption, 198.

Use the binary numbers in your diagnostic report to calculate the gamma rate and epsilon rate, then multiply them together. What is the power consumption of the submarine? (Be sure to represent your answer in decimal, not binary.)

The input provided by Advent of Code is different for each participant in order to keep the solution unique for each person. It is roughly 1000 lines of text mimicking the above example with each line consisting of a 12 bit binary number. For this solution bitset was utilized after putting the text into a .txt file that can be reached by the program.

Here is the code:

#include <iostream>
#include <fstream>
#include <bitset>
#include <vector>
using namespace std;

int main(){
  const int bits = 12; //12 bit input
  vector<bitset<bits>> diagnostics;
  ifstream fin("text.txt");
  string line;
  while(fin >> line) {
	diagnostics.push_back(bitset<bits>(line));
  }

  bitset<bits> gamma_rate, epsilon_rate;
  for(int i = bits-1; i >= 0; i--){
	int counts[2] {0,0};
	for(auto diagnostic : diagnostics){
		counts[diagnostic[i]]++;
	}
	gamma_rate[i] = counts[0] > counts[1] ? 0 : 1;
  }
  epsilon_rate = bitset<bits>(gamma_rate).flip(); //bitset flip zeros to ones and ones to zeros
	
  cout << "Gamma : " << gamma_rate.to_ulong() << endl; //member function to unsigned long
  cout << "Epsilon : " << epsilon_rate.to_ulong() << endl;
  cout << "Power Consumption : " << gamma_rate.to_ulong()*epsilon_rate.to_ulong() << endl;
}

As mentioned previously, this solution utilizes the bitset class which stores bits that may only contain one of two values, 0 and 1, in a binary number emulated through an array of boolean variables. The class optimizes the arrays for space allocation as well as allowing each bit to be accessed individually similar to a normal array. For example, foo[1] in bitset would access the second bit of the binary number. Another reason why bitset is utilized in this solution is because they have the feature of being able to be constructed from and converted to both integer values and binary strings through it's constructor and members to_ulong and to_string.

In addition to bitset, this solution also utilizes vectors. Vectors are a type of container that has a dynamic size that can be changed during runtime. Due to this, vectors generally utilize more memory than a typical array.

This solution essentially pushes each line, consisting of a single binary 12 bit number, onto a stack within the vector and runs through the number to find the most common digit of each bit within each number. Through obtaining the most common number in each bit and determining the gamma rate, one is able to simply find the epsilon rate as the least common number in each bit is simply the opposite of the most common as binary consists of only two values. By simply utilizing flip(), we can determine the epsilon rate. Afterwards, for the output and solution, each number is converted to an unsigned long integer value through the bitset member function and then multiplied to obtain the answer to the question.

Part 2

Part 2 of the problem states:

Next, you should verify the life support rating, which can be determined by multiplying the oxygen generator rating by the CO2 scrubber rating.

Both the oxygen generator rating and the CO2 scrubber rating are values that can be found in your diagnostic report - finding them is the tricky part. Both values are located using a similar process that involves filtering out values until only one remains. Before searching for either rating value, start with the full list of binary numbers from your diagnostic report and consider just the first bit of those numbers. Then:

Keep only numbers selected by the bit criteria for the type of rating value for which you are searching. Discard numbers which do not match the bit criteria.
If you only have one number left, stop; this is the rating value for which you are searching.
Otherwise, repeat the process, considering the next bit to the right.

The bit criteria depends on which type of rating value you want to find:

To find oxygen generator rating, determine the most common value (0 or 1) in the current bit position, and keep only numbers with that bit in that position. If 0 and 1 are equally common, keep values with a 1 in the position being considered.
To find CO2 scrubber rating, determine the least common value (0 or 1) in the current bit position, and keep only numbers with that bit in that position. If 0 and 1 are equally common, keep values with a 0 in the position being considered.

For example, to determine the oxygen generator rating value using the same example diagnostic report from above:

Start with all 12 numbers and consider only the first bit of each number. There are more 1 bits (7) than 0 bits (5), so keep only the 7 numbers with a 1 in the first position: 11110, 10110, 10111, 10101, 11100, 10000, and 11001.
Then, consider the second bit of the 7 remaining numbers: there are more 0 bits (4) than 1 bits (3), so keep only the 4 numbers with a 0 in the second position: 10110, 10111, 10101, and 10000.
In the third position, three of the four numbers have a 1, so keep those three: 10110, 10111, and 10101.
In the fourth position, two of the three numbers have a 1, so keep those two: 10110 and 10111.
In the fifth position, there are an equal number of 0 bits and 1 bits (one each). So, to find the oxygen generator rating, keep the number with a 1 in that position: 10111.
As there is only one number left, stop; the oxygen generator rating is 10111, or 23 in decimal.

Then, to determine the CO2 scrubber rating value from the same example above:

Start again with all 12 numbers and consider only the first bit of each number. There are fewer 0 bits (5) than 1 bits (7), so keep only the 5 numbers with a 0 in the first position: 00100, 01111, 00111, 00010, and 01010.
Then, consider the second bit of the 5 remaining numbers: there are fewer 1 bits (2) than 0 bits (3), so keep only the 2 numbers with a 1 in the second position: 01111 and 01010.
In the third position, there are an equal number of 0 bits and 1 bits (one each). So, to find the CO2 scrubber rating, keep the number with a 0 in that position: 01010.
As there is only one number left, stop; the CO2 scrubber rating is 01010, or 10 in decimal.

Finally, to find the life support rating, multiply the oxygen generator rating (23) by the CO2 scrubber rating (10) to get 230.

Use the binary numbers in your diagnostic report to calculate the oxygen generator rating and CO2 scrubber rating, then multiply them together. What is the life support rating of the submarine? (Be sure to represent your answer in decimal, not binary.)

This part is very similar to the first part in how it is set up and the goal of determining most common or least common bits within each binary number.

Here is the code:

#include <iostream>
#include <fstream>
#include <bitset>
#include <vector>
#include <array>
using namespace std;

int main() {
  const int bits = 12; // 12 bit numbers
	
  vector<bitset<bits>> diagnostics;
  ifstream fin("text.txt");
  string line;
  while(fin >> line) {
	diagnostics.push_back(bitset<bits>(line));
  }
	
  bitset<bits> oxygen_generator_rating;

  vector<bitset<bits>> most_common(diagnostics); // avoid changing input by duplicating
  for(int i = bits-1; most_common.size() > 1 && i >= 0; i--){
	array<vector<bitset<bits>>,2> filtered;
	for(auto diagnostic : most_common){
		filtered[diagnostic[i]].push_back(diagnostic);
	}
	most_common = filtered[0].size() > filtered[1].size() ? filtered[0] : filtered[1]; 
	//if equal, keep 1
  }
  oxygen_generator_rating = most_common.at(0);
	
  bitset<bits> co2_scrubber_rating;

  vector<bitset<bits>> least_common(diagnostics); //avoid changing input by duplicating
  for(int i = bits-1; least_common.size() > 1 && i >= 0; i--){
	array<vector<bitset<bits>>,2> filtered;
	for(auto diagnostic : least_common){
		filtered[diagnostic[i]].push_back(diagnostic);
	}
	least_common = filtered[0].size() > filtered[1].size() ? filtered[1] : filtered[0];
        // if equal, keep 0
  }
  co2_scrubber_rating = least_common.at(0);
	
  // convert to unsigned long int
  cout << "Oxygen generator rating : " << oxygen_generator_rating.to_ulong() << endl;
  cout << "Co2 scrubber rating : " << co2_scrubber_rating.to_ulong() << endl;
  cout << "Life support rating : " << oxygen_generator_rating.to_ulong()*co2_scrubber_rating.to_ulong() << endl;
}

This solution duplicates the vectors into an array and filters through the lists of binary numbers determining each most common bit, or least common bit, and then eliminating the ones starting with a different digit. After filtering through the list and eliminating each binary number, once there is only one binary number remaining, the program sets the rating to the remaining binary number through a statement such as rating = array.at(0); which sets the rating of type bitset to the first binary number located within the array, which is also the only number remaining in the array.

Similarly to the first part, the output numbers are then converted to unsigned long integers and multiplied to obtain the solution to the problem.

Conditional Operator

The question mark that is visible in both solutions to both parts is known as the conditional operator. The conditional operator is highly useful in determining what happens if a condition is true or not, similar to an if statement, in a one line statement. This is typically utilized for conditions whose outcomes are typically simple such as setting a value or producing an output.

The syntax for the conditional operator is:

condition ? result_if_true : result_if_false

Conclusion

Advent of Code is a very fun event that only happens once a year similar to typical advent calendars. Having an Advent calendar of small programming puzzles for a variety of skill sets and skill levels that can be solved in any programming language is a fun little challenge that brings a lot of the coding community together in various different ways. Users can have private leaderboards to compare their scores with their friends as well as possibly making their way onto the global leaderboards. The Day 3 problems "Binary Diagnostic" were rather simple and can be solved in a variety of methods and these solutions could possibly be considered a "more advanced" way of solving the problem. Despite this, the logic of how the solutions are obtained is rather straightforward and can be applied in multiple ways that differ from this. I hope that you learned from this post of my code and can help in creating your own solution to the issue and grasp the concepts of what the code is doing to reach the end goal.

December 5, 2021