Hello there ! Iβm Xavier Jouvenot and here is the first part of a long series on Advent Of Code. The original post of this article is on my website.
For this first post, we will start with the first problem from the 1st December 2015, named "Not Quite Lisp".The solution I will propose in c++, but the reasoning can be applied to other languages.
The Problem
The full version of this problem can be found directly on the Advent of Code website, I will only describe the essence of the problem here:
Santa needs to find the floor on which he will let his presents, but he only have instructions with (
and )
which respectively indicate that he should go up one floor or go down one floor.Here are some examples:

(((
results in floor3

)))
results in floor3

(()))(
results in floor0
No Code Solution
First of all, why write a program, when you avoid doing so.Letβs analyse the problem a little.
We want to know the final floor, the one on which Santa will be in the end. And that, is the result of all the going up one floor and going down one floor. The result can then be describe as final Santa floor = (all the time Santa goes up)  (all the time Santa goes down)
.
So if we know how many time Santa go up, or how many (
there are, and down, or how many )
there are, we won. And for that just using CTRLF
is enough to get the number of occurrences of (
and )
.
And voilΓ . Here you can have the solution by subtracting the 2 number of parenthesis occurrences without writing even a line of code by yourself, since somebody has written the CTRLF
functionalities π.
C++ Solution
Even if we can found the solution without coding, we can do it, for the exercise.
To find the solution, we can use some naive approach by iterating on the input while tracking the floor we are in, to ultimately arrive to the solution. But, we can use the same approach we used in the nocode solution, by counting the number of occurrences for each parenthesis.
#include <algorithm>
const auto openParenthesisCount = std::count(std::begin(input), std::end(input), '(');
const auto closeParenthesisCount = std::count(std::begin(input), std::end(input), ')');
const auto result = openParenthesisCount  closeParenthesisCount;
Simple, but efficient π.
This is not the only solution of course. Two other solutions I have in mind are the naive approach and the recursive one that I wonβt describe here.
Part 2
After completing the first part of this puzzle, surprise !! (at least for me it was), you unlocked the second part.
This part consists to find the position of the first character that make Santa go into the basement.Unlike the Part 1, there is no simple and quick tricks without some programming.So here we go.
Solution
Once again, we can use the std to find the solution of our problem.
#include <algorithm>
// Starting on the floor 0
auto floor {0};
const auto firstEnteringInTheBasement = std::find_if(
std::begin(input),
std::end(input),
[&floor](const auto& character)
{
// We go up when meeting a '('
if (character == '(')
{
++floor;
}
// We go down when meeting a ')'
else if (character == ')')
{
floor;
}
// Return true if we are in the basement
return floor < 0;
});
// Getting the position of the element which makes us go to the basement
const auto result = std::distance(std::begin(input), firstEnteringInTheBasement) + 1;
And thatβs basically all we need to solve this problem.
Conclusion
You can note that the solutions written in this post, donβt include all the sources to make running programs, but only the interesting part of the sources to solve this problem.If you want to see the programs from end to end, you can go on my GitHub account, explore the full solution, add comments or ask questions if you want to.
Here is the list of std method that we have used, I canβt encourage you enough to look at their definitions :
Thanks for you reading, hope you liked it π.
And until next part, have fun learning and growing.
Top comments (0)