Hello there ! I'm Xavier Jouvenot and here is the first part of a long series on Advent Of Code.
For this first post, we will start with the 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 leave his presents, but he only has 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 analyze 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 described as final Santa floor = (all the time Santa goes up)  (all the time Santa goes down)
.
So if we know how many times Santa goes 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 find 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 at the solution. But, we can use the same approach we used in the nocode solution, by counting the number of occurrences for each parenthesis.
PuzzleSolution computeSolution(const std::string_view input) {
const auto openParenthesisCount =
std::count(std::begin(input), std::end(input), '(');
const auto closeParenthesisCount =
std::count(std::begin(input), std::end(input), ')');
return 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 of finding the position of the first character that makes 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 to our problem.
PuzzleSolution computeSolution(const std::string_view input) {
auto floor{0};
const auto firstEnteringInTheBasement = std::find_if(
std::begin(input), std::end(input), [&floor](const auto &character) {
if (character == '(') {
++floor;
} else if (character == ')') {
floor;
}
return floor < 0;
});
assert(firstEnteringInTheBasement != std::end(input));
return 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 the next part, have fun learning and growing.
Top comments (0)