Today’s puzzle was about grid traversal and simulating process. Let me setup the scenario.

We are there at the printing department. And we need the forklift for the commute process, but the forklifts are used by the elves for moving heavy rolls of wrapping paper. We need to optimize their workflow, so that the forklifts become free ASAP.

Now comes the important part, the paper rolls are arranged in a grid, and in the given representation, a paper roll is represented by @. For example,

In this grid a forklift can access/lift a paper roll if there are fewer than four in the eight adjacent positions. In the above example, the rolls that can be accessed are marked x.

Puzzle 1

First puzzle was quite simple simple, we simply had to count the number of liftable rolls. In the given example, it is \(13\).

Let me tell you a little bit about the adjacent positions. In a grid, for a position (i, j), the adjacent positions are the following. Its the positions at units distance from that position in vertical or horizontal or diagonal direction. In the figure below for blue position, the green position are called adjancent.

Solution and Implementation

We will simply check at each of the eight positions, that if they exist(they don’t for border elements) and if they are paper roll and count them, if that count < 4, count it in ans.

for (int i = 0; i < grid.size(); ++i) {
    for (int j = 0; j < grid[0].size(); ++j) {
      if (grid[i][j] != '@')
        continue;
      int count =
          // N
          (i >= 1 && grid[i - 1][j] == '@') +
          // NW
          (i >= 1 && j >= 1 && grid[i - 1][j - 1] == '@') +
          // W
          (j >= 1 && grid[i][j - 1] == '@') +
          // SW
          (j >= 1 && i < grid.size() - 1 && grid[i + 1][j - 1] == '@') +
          // S
          (i < grid.size() - 1 && grid[i + 1][j] == '@') +
          // SE
          (j < grid[0].size() - 1 && i < grid.size() - 1 &&
           grid[i + 1][j + 1] == '@') +
          // E
          (j < grid[0].size() - 1 && grid[i][j + 1] == '@') +
          // NE  ← missing one
          (i >= 1 && j < grid[0].size() - 1 && grid[i - 1][j + 1] == '@');
      if (count < 4)
        ans++; // count as liftable
    }
  }

Puzzle 2

Now the Elves just need help accessing as much of the paper as they can.

Once a roll of paper can be accessed by a forklift, it can be removed. Once a roll of paper is removed, the forklifts might be able to access more rolls of paper, which they might also be able to remove. How many total rolls of paper could the Elves remove if they keep repeating this process?

In simple words, we remove the removable ones, then remove more(if possible) until we are left with such situation, that we can’t remove anymore. In the above example, the simulation/solution is present here.

Solution

We can’t remove the removable paper rolls on the first pass(where we are checking if they are removable or not) as that might hinder the verification of other rolls, instead we just mark them, and then after this pass, we remove them(just mark them .). And repeat this process, until nothing is marked in first pass

Implementation

In my implementation, I used a list of positions that are supposed to be marked. When I have to mark them, I just push them in this list. If nothing is in the list after this pass we just stop the whole process, else we remove(marking them . in the grid) all the positions while also adding the list’s original size to the final solution.

  int final_ans = 0;
  list<pair<int, int>> positions;
  do {
    positions.clear();
    for (int i = 0; i < grid.size(); ++i) {
      for (int j = 0; j < grid[0].size(); ++j) {
        if (grid[i][j] != '@')
          continue;
        int cnt =
            // N
            (i >= 1 && grid[i - 1][j] == '@') +
            // NW
            (i >= 1 && j >= 1 && grid[i - 1][j - 1] == '@') +
            // W
            (j >= 1 && grid[i][j - 1] == '@') +
            // SW
            (j >= 1 && i < grid.size() - 1 && grid[i + 1][j - 1] == '@') +
            // S
            (i < grid.size() - 1 && grid[i + 1][j] == '@') +
            // SE
            (j < grid[0].size() - 1 && i < grid.size() - 1 &&
             grid[i + 1][j + 1] == '@') +
            // E
            (j < grid[0].size() - 1 && grid[i][j + 1] == '@') +
            // NE  ← missing one
            (i >= 1 && j < grid[0].size() - 1 && grid[i - 1][j + 1] == '@');
        if (cnt < 4) {
          final_ans++;
          positions.push_back({i, j});
        }
      }
    }
    for (const auto [i, j] : positions)
      grid[i][j] = '.';
  } while (positions.size() != 0);

Conclusion

These might not have been the most efficient solutions, but they are surely simple, and that also counts in software engineering. Most of the times, simplicity of the solutions matters mote than the premature optimizations/optimizations possible.

Signing off

Today’s Advent of Code puzzles were quite simple to come up with, the only issue/challenge that might come is about “implementation”

Puzzle 1

Deduced Problem: Given a decimal digits string num find the maximum number that can be made using exactly 2 digits of num, maintaining their relative order

Intuition and Logic

A simple brute force solution will involve iteration over [0 … len(num) - 2] with i as iterator and for each i we iterate over [i + 1 … len(num) - 1] with j as iterator to find maximum digit in num[i+1:]. Hence for each num[i] we have maximum in num[i+1:] as num[j] and therefore corresponding candidate for num[i] is made by (i, j). We can do this for each i in [0 … len(num) - 2]. And from the candidates take the maximum result.

Time Complexity: \(\Theta(n^2)\)

Improvement

For finding the maximum for each element in its suffix array instead of scanning the entire suffix array, we can maintain a suffix_max array, where suffix_max[i] is
max(num[i], max in [i+1 … len(nums - 1)]
Where we set the last element same as the last element in num as it has no suffix array.
We can compute this suffix_max in a single pass(reverse one). And in another pass of num, we use num[i] and suffix_max[i+1] for making candidates and hence choosing the maximum.

Implementation

int max_joltage(string bank) {
        vector<char> suffix_max(bank.size());
        for (int i = bank.size() - 1; i >= 0; --i) {
                if (i == bank.size() - 1) {
                        suffix_max[i] = bank[i];
                }
                else {
                        suffix_max[i] = max(suffix_max[i + 1], bank[i]);
                }
        }
        int ans = INT_MIN;
        for (int i = 0; i < bank.size() - 1; ++i) {
                ans = max(ans, (bank[i] - '0') * 10 + (suffix_max[i + 1] - '0'));
        }
        return ans;
}

Puzzle 2

Deduced Problem: Given a decimal digits string num find the maximum number that can be made using exactly 12 digits of num, maintaining their relative order

Intuition and Logic

I came up with a simple solution

Start at start of string, and then find a maximum number such that there are still enough elements left to make a string of size 12. Continue that until size 12 string is formed

Implementation

1. start at pos = 0

2. loop over the count remaining that tells how many digits are left to select(initially 12 and goes till 0)

3. Find the position last such that we find max digit in [pos … last] and there are at least remaining - 1 elements left to process

4. Find max in [pos … last] say at position best_idx.

5. Add that to result and set pos = best_idx + 1.

6. Repeat until remaining = 0.

I share the solution for any k(that is number of digits I have to choose)

string max_subsequence_of_length(const string &num, int k = 12) {
    int n = (int)num.size();
    if (k >= n) return s;          // if input shorter or equal, return it
    string res;
    res.reserve(k);

    int pos = 0; // next index we can pick from
    for (int remaining = k; remaining > 0; --remaining) {
        // last index we can pick so that there remain (remaining-1) chars after it
        int last = n - remaining;
        // find maximum digit in s[pos..last]
        char best = '0';
        int best_idx = pos;
        for (int i = pos; i <= last; ++i) {
            if (num[i] > best) {
                best = num[i];
                best_idx = i;
                if (best == '9') break; // can't do better than '9'
            }
        }
        res.push_back(best);
        pos = best_idx + 1;
    }
    return res;
}

Time Complexity: \(\Theta(n \cdot k)\), in our case \(\Theta(12n)\).

Conclusion

At last, it was one where you had to think more about robust implementation rather than approach and intuition. Follow me on X @singhrounakkumr.

Signing Off

Puzzle 1

Deduced problem: Given a set of ranges in the form [a, b], we had to find sum of all possible invalid IDs in these ranges.

Invalid ID is an ID which is made only of some sequence of digits repeated twice. For example, 55(5 twice), 6464 (64 twice), and 123123 (123 twice) would all be invalid IDs.

Intuition and Thoughts

Hmm, so the invalid numbers(say \(N\)) would be of the form \(N \rightarrow xx\), where \(x\) is a say \(k\) digits number, so \(N\) will have \(k\) digits and the value of \(N\) is given by

$$N = x + 10^k \cdot x = (10^k + 1) \cdot x$$

So, for \(N\) must be a multiple of \(10^k + 1\)

Approach

For a fixed \(k\), \(N\) is a \(2k\) digit number which is a multiple of \(m = 10^k + 1\)

So if we find all \(x\) such that \(x \cdot m\) is in the range, then we found the invalid ids which can be deduced from the following conditions

$$a \leq N \leq b \implies a \leq x \cdot m \leq b$$

which is from the problem only and,

$$10^{k-1} \leq x \leq 10^k - 1$$

since \(x\) is \(k\) digit number

Solving the problem

Combining the two inequalities we get,

$$\max(10^{k-1}, \frac{a}{m}) \leq x \leq \min (10^k - 1, \frac{b}{m})$$

Since this we are dealing with integer calculation, I will make it more precise

$$\max(10^{k-1}, \lceil \frac{a}{m} \rceil) \leq x \leq \min (10^k - 1, \lfloor\frac{b}{m}\rfloor)$$

Implementation

I used __int128 data type for storing the sums, the values and everything, just because I wanted to be paranoid — definitely not needed

1. I used a precomputed table to compute the masks value

2. To avoid data loss in extreme cases due to conversion between integers and doubles and ceiling them I instead do (a + b - 1) / b to compute \(\lceil\frac{a}{b}\rceil\)

Steps:

1. Early Exit on Useless Cases:

   • If (a > b), exit early as there are no valid ranges.

   • If there are no even-length numbers within the range, exit early.

2. Consider Each Valid (k): Identify each k such that a 2k digit number lies within the range [a, b].

3. Compute min_x and max_x: Calculate min_x and max_x using the inequalities

4. Check Existence of Numbers: Ensure numbers exist by checking min_x <= max_x.

5. Generate (N): N can be generated by x in [min_x, min_x + 1, ..., max_x]).

6. Sum the Values: Sum all x using basic arithmetic progression results and multiply by mask to get the final value.

__int128 find_invalid(__int128 a, __int128 b) {
  if (a > b)
    return 0;
  int digits_1 = count_digits(a); // We count the number of digits in a & b
  int digits_2 = count_digits(b);
  if (digits_1 == digits_2 && (digits_1 & 1))
    return 0;
  __int128 ans = 0;
  for (int k = (digits_1 + 1) / 2; 2 * k <= digits_2; ++k) {
    int twice_k = 2 * k;
    __int128 mask = 1 + pow10_128[k]; // mask = 10^k + 1
    __int128 loN = max(a, pow10_128[2 * k - 1]);
    __int128 hiN = min(b, pow10_128[2 * k] - 1);
    if (loN > hiN)
      continue;
    __int128 min_x = (loN + mask - 1) / mask;
    __int128 max_x = hiN / mask;
    if (min_x > max_x) continue;
    __int128 sum_x = (max_x - min_x + 1) * (min_x + max_x) / 2;
    ans += sum_x * mask;
  }
  return ans;
}

Complexity Analysis

The time complexity is \(\Theta(d_b - d_a)\) or \(\Theta(\log \frac{b}{a})\) as the loop runs that many times

Puzzle 2

Deduced Problem: Same as last problem but definition of Invalid ID changes.

An ID is invalid if it is made only of some sequence of digits repeated at least twice.

Intuition and Thoughts

Using the same notations as above, here \(N \rightarrow xxxx(\dots n\text{ times})\), so digits of \(N\), \(d_N = k \cdot n\), where \(N\) is given by

$$N = x \cdot (1 + 10^k + 10^{2k} \dots 10^{(n-1)k}) = x \cdot M(n, k)$$

where \(M(n, k) \) is a repunit-like number, which is used to repeat a \(k\) digit number \(n\) times in order to get a \(d= k \cdot n\) digit number.

By concept of geometric progressions,

$$M(n, k) = \dfrac{10^{nk} - 1}{10^k - 1}$$

So to generate a \(d_N\) digit \(N\), the only thing we need is few \(k\) digit numbers \(x\), where \(k \mid n\)(\(k\) divides \(n\)) and \(k \ne n\) and they will generate \(N\)

So for a fixed \(d_N\) and \(k\), we calculate the possible values of \(x\)(just like we did last time), but this time mask is replaced by a more general term repunit (mask is repunit for n = 2)

So this is simply solved like the previous one only the mask value is swapped.

Gotcha!!!

This time there is an issue, the issue of duplicates, consider the following example
\(d_N = 6\), \(k = 1\), \(n = 6\), generates \(111111\)
which is also generated by \(k = 2, n = 3\) and \(k = 3 , n = 2\)

So there are solutions to this problem, I will share 3 and discuss only one and the simplest one and leave the other two as extensions for you to solve

Solution

Implementation quirks:

1. I stored the proper factors of numbers upto 20 in a table named DIV

2. Created a hash set for __int128 type(easier than it sounds)

Steps:

1. Use the same procedure as the last puzzle

2. Instead of summing all the numbers at once, we will store each of the generated number in a hash set, so that we can deduplicate the duplicates

3. After going through all possible digits, we sum at last

__int128_t find_invalid(__int128 a, __int128 b) {
  if (a > b)
    return 0;
  int digits_1 = count_digits(a); // We count the number of digits in a & b
  int digits_2 = count_digits(b);
  unordered_set<__int128, Hash128, Eq128> invalid_nums;
  for (int digits = digits_1; digits <= digits_2; ++digits) {

    for (const int k : DIV[digits]) {
      __int128 repunit = (pow10_128[digits] - 1) / (pow10_128[k] - 1);
      __int128 loN = max(a, pow10_128[digits - 1]);
      __int128 hiN = min(b, pow10_128[digits] - 1);
      __int128 min_x = (loN + repunit - 1) / repunit;
      __int128 max_x = (hiN) / repunit;
      if (min_x > max_x)
        continue;
      for (int i = min_x; i <= max_x; ++i) {
        invalid_nums.insert(i * repunit);
      }
    }
  }
  __int128_t ans = 0;
  for (const __int128_t invalid_num : invalid_nums) {
    ans += invalid_num;
  }
  return ans;
}

Performance Analysis

Outer loop runs \(\Theta(d_b - d_a)\) just like last puzzle
First Inner loop runs \(\Theta(f)\)times where \(f\) is the sum of number of proper factors of all \(d \in [d_a, d_b]\)
Second Inner loop runs \(\Theta(s)\) in total where \(s\) is the number of solutions(Invalid IDs) and so does the sum computing loop

Total time complexity: \(\Theta(d_b - d_a +f +s)\)

Improvement 1 — primitive block

My initial idea for improvement is phrased by an LLM as:

Define a k-digit block x as primitive if it is not itself a repetition of a smaller block. For a given (k,n), you should only accept x that are primitive; then every final N has a unique representation (with k minimal).

Improvement 2 - counting primitives without enumerating x (Möbius)

I found the following from ChatGPT and haven’t explored much, so I would love to hear more about this from anyone of you

If you need to count how many primitive k-digit x lie in the interval [A, B] (where A and B are arbitrary, e.g. x_low..x_high), you can use inclusion-exclusion / Möbius inversion on divisors of k. Rough sketch:

• Let F(t) be number of k-digit numbers that are repetition of a block of length t where t | k (and t<k). Those x are of the form y repeated k/t times. Counting those ≤ X reduces to counting y ≤ something. Use Möbius to invert and get count of primitive numbers. Implementation is trickier because of the arbitrary interval endpoints but doable if you need asymptotic speed and k can be large.

For those of you who want the solution with improvements: https://gist.github.com/rounakkumarsingh/d8ed1af840c7ad995329e647672cc3e9. (I neither have written this nor have read this, this is generated by ChatGPT)