Susam's Puzzles

Fizz Buzz in CSS

2025-12-06T00:00:00Z

How many CSS selectors and declarations do we need to produce the Fizz Buzz sequence? Of course we could do this with no CSS at all simply by placing the entire sequence as text in the HTML body. So to make the problem precise as well as to keep it interesting, we require that all text that appears in the Fizz Buzz sequence comes directly from the CSS. Placing any part of the output numbers or words outside the stylesheet is not allowed. JavaScript is not allowed either. With these constraints, I think we need at least four CSS selectors along with four declarations to solve this puzzle, as shown below:

li { counter-increment: n }
li:not(:nth-child(5n))::before { content: counter(n) }
li:nth-child(3n)::before { content: "Fizz" }
li:nth-child(5n)::after { content: "Buzz" }

Here is a complete working example: css-fizz-buzz.html.

The above solution contains four CSS rules with one selector and one declaration in each rule. For example, li { counter-increment: n } is one rule consisting of the selector li and the declaration counter-increment: n.

Seasoned code golfers looking for a challenge can probably shrink this solution further. A common trick to solve this problem is to use an ordered list (<ol>) which provides the integers in the form of list markers automatically, thereby eliminating the need to maintain a counter in the stylesheet. However, this violates the requirement set out in the introduction. We want every integer to be produced directly by the stylesheet. Treating the integers in the list markers as part of the output sequence breaks this rule. Not to mention the output looks untidy because of the unnecessary dot after each marker and also because the numbers and words appear misaligned. See an example of that trick here: css-fizz-buzz-ol.html. Correcting the misaligned output calls for extra code that cancels out the number of declarations saved. In any case, the requirement that all integers of the output must come directly from the stylesheet prevents untidy solutions like this and also forces us to rely on the capabilities of CSS to solve this puzzle.

The intention here was to obtain the smallest possible code in terms of the number of CSS declarations. This example is not crafted to minimise bytes, but for code golfers who enjoy reducing byte count, here is the number of bytes this solution consumes after removing all whitespace:

$ curl -sS https://susam.net/css-fizz-buzz.html | sed -n '/counter/,/after/p' | tr -d '[:space:]' | wc -c
152

Further reduction in byte count can be achieved by using the <p> element instead of <li>, nesting CSS selectors, etc. I'll leave that as an exercise for the reader. Returning to the focus of this post as well as to summarise it, the solution here uses four CSS rules consisting of four selectors and four declarations to render the Fizz Buzz sequence.

Fizz Buzz with Cosines

2025-11-20T00:00:00Z

Fizz Buzz is a counting game that has become oddly popular in the world of computer programming as a simple test of basic programming skills. The rules of the game are straightforward. Players say the numbers aloud in order beginning with one. Whenever a number is divisible by 3, they say 'Fizz' instead. If it is divisible by 5, they say 'Buzz'. If it is divisible by both 3 and 5, the player says both 'Fizz' and 'Buzz'. Here is a typical Python program that prints this sequence:

for n in range(1, 101):
    if n % 15 == 0:
        print('FizzBuzz')
    elif n % 3 == 0:
        print('Fizz')
    elif n % 5 == 0:
        print('Buzz')
    else:
        print(n)

Here is the output: fizz-buzz.txt. Can we make the program more complicated? The words 'Fizz', 'Buzz' and 'FizzBuzz' repeat in a periodic manner throughout the sequence. What else is periodic? Trigonometric functions! Perhaps we can use trigonometric functions to encode all four rules of the sequence in a single closed-form expression. That is what we are going to explore in this article, for fun and no profit.

By the end, we will obtain a discrete Fourier series that can take any integer $ n $ and select the corresponding text to be printed. In fact, we will derive it using two different methods. First, we will follow a long-winded but hopefully enjoyable approach that relies on a basic understanding of complex exponentiation, geometric series and trigonometric functions. Then, we will obtain the same result through a direct application of the discrete Fourier transform.

Definitions
From Indicator Functions to Cosines
Discrete Fourier Transform
Conclusion

Definitions

Before going any further, we establish a precise mathematical definition for the Fizz Buzz sequence. We begin by introducing a few functions that will help us define the Fizz Buzz sequence later.

Symbol Functions

We define a set of four functions $ \{ s_0, s_1, s_2, s_3 \} $ for integers $ n $ by: \begin{align*} s_0(n) &= n, \\ s_1(n) &= \mathtt{Fizz}, \\ s_2(n) &= \mathtt{Buzz}, \\ s_3(n) &= \mathtt{FizzBuzz}. \end{align*} We call these the symbol functions because they produce every term that appears in the Fizz Buzz sequence. The symbol function $ s_0 $ returns $ n $ itself. The functions $ s_1, $ $ s_2 $ and $ s_3 $ are constant functions that always return the literal words $ \mathtt{Fizz}, $ $ \mathtt{Buzz} $ and $ \mathtt{FizzBuzz} $ respectively, no matter what the value of $ n $ is.

Index Function

We define a function $ f(n) $ for integer $ n $ by \[ f(n) = \begin{cases} 1 & \text{if } 3 \mid n \text{ and } 5 \nmid n, \\ 2 & \text{if } 3 \nmid n \text{ and } 5 \mid n, \\ 3 & \text{if } 3 \mid n \text{ and } 5 \mid n, \\ 0 & \text{otherwise}. \end{cases} \] The notation $ m \mid n $ means that the integer $ m $ divides the integer $ n, $ i.e. $ n $ is a multiple of $ m. $ Equivalently, there exists an integer $ c $ such that $ n = cm . $ Similarly, $ m \nmid n $ means that $ m $ does not divide $ n, $ i.e. $ n $ is not a multiple of $ m. $

This function covers all four conditions involved in choosing the $ n $th item of the Fizz Buzz sequence. As we will soon see, this function tells us which of the four symbol functions produces the $ n $th item of the Fizz Buzz sequence. For this reason, we call $ f(n) $ the index function.

Fizz Buzz Sequence

We now define the Fizz Buzz sequence as the sequence \[ (s_{f(n)}(n))_{n = 1}^{\infty} \] We can expand the first few terms of the sequence explicitly as follows: \begin{align*} (s_{f(n)}(n))_{n = 1}^{\infty} &= (s_{f(1)}(1), \; s_{f(2)}(2), \; s_{f(3)}(3), \; s_{f(4)}(4), \; s_{f(5)}(5), \; s_{f(6)}(6), \; s_{f(7)}(7), \; \dots) \\ &= (s_0(1), \; s_0(2), \; s_1(3), \; s_0(4), s_2(5), \; s_1(6), \; s_0(7), \; \dots) \\ &= (1, \; 2, \; \mathtt{Fizz}, \; 4, \; \mathtt{Buzz}, \; \mathtt{Fizz}, \; 7, \; \dots). \end{align*} Note how the function $ f(n) $ produces an index $ i $ which we then use to select the symbol function $ s_i(n) $ to produce the $ n $th term of the sequence. This is precisely why we decided to call $ f(n) $ the index function while defining it in the previous section.

From Indicator Functions to Cosines

Here we discuss the first method of deriving our closed form expression, starting with indicator functions and rewriting them using complex exponentials and cosines.

Indicator Functions

Here is the index function $ f(n) $ from the previous section with its cases and conditions rearranged to make it easier to spot interesting patterns: \[ f(n) = \begin{cases} 0 & \text{if } 5 \nmid n \text{ and } 3 \nmid n, \\ 1 & \text{if } 5 \nmid n \text{ and } 3 \mid n, \\ 2 & \text{if } 5 \mid n \text{ and } 3 \nmid n, \\ 3 & \text{if } 5 \mid n \text{ and } 3 \mid n. \end{cases} \] This function helps us select another function $ s_{f(n)}(n) $ which in turn determines the $ n $th term of the Fizz Buzz sequence. Our goal now is to replace this piecewise formula with a single closed-form expression. To do so, we first define indicator functions $ I_m(n) $ as follows: \[ I_m(n) = \begin{cases} 1 & \text{if } m \mid n, \\ 0 & \text{if } m \nmid n. \end{cases} \] The formula for $ f(n) $ can now be written as: \[ f(n) = \begin{cases} 0 & \text{if } I_5(n) = 0 \text{ and } I_3(n) = 0, \\ 1 & \text{if } I_5(n) = 0 \text{ and } I_3(n) = 1, \\ 2 & \text{if } I_5(n) = 1 \text{ and } I_3(n) = 0, \\ 3 & \text{if } I_5(n) = 1 \text{ and } I_3(n) = 1. \end{cases} \] Do you see a pattern? Here is the same function written as a table:

\( I_5(n) \)	\( I_3(n) \)	\( f(n) \)
\( 0 \)	\( 0 \)	\( 0 \)
\( 0 \)	\( 1 \)	\( 1 \)
\( 1 \)	\( 0 \)	\( 2 \)
\( 1 \)	\( 1 \)	\( 3 \)

$ I_5(n) $

$ I_3(n) $

$ f(n) $

$ 0 $

$ 1 $

$ 0 $

$ 2 $

$ 1 $

$ 3 $

Do you see it now? If we treat the values in the first two columns as binary digits and the values in the third column as decimal numbers, then in each row the first two columns give the binary representation of the number in the third column. For example, $ 3_{10} = 11_2 $ and indeed in the last row of the table, we see the bits $ 1 $ and $ 1 $ in the first two columns and the number $ 3 $ in the last column. In other words, writing the binary digits $ I_5(n) $ and $ I_3(n) $ side by side gives us the binary representation of $ f(n). $ Therefore \[ f(n) = 2 \, I_5(n) + I_3(n). \] We can now write a small program to demonstrate this formula:

for n in range(1, 101):
    s = [n, 'Fizz', 'Buzz', 'FizzBuzz']
    i = (n % 3 == 0) + 2 * (n % 5 == 0)
    print(s[i])

We can make it even shorter at the cost of some clarity:

for n in range(1, 101):
    print([n, 'Fizz', 'Buzz', 'FizzBuzz'][(n % 3 == 0) + 2 * (n % 5 == 0)])

What we have obtained so far is pretty good. While there is no universal definition of a closed-form expression, I think most people would agree that the indicator functions as defined above are simple enough to be permitted in a closed-form expression.

Complex Exponentials

In the previous section, we obtained the formula \[ f(n) = I_3(n) + 2 \, I_5(n) \] which we then used as an index to look up the text to be printed. We also argued that this is a pretty good closed-form expression already.

However, in the interest of making things more complicated, we must ask ourselves: What if we are not allowed to use the indicator functions? What if we must adhere to the commonly accepted meaning of a closed-form expression which allows only finite combinations of basic operations such as addition, subtraction, multiplication, division, integer exponents and roots with integer index as well as functions such as exponentials, logarithms and trigonometric functions. It turns out that the above formula can be rewritten using only addition, multiplication, division and the cosine function. Let us begin the translation. Consider the sum \[ S_m(n) = \sum_{k = 0}^{m - 1} e^{i 2 \pi k n / m}, \] where $ i $ is the imaginary unit and $ n $ and $ m $ are integers. This is a geometric series in the complex plane with ratio $ r = e^{i 2 \pi n / m}. $ If $ n $ is a multiple of $ m , $ then $ n = cm $ for some integer $ c $ and we get \[ r = e^{i 2 \pi n / m} = e^{i 2 \pi c} = 1. \] Therefore, when $ n $ is a multiple of $ m, $ we get \[ S_m(n) = \sum_{k = 0}^{m - 1} e^{i 2 \pi k n / m} = \sum_{k = 0}^{m - 1} 1^k = m. \] If $ n $ is not a multiple of $ m, $ then $ r \ne 1 $ and the geometric series becomes \[ S_m(n) = \frac{r^m - 1}{r - 1} = \frac{e^{i 2 \pi n} - 1}{e^{i 2 \pi n / m} - 1} = 0. \] Therefore, \[ S_m(n) = \begin{cases} m & \text{if } m \mid n, \\ 0 & \text{if } m \nmid n. \end{cases} \] Dividing both sides by $ m, $ we get \[ \frac{S_m(n)}{m} = \begin{cases} 1 & \text{if } m \mid n, \\ 0 & \text{if } m \nmid n. \end{cases} \] But the right-hand side is $ I_m(n). $ Therefore \[ I_m(n) = \frac{S_m(n)}{m} = \frac{1}{m} \sum_{k = 0}^{m - 1} e^{i 2 \pi k n / m}. \]

Cosines

We begin with Euler's formula \[ e^{i x} = \cos x + i \sin x \] where $ x $ is a real number. From this formula, we get \[ e^{i x} + e^{-i x} = 2 \cos x. \] Therefore \begin{align*} I_3(n) &= \frac{1}{3} \sum_{k = 0}^2 e^{i 2 \pi k n / 3} \\ &= \frac{1}{3} \left( 1 + e^{i 2 \pi n / 3} + e^{i 4 \pi n / 3} \right) \\ &= \frac{1}{3} \left( 1 + e^{i 2 \pi n / 3} + e^{-i 2 \pi n / 3} \right) \\ &= \frac{1}{3} + \frac{2}{3} \cos \left( \frac{2 \pi n}{3} \right). \end{align*} The third equality above follows from the fact that $ e^{i 4 \pi n / 3} = e^{i 6 \pi n / 3} e^{-i 2 \pi n / 3} = e^{i 2 \pi n} e^{-i 2 \pi n/3} = e^{-i 2 \pi n / 3} $ when $ n $ is an integer.

The function above is defined for integer values of $ n $ but we can extend its formula to real $ x $ and plot it to observe its shape between integers. As expected, the function takes the value $ 1 $ whenever $ x $ is an integer multiple of $ 3 $ and $ 0 $ whenever $ x $ is an integer not divisible by $ 3. $

Graph of $ \frac{1}{3} + \frac{2}{3} \cos \left( \frac{2 \pi x}{3} \right) $

Similarly, \begin{align*} I_5(n) &= \frac{1}{5} \sum_{k = 0}^4 e^{i 2 \pi k n / 5} \\ &= \frac{1}{5} \left( 1 + e^{i 2 \pi n / 5} + e^{i 4 \pi n / 5} + e^{i 6 \pi n / 5} + e^{i 8 \pi n / 5} \right) \\ &= \frac{1}{5} \left( 1 + e^{i 2 \pi n / 5} + e^{i 4 \pi n / 5} + e^{-i 4 \pi n / 5} + e^{-i 2 \pi n / 5} \right) \\ &= \frac{1}{5} + \frac{2}{5} \cos \left( \frac{2 \pi n}{5} \right) + \frac{2}{5} \cos \left( \frac{4 \pi n}{5} \right). \end{align*} Extending this expression to real values of $ x $ allows us to plot its shape as well. Once again, the function takes the value $ 1 $ at integer multiples of $ 5 $ and $ 0 $ at integers not divisible by $ 5. $

Graph of $ \frac{1}{5} + \frac{2}{5} \cos \left( \frac{2 \pi x}{5} \right) + \frac{2}{5} \cos \left( \frac{4 \pi x}{5} \right) $

Recall that we expressed $ f(n) $ as \[ f(n) = I_3(n) + 2 \, I_5(n). \] Substituting these trigonometric expressions yields \[ f(n) = \frac{1}{3} + \frac{2}{3} \cos \left( \frac{2 \pi n}{3} \right) + 2 \cdot \left( \frac{1}{5} + \frac{2}{5} \cos \left( \frac{2 \pi n}{5} \right) + \frac{2}{5} \cos \left( \frac{4 \pi n}{5} \right) \right). \] A straightforward simplification gives \[ f(n) = \frac{11}{15} + \frac{2}{3} \cos \left( \frac{2 \pi n}{3} \right) + \frac{4}{5} \cos \left( \frac{2 \pi n}{5} \right) + \frac{4}{5} \cos \left( \frac{4 \pi n}{5} \right). \] We can extend this expression to real $ x $ and plot it as well. The resulting curve takes the values $ 0, 1, 2 $ and $ 3 $ at integer points, as desired.

Graph of $ \frac{11}{15} + \frac{2}{3} \cos \left( \frac{2 \pi x}{3} \right) + \frac{4}{5} \cos \left( \frac{2 \pi x}{5} \right) + \frac{4}{5} \cos \left( \frac{4 \pi x}{5} \right) $

Now we can write our Python program as follows:

from math import cos, pi
for n in range(1, 101):
    s = [n, 'Fizz', 'Buzz', 'FizzBuzz']
    i = round(11 / 15 + (2 / 3) * cos(2 * pi * n / 3)
                      + (4 / 5) * cos(2 * pi * n / 5)
                      + (4 / 5) * cos(4 * pi * n / 5))
    print(s[i])

Discrete Fourier Transform

The keen-eyed might notice that the expression we obtained for $ f(n) $ is a discrete Fourier series. This is not surprising, since the output of a Fizz Buzz program depends only on $ n \bmod 15. $ Any function on a finite cyclic group can be written exactly as a finite Fourier expansion. In this section, we obtain $ f(n) $ using the discrete Fourier transform. It is worth mentioning that the calculations presented here are quite tedious to do by hand. Nevertheless, this section offers a glimpse of how such calculations are performed. By the end, we will arrive at exactly the same $ f(n) $ as before. There is nothing new to discover here. We simply obtain the same result by a more direct but more laborious method. If this doesn't sound interesting, you may safely skip the subsections that follow.

One Period of Fizz Buzz

We know that $ f(n) $ is a periodic function with period $ 15. $ To apply the discrete Fourier transform, we look at one complete period of the function using the values $ n = 0, 1, \dots, 14. $ Over this period, we have: \begin{array}{c|ccccccccccccccc} n & 0 & 1 & 2 & 3 & 4 & 5 & 6 & 7 & 8 & 9 & 10 & 11 & 12 & 13 & 14 \\ \hline f(n) & 3 & 0 & 0 & 1 & 0 & 2 & 1 & 0 & 0 & 1 & 2 & 0 & 1 & 0 & 0 \end{array} The discrete Fourier series of $ f(n) $ is \[ f(n) = \sum_{k = 0}^{14} c_k \, e^{i 2 \pi k n / 15} \] where the Fourier coefficients $ c_k $ are given by the discrete Fourier transform \[ c_k = \frac{1}{15} \sum_{n = 0}^{14} f(n) e^{-i 2 \pi k n / 15}. \] for $ k = 0, 1, \dots, 14. $ The formula for $ c_k $ is called the discrete Fourier transform (DFT). The formula for $ f(n) $ is called the inverse discrete Fourier transform (IDFT).

Fourier Coefficients

Let $ \omega = e^{-i 2 \pi / 15}. $ Then using the values of $ f(n) $ from the table above, the DFT becomes: \[ c_k = \frac{3 + \omega^{3k} + 2 \omega^{5k} + \omega^{6k} + \omega^{9k} + 2 \omega^{10k} + \omega^{12k}}{15}. \] Substituting $ k = 0, 1, 2, \dots, 14 $ into the above equation gives us the following Fourier coefficients: \begin{align*} c_{0} &= \frac{11}{15}, \\ c_{3} &= c_{6} = c_{9} = c_{12} = \frac{2}{5}, \\ c_{5} &= c_{10} = \frac{1}{3}, \\ c_{1} &= c_{2} = c_{4} = c_{7} = c_{8} = c_{11} = c_{13} = c_{14} = 0. \end{align*} Calculating these Fourier coefficients by hand can be rather tedious. In practice they are almost always calculated using numerical software, computer algebra systems or even simple code such as the example here: fizz-buzz-fourier.py.

Inverse Transform

Once the coefficients are known, we can substitute them into the inverse transform introduced earlier to obtain \begin{align*} f(n) &= \sum_{k = 0}^{14} c_k \, e^{i 2 \pi k n / 15} \\[1.5em] &= \frac{11}{15} + \frac{2}{5} \left( e^{i 2 \pi \cdot 3n / 15} + e^{i 2 \pi \cdot 6n / 15} + e^{i 2 \pi \cdot 9n / 15} + e^{i 2 \pi \cdot 12n / 15} \right) \\ & \phantom{=\frac{11}{15}} + \frac{1}{3} \left( e^{i 2 \pi \cdot 5n / 15} + e^{i 2 \pi \cdot 10n / 15} \right) \\[1em] &= \frac{11}{15} + \frac{2}{5} \left( e^{i 2 \pi \cdot 3n / 15} + e^{i 2 \pi \cdot 6n / 15} + e^{-i 2 \pi \cdot 6n / 15} + e^{-i 2 \pi \cdot 3n / 15} \right) \\ & \phantom{=\frac{11}{15}} + \frac{1}{3} \left( e^{i 2 \pi \cdot 5n / 15} + e^{-i 2 \pi \cdot 5n / 15} \right) \\[1em] &= \frac{11}{15} + \frac{2}{5} \left( 2 \cos \left( \frac{2 \pi n}{5} \right) + 2 \cos \left( \frac{4 \pi n}{5} \right) \right) \\ & \phantom{=\frac{11}{15}} + \frac{1}{3} \left( 2 \cos \left( \frac{2 \pi n}{3} \right) \right) \\[1em] &= \frac{11}{15} + \frac{4}{5} \cos \left( \frac{2 \pi n}{5} \right) + \frac{4}{5} \cos \left( \frac{4 \pi n}{5} \right) + \frac{2}{3} \cos \left( \frac{2 \pi n}{3} \right). \end{align*} This is exactly the same expression for $ f(n) $ we obtained in the previous section. We see that the Fizz Buzz index function $ f(n) $ can be expressed precisely using the machinery of Fourier analysis.

Conclusion

To summarise, we have defined the Fizz Buzz sequence as \[ (s_{f(n)}(n))_{n = 1}^{\infty} \] where \[ f(n) = \frac{11}{15} + \frac{2}{3} \cos \left( \frac{2 \pi n}{3} \right) + \frac{4}{5} \cos \left( \frac{2 \pi n}{5} \right) + \frac{4}{5} \cos \left( \frac{4 \pi n}{5} \right). \] and $ s_0(n) = n, $ $ s_1(n) = \mathtt{Fizz}, $ $ s_2(n) = \mathtt{Buzz} $ and $ s_3(n) = \mathtt{FizzBuzz}. $ A Python program to print the Fizz Buzz sequence based on this definition was presented earlier. That program can be written more succinctly as follows:

from math import cos, pi
for n in range(1, 101):
    print([n, 'Fizz', 'Buzz', 'FizzBuzz'][round(11 / 15 + (2 / 3) * cos(2 * pi * n / 3) + (4 / 5) * (cos(2 * pi * n / 5) + cos(4 * pi * n / 5)))])

We can also wrap this up nicely in a shell one-liner, in case you want to share it with your friends and family and surprise them:

python3 -c 'from math import cos, pi; [print([n, "Fizz", "Buzz", "FizzBuzz"][round(11/15 + (2/3) * cos(2*pi*n/3) + (4/5) * (cos(2*pi*n/5) + cos(4*pi*n/5)))]) for n in range(1, 101)]'

We have taken a simple counting game and turned it into a trigonometric construction consisting of a discrete Fourier series with three cosine terms and four coefficients. None of this makes Fizz Buzz any easier. Quite the contrary. But it does show that every $ \mathtt{Fizz} $ and $ \mathtt{Buzz} $ now owes its existence to a particular set of Fourier coefficients. We began with the modest goal of making this simple problem more complicated. I think it is safe to say that we did not fall short.

Mutually Attacking Knights

2025-08-11T00:00:00Z

How many different ways can we place two identical knights on an $ n \times n $ chessboard so that they attack each other? Can we find a closed-form expression that gives this number? This is the problem we explore in this article.

Introduction
Counting Placements as the Board Grows
Counting Placements for Each Square
Counting Placements From Minimal Attack Sections
- Minimal Attack Sections
- Closed Form Expression
References

Introduction

A knight moves two squares in one direction, then one square perpendicular to it, forming an L-shaped path. If a piece occupies the destination square, the knight captures it. If two knights are placed such that each can capture the other in a single move, then we say the knights attack each other. We want to determine the number of ways to place two identical knights on an $ n \times n $ chessboard so that they attack each other.

Two knights attacking each other

The above illustration shows just one of several ways two knights can attack each other on a $ 3 \times 3 $ board. There are, in fact, a total of eight such placements, shown below.

All $ 8 $ ways two identical knights can attack each other on a $ 3 \times 3 $ board.

Let $ f(n) $ denote the number of ways we can place two identical knights on an $ n \times n $ chessboard such that they attack each other, where $ n \ge 1. $

A $ 1 \times 1 $ board has room for only one knight, so we define $ f(1) = 0. $ On a $ 2 \times 2 $ board, a knight cannot move two squares in any direction and therefore cannot attack. Therefore, $ f(2) = 0. $ To summarise, \[ f(1) = f(2) = 0. \] From the illustration above, we see that $ f(3) = 8. $ We want to find a closed-form expression for $ f(n). $

We will analyse this problem from various perspectives. We begin with a couple of needlessly complicated approaches, followed by a simple and elegant solution. While I personally enjoy these long-winded explorations, if you prefer a more direct solution, please skip ahead to Counting Placements From Minimal Attack Sections.

Before we proceed, let us introduce the term mutually attacking knight placement to mean a placement of two knights on the chessboard such that they attack each other. Unless stated otherwise, the two knights are identical. This term will serve as a convenient shorthand for referring to such placements.

Counting Placements as the Board Grows

We now turn to the needlessly complicated solution promised in the previous section. We analyse the new mutually attacking knight placements introduced when an existing board is enlarged by adding a row and a column.

Let us define \[ \Delta f(n) = f(n) - f(n - 1) \] for $ n \ge 2, $ so that $ \Delta f(n) $ denotes the new mutually attacking knight placements introduced when an $ (n - 1) \times (n - 1) $ board is expanded to size $ n \times n $ by adding one row and one column.

For brevity, we will avoid restating the process of enlarging an $ (n - 1) \times (n - 1) $ board to an $ n \times n $ board by adding one row and one column whenever we refer to new placements. Instead, we use the term new placements on an $ n \times n $ board to refer to $ \Delta f(n). $ It is to be understood that these new placements are the mutually attacking knight placements introduced by enlarging the board from size $ (n - 1) \times (n - 1) $ to $ n \times n. $

Without loss of generality, suppose the new row and column are added to the bottom and right respectively. We already know that \begin{align*} \Delta f(2) & = f(2) - f(1) = 0 - 0 = 0, \\ \Delta f(3) & = f(3) - f(2) = 8 - 0 = 8. \\ \end{align*} We will now find $ \Delta f(n) $ for $ n \ge 4. $ To do this, we first categorise the newly added squares due to board expansion, into four types, as illustrated below.

					A
					B
					C
					C
					D
A	B	C	C	D	A

New squares, labelled by type, as the board size increases from $ 5 \times 5 $ to $ 6 \times 6 $

Here is a brief description of each square type:

Type A squares are the three new corner squares.
Type B squares are the two new squares adjacent to type A squares at the top and left edges.
Type C squares are the new squares that are not adjacent to any type A square. If the new board has dimensions $ n \times n, $ where $ n \ge 4, $ then there are exactly $ 2n - 8 $ squares of type C.
Type D squares are the two new squares adjacent to the bottom-right type A square.

We now calculate how many new mutually attacking knight placements are introduced by these additional squares as the board expands. We proceed with a case-by-case analysis for each square type.

Type A Squares

There are three squares of type A. If we place one knight on a type A square, there are two positions for the second knight such that the two knights attack each other.


		✗
			✗

Knights on type A squares, with squares attacked by the top knight marked with crosses

Since there are three such squares, we get a total of $ 3 \times 2 = 6 $ new mutually attacking knight placements.

Type B Squares

There are two squares of type B. If we place one knight on a type B square, there are three positions for the second knight such that the two knights attack each other.

		✗

		✗
			✗

Knights on type B squares, with squares attacked by the top knight marked with crosses

Since there are two such squares, we get a total of $ 2 \times 3 = 6 $ new mutually attacking knight placements.

Type C Squares

The number of type C squares depends on the board size. When we increase the size of a board from $ (n - 1) \times (n - 1) $ to $n \times n, $ where $ n \ge 4, $ we add $ n^2 - (n - 1)^2 = 2n - 1 $ new squares. Among these, $ 3 $ are of type A, $ 2 $ are of type B and $ 2 $ are of type D. That gives us a total of $ 7 $ squares of type A, B or D. The remaining $ 2n - 1 - 7 = 2n - 8 $ squares are therefore of type C. Note that when the board size increases from $ 3 \times 3 $ to $ 4 \times 4, $ there are $ 2 \times 4 - 8 = 0 $ squares of type C.

			A
			B
			D
A	B	D	A

A $ 4 \times 4 $ board has no type C squares.

However, for a board of size $ 5 \times 5 $ or greater, there is a positive number of type C squares since $ 2n - 8 \gt 0 $ if and only if $ n \gt 4. $

				A
				B
				C
				D
A	B	C	D	A

A $ 5 \times 5 $ board has one type C square.

If we place one knight on a type C square, there are four positions for the second knight such that the two knights attack each other.

			✗
		✗

		✗
			✗

Knights on type C squares, with squares attacked by the top knight marked with crosses

Since there are $ 2n - 8 $ such squares, we get a total of $ 4(2n - 8) = 8(n - 4) $ new mutually attacking knight placements.

Type D Squares

There are two squares of type D. As with type B squares, placing one knight on a type D square yields three positions for the second knight such that the two knights attack each other. This gives $ 2 \times 3 = 6 $ potentially new placements.


			✗
		✗

		✗

Knights on type D squares, with squares attacked by the top knight marked with crosses

However, unlike type B squares, not all of these placements are new. The two placements where one knight is on the right edge and the other on the bottom edge were already counted in a previous subsection.

Placements already counted while analysing placements involving a knight on a type B square of the $ 4 \times 4 $ board

For example, when we increase the board size from $ 3 \times 3 $ to $ 4 \times 4, $ both the placements described in the previous paragraph appear while analysing the placements with a knight on a type B square. More generally, for any board of size $ n \times n $ with $ n \ge 5, $ these placements occur while analysing the placements with a knight on a type C square. Therefore the total number of new mutually attacking knight placements is $ 2 \times 3 - 2 = 4. $

Placements already counted while analysing placements involving a knight on a type C square of an $ n \times n $ board, where $ n \ge 5 $

Another way to describe this result is to observe that when one knight is placed on a type D square, only two positions for the second knight yield new mutually attacking knight placements. Since there are two type $ D $ squares, we get a total of $ 2 \times 2 = 4 $ new mutually attacking knight placements.


			✗
		✗

Knights on type D squares, with squares attacked by the top knight that yield new mutually attacking knight placements marked with crosses

Closed Form Expression

If we add the number of new mutually attacking knight placements found in each of the cases above, we get \[ \Delta f(n) = 6 + 6 + 8(n - 4) + 4 = 8(n - 2) \] new mutually attacking knight placements as the board size increases from $ (n - 1) \times (n - 1) $ to $ n \times n, $ where $ n \ge 4. $ We already know that $ \Delta f(2) = 0 $ and $ \Delta f(3) = 8. $ Surprisingly, the above formula produces the correct values for those cases as well. Therefore, we can generalise this result as \[ \Delta f(n) = 8(n - 2) \] for all $ n \ge 2. $ We can now calculate $ f(n) $ for $ n \ge 1 $ as follows: \begin{align*} f(n) & = \sum_{k = 1}^n f(k) - \sum_{k = 1}^{n - 1} f(k) \\ & = \sum_{k = 1}^n f(k) - \sum_{k = 2}^n f(k - 1) \\ & = f(1) + \sum_{k = 2}^n (f(k) - f(k - 1)) \\ & = f(1) + \sum_{k = 2}^n \Delta f(k) \\ & = 0 + \sum_{k = 2}^n 8(k - 2) \\ & = 8 \sum_{k = 0}^{n - 2} k \\ & = \frac{8(n - 2)(n - 1)}{2} \\ & = 4(n - 1)(n - 2). \end{align*} To summarise, we now have a closed form expression for $ f(n). $ For all $ n \ge 1, $ we have \[ f(n) = 4(n - 1)(n - 2). \]

Counting Placements for Each Square

The previous section took a long-winded path to arrive at a closed form expression for $ f(n). $ In this section, we will reach the same result that is still a bit drawn out, but not quite as much as before.

This time, instead of looking only at the new squares created when the board grows, we consider every square on the board. To make the counting easier, we no longer treat the knights as identical. We first work with two distinct knights, count the mutually attacking knight placements and then divide the total by $ 2 $ to get the result for identical knights.

Attacking Degrees of Squares

Here, we introduce the term attacking degree of a square to mean the number of squares a knight can move to from that square in a single move. In other words, the attacking degree of a square is the number of squares that would be attacked if a knight were placed on it. For example, the corner squares have an attacking degree of $ 2. $


		✗
	✗

The attacking degree of a corner square is $ 2 $ since a knight can attack two squares from it

Let us now label each square with its attacking degree. A $ 1 \times 1 $ board has only one square of attacking degree $ 0 $ since a knight placed on it has nothing to attack. Similarly, each square of a $ 2 \times 2 $ board has attacking degree $ 0 $ too.

0	0
0	0

Attacking degrees of all squares are zero on $ 1 \times 1 $ and $ 2 \times 2 $ boards

On a $ 3 \times 3 $ board, all squares have attacking degree $ 2 $ except the centre square, whose attacking degree is $ 0. $ In other words, placing a knight on any square other than the middle one gives exactly two possible positions for the other knight so that they attack each other.

2	2	2
2	0	2
2	2	2

Attacking degrees of all squares on a $ 3 \times 3 $ board

With eight such squares, we get $ 8 \times 2 = 16 $ mutually attacking knight placements when the two knights are distinct. If we divide this number by $ 2, $ we get $ 8 $ which is indeed the number of mutually attacking knight placements on a $ 3 \times 3 $ board when the two knights are identical. This matches the earlier result $ f(3) = 8. $

From Attacking Degrees to Counting Placements

Let $ g(n) $ be the number of mutually attacking knight placements on an $ n \times n $ board when the knights are distinct. Then $ g(n) $ is simply the sum of the attacking degrees of all squares on the board. As before, let $ f(n) $ denote the number of mutually attacking knight placements on an $ n \times n $ board when the two knights are identical. We will now show that $ f(n) = g(n)/2. $

Label all squares of the $ n \times n $ board as $ S_1, S_2, \dots, S_{n^2} $ in any fixed order. Label the two distinct knights as $ N_1 $ and $ N_2. $ We represent each mutually attacking knight placement as an ordered pair $ (S_i, S_j) $ if $ N_1 $ is on $ S_i $ and $ N_2 $ is on $ S_j, $ with the two knights attacking each other. Here $ 1 \le i, j \le n^2 $ and $ i \ne j. $

Let $ M $ be the set of all mutually attacking knight placements for distinct knights on an $ n \times n $ board. Then \[ g(n) = \lvert M \rvert. \] If $ (S_i, S_j) $ is a mutually attacking knight placement of the distinct knights $ N_1 $ and $ N_2 $ for some $ i $ and $ j $ with $ 1 \le i, j \le n^2 $ and $ i \ne j, $ then $ (S_j, S_i) $ is also a mutually attacking knight placement, since swapping the positions of the two mutually attacking knights still yields a valid mutually attacking placement. Therefore \[ (S_i, S_j) \in M \iff (S_j, S_i) \in M. \] Each ordered placement $ (S_i, S_j) $ in $ M $ is thus paired with the ordered placement $ (S_j, S_i). $ When the knights are identical, the two arrangements are indistinguishable and count as one placement. Hence, the number of mutually attacking placements for identical knights is exactly half of the number for distinct knights, i.e. \[ f(n) = \frac{g(n)}{2}. \] The next subsection focuses on calculating $ g(n), $ from which $ f(n) $ follows immediately by the above formula.

Closed Form Expression

As noted in the previous section, the number of mutually attacking knight placements for two distinct knights on an $ n \times n $ board is simply the sum of attacking degrees of all squares on the board. If we label each square as discussed in the previous section and use the notation $ \deg(S_i) $ for the attacking degree of the square labelled $ S_i, $ where $ 1 \le i \le n^2, $ then \[ g(n) = \sum_{i=1}^{n^2} \deg(S_i). \] Recall that the attacking degree of a square is the number of squares a knight could attack if it were placed there. Earlier, we saw that on a $ 3 \times 3 $ board, all squares except the centre one have attacking degree $ 2, $ which gives $ g(3) = 8 \times 2 = 16 $ and $ f(3) = g(3)/2 = 8. $ Let us now write down the attacking degrees of all squares on a $ 4 \times 4 $ board.

2	3	3	2
3	4	4	3
3	4	4	3
2	3	3	2

Attacking degrees of all squares on a $ 4 \times 4 $ board

From the above illustration we get \begin{align*} g(4) & = 4 \times 2 + 8 \times 3 + 4 \times 4 = 48, \\ f(4) & = g(4)/2 = 24. \end{align*} A more general pattern emerges if we consider a larger board, such as a $ 6 \times 6 $ board.

2	3	4	4	3	2
3	4	6	6	4	3
4	6	8	8	6	4
4	6	8	8	6	4
3	4	6	6	4	3
2	3	4	4	3	2

Attacking degrees of all squares on a $ 6 \times 6 $ board

From this illustration, we get \begin{align*} g(6) & = 4 \times 2 + 8 \times 3 + 12 \times 4 + 8 \times 6 + 4 \times 8 = 160. \\ f(6) & = g(6)/2 = 80. \end{align*} Let us find a general formula now for $ n \ge 4. $ We introduce one more notation. Let $ D_k(n) $ denote the sum of the attacking degrees of all squares of attacking degree $ k $ on an $ n \times n $ board, i.e. \[ D_k(n) = \sum_{\mathclap{\deg(S_i) = k}} \deg(S_i). \] Since the only attacking degrees the squares can have are $ 2, 3, 4, 6 $ and $ 8, $ the sum of the attacking degrees of all squares can be written as \[ g(n) = D_2(n) + D_3(n) + D_4(n) + D_6(n) + D_8(n). \] There are exactly four squares of attacking degree $ 2. $ These are the corner ones. Therefore, \[ D_2(n) = 4 \times 2 = 8. \] The eight squares adjacent to the corner squares have attacking degree $ 3. $ Therefore, \[ D_3(n) = 8 \times 3 = 24. \] Let us define an inner corner square as one that shares a corner with a corner square but not an edge with it. There are four inner corner squares and each has attacking degree $ 4. $ Further, each row and column on the outer edge contains $ n - 4 $ additional squares with attacking degree $ 4. $ Therefore, \[ D_4(n) = (4 + 4(n - 4))(4) = 16(n - 3). \] Consider a row or column that contains two inner corner squares of attacking degree $ 4. $ All $ n - 4 $ squares between the inner corner squares have attacking degree $ 6. $ There are two such rows and two such columns. Therefore, \[ D_6(n) = 4(n - 4)(6) = 24(n - 4). \] We have counted the attacking degrees of all squares in the first two columns and rows as well as the last two columns and rows. We are left with $ (n - 4)^2 $ squares in the middle and they all have attacking degree $ 8. $ Therefore, \[ D_8(n) = 8(n - 4)^2. \] Therefore, \begin{align*} g(n) & = D_2(n) + D_3(n) + D_4(n) + D_6(n) + D_8(n) \\ & = 8 + 24 + 16(n - 3) + 24(n - 4) + 8(n - 4)^2 \\ & = 8(n - 1)(n - 2). \end{align*} Even though we assumed $ n \ge 4 $ while obtaining the above formula, remarkably, it gives us the correct values for $ n = 1, 2 $ and $ 3. $ The number of mutually attacking knight placements for distinct knights on an $ n \times n $ board is $ 0 $ if $ n = 1 $ or $ 2. $ It is $ 16 $ if $ n = 3. $ Indeed the above formula gives us \[ g(1) = g(2) = 0, \quad g(3) = 16. \] Therefore, we can now generalise the above result as \[ g(n) = 8(n - 1)(n - 2) \] for all $ n \ge 1. $ Therefore, for all $ n \ge 1, $ \[ f(n) = \frac{g(n)}{2} = 4(n - 1)(n - 2). \]

Counting Placements From Minimal Attack Sections

Finally, in this section, we take a look at a simple and elegant solution that arrives at the closed-form solution in a more direct manner. The analysis begins by looking at the smallest section of the board where two knights can attack each other.

Minimal Attack Sections

Consider a $ 2 \times 3 $ section of a board of size $ 3 \times 3 $ or larger. Such a section has exactly two mutually attacking knight placements.

Two mutually attacking knight placements on a $ 2 \times 3 $ section of a board

Similarly, a $ 3 \times 2 $ section of a board also has exactly two mutually attacking knight placements.

Two mutually attacking knight placements on a $ 3 \times 2 $ section of a board

We call these $ 2 \times 3 $ and $ 3 \times 2 $ sections the minimal attack sections of a board, since no smaller section can contain a mutually attacking knight placement.

Two distinct $ 2 \times 3 $ sections can share at most a $ 1 \times 3 $ section, which is smaller than a minimal attack section. Consequently, no mutually attacking knight placement can be common to two distinct $ 2 \times 3 $ sections of a board.

Similarly, two distinct $ 3 \times 2 $ sections can share at most a $ 3 \times 1 $ section, again too small to contain a minimal attack section. Therefore, they share no mutually attacking knight placement.

A $ 2 \times 3 $ section and a $ 3 \times 2 $ section can share at most a $ 2 \times 2 $ section, which is still smaller than a minimal attack section, so they share no mutually attacking knight placement either.

To summarise, any two minimal attack sections of the board yield distinct pairs of mutually attacking knight placements. The total number of such placements is therefore exactly twice the number of minimal attack sections on the board.

Closed Form Expression

In an $ n \times n $ board where $ n \ge 3, $ the left edge of a $ 2 \times 3 $ section can be placed in any one of the first $ n - 2 $ columns of the board. Similarly, the top edge of such a section can be placed in any one of the first $ n - 1 $ rows of the board. Therefore, the total number of distinct $ 2 \times 3 $ sections on the board is $ (n - 2)(n - 1). $

By similar reasoning, the number of distinct $ 3 \times 2 $ sections on an $ n \times n $ board, where $ n \ge 3, $ is also $ (n - 1)(n - 2). $

Let $ h(n) $ be the total number of minimal attack sections we can find on an $ n \times n $ board where $ n \ge 1. $ From the discussion in the previous two paragraphs, we know that $ h(n) = 2(n - 1)(n - 2) $ for $ n \ge 3. $ Further, this formula for $ h(n) $ works for $ n = 1 $ and $ n = 2 $ as well since $ h(1) = h(2) = 0 $ and indeed a $ 1 \times 1 $ board or a $ 2 \times 2 $ board is too small to contain any minimal attack sections. Therefore, for all $ n \ge 1, $ we get \[ h(n) = 2(n - 1)(n - 2). \] Since each minimal attack section yields two mutually attacking knight placements, the total number of mutually attacking knight placements on an $ n \times n $ board is \[ f(n) = 2h(n) = 4(n - 1)(n - 2) \] for all $ n \ge 1. $

References

Two Knights from the CSES Problem Set
Knight Graph by Eric W. Weisstein
OEIS Entry A033996 by N. J. A. Sloane
OEIS Entry A172132 by Vaclav Kotesovec

Read on website | #mathematics | #puzzle

Zigzag Number Spiral

2025-07-27T00:00:00Z

Consider the following infinite grid of numbers, where the numbers are arranged in a spiral-like manner, but the spiral reverses direction each time it reaches the edge of the grid: \begin{array}{rcrcrcrcrl} 1 & \rt & 2 & \sp & 9 & \rt & 10 & \sp & 25 & \cd \\ \sp & \sp & \dn & \sp & \up & \sp & \dn & \sp & \up & \sp \\ 4 & \lf & 3 & \sp & 8 & \sp & 11 & \sp & 24 & \cd \\ \dn & \sp & \sp & \sp & \up & \sp & \dn & \sp & \up & \sp \\ 5 & \rt & 6 & \rt & 7 & \sp & 12 & \sp & 23 & \cd \\ \sp & \sp & \sp & \sp & \sp & \sp & \dn & \sp & \up & \sp \\ 16 & \lf & 15 & \lf & 14 & \lf & 13 & \sp & 22 & \cd \\ \dn & \sp & \sp & \sp & \sp & \sp & \sp & \sp & \up & \sp \\ 17 & \rt & 18 & \rt & 19 & \rt & 20 & \rt & 21 & \cd \\ \vd & \sp & \vd & \sp & \vd & \sp & \vd & \sp & \vd & \dd \end{array} Can we find a closed-form expression that tells us the number at the $ m $th row and $ n $th column?

Introduction
Patterns on the Edges
Patterns on the Diagonal
References

Introduction

Before we explore this problem further, let us rewrite the zigzag number spiral grid in a cleaner form, omitting the arrows: \begin{array}{rrrrrl} 1 & 2 & 9 & 10 & 25 & \cd \\ 4 & 3 & 8 & 11 & 24 & \cd \\ 5 & 6 & 7 & 12 & 23 & \cd \\ 16 & 15 & 14 & 13 & 22 & \cd \\ 17 & 18 & 19 & 20 & 21 & \cd \\ \vd & \vd & \vd & \vd & \vd & \dd \end{array} Let $ f(m, n) $ denote the number at the $ m $th row and $ n $th column. For example, $ f(1, 1) = 1 $ and $ f(2, 5) = 24. $ We want to find a closed-form expression for $ f(m, n). $

Let us first clarify what we mean by a closed-form expression. There is no universal definition of a closed-form expression, but the term typically refers to a mathematical expression involving variables and constants, built using a finite combination of basic operations: addition, subtraction, multiplication, division, integer exponents, roots with integer index and functions such as exponentials, logarithms and trigonometric functions.

In this article, however, we need only addition, subtraction, division, squares and square roots. This may be a bit of a spoiler, but I must mention that the $ \max $ function appears in the closed-form expressions we are about to see. If you are concerned about whether functions like $ \max $ and $ \min $ are permitted in such expressions, note that \begin{align*} \max(m, n) & = \frac{m + n + \sqrt{(m - n)^2}}{2}, \\ \min(m, n) & = \frac{m + n - \sqrt{(m - n)^2}}{2}. \end{align*} So $ \max $ and $ \min $ are simply shorthand for expressions involving addition, subtraction, division, squares and square roots. In the discussion that follows, we will use only the $ \max $ function.

Patterns on the Edges

Let us begin by analysing the edge numbers. Number the rows as $ 1, 2, 3 \dots $ and the columns likewise. Observe where the spiral touches the left edge and changes direction. This happens only on even-numbered rows. Similarly, each time the spiral touches the top edge and changes direction, it does so on odd-numbered columns. In the following subsections, we take a closer look at this behaviour of the spiral.

I should mention that this section takes a rather long path to arrive at the closed-form solution. Personally, I enjoy such long tours. If you prefer a more direct approach, feel free to skip ahead to Patterns on the Diagonal for a shorter discussion that reaches the same result.

Computing Edge Numbers

Each time the spiral reaches the left edge of the grid, it does so at some $ m $th row where $ m $ is even. The $ m \times m $ subgrid formed by the first $ m $ rows and the first $ m $ columns contains $ m^2 $ consecutive numbers. Since the numbers strictly increase as the spiral grows, the largest of these $ m^2 $ numbers must appear at the position where the spiral touches the left edge. This is illustrated in the figure below.

\begin{array}{rrrr:rl} 1 & 2 & 9 & 10 & 25 & \cd \\ 4 & 3 & 8 & 11 & 24 & \cd \\ 5 & 6 & 7 & 12 & 23 & \cd \\ \hl 16 & 15 & 14 & 13 & 22 & \cd \\ \hdashline 17 & 18 & 19 & 20 & 21 & \cd \\ \vd & \vd & \vd & \vd & \vd & \dd \end{array}

The spiral touches the left edge on the $ 4 $th row where the number is $ 4^2 $

Whenever the spiral touches the left edge at the $ m $th row (where $ m $ is even), the number in the first column of that row is $ m^2. $ Hence, we conclude that $ f(m, 1) = m^2 $ when $ m $ is even. Immediately after touching the left edge, the spiral turns downwards into the first column of the next row. Thus, in the next row, i.e. in the $ (m + 1) $th row, we have $ f(m + 1, 1) = m^2 + 1, $ where $ m + 1 $ is odd. This can be restated as $ f(m, 1) = (m - 1)^2 + 1 $ when $ m $ is odd. Since $ f(1, 1) = 1, $ we can summarise the two formulas we have found here as: \[ f(m, 1) = \begin{cases} m^2 & \text{if } m \equiv 0 \pmod{2}, \\ (m - 1)^2 + 1 & \text{if } m \equiv 1 \pmod{2}. \end{cases} \]

We can perform a similar analysis for the numbers at the top edge and note that whenever the spiral touches the top edge at the $ n $th column (where $ n $ is odd), the number in the first row of that column is $ n^2. $ This is illustrated below.

\begin{array}{rrr:rrl} 1 & 2 & \hl 9 & 10 & 25 & \cd \\ 4 & 3 & 8 & 11 & 24 & \cd \\ 5 & 6 & 7 & 12 & 23 & \cd \\ \hdashline 16 & 15 & 14 & 13 & 22 & \cd \\ 17 & 18 & 19 & 20 & 21 & \cd \\ \vd & \vd & \vd & \vd & \vd & \dd \end{array}

The spiral touches the top edge on the $ 3 $rd column where the number is $ 3^2 $

Immediately after touching the top edge, the spiral turns right into the next column. These observations give us the following formula for the numbers at the top edge: \[ f(1, n) = \begin{cases} n^2 & \text{if } n \equiv 1 \pmod{2}, \\ (n - 1)^2 + 1 & \text{if } n \equiv 0 \pmod{2}. \end{cases} \] Next we will find a formula for any arbitrary number anywhere in the grid.

Computing All Grid Numbers

Since the spiral touches the left edge on even-numbered rows, then turns downwards into the next (odd-numbered) row and then starts moving right until the diagonal (where it changes direction again), the following two rules hold:

On every odd-numbered row, as we go from left to right, the numbers increase until we reach the diagonal.
On every even-numbered row, as we go from left to right, the numbers decrease until we reach the diagonal.

Note that all the numbers we considered in the above two points lie on or below the diagonal (or equivalently, on or to the left of the diagonal). Therefore, on an odd-numbered row, we can find the numbers on or below the diagonal using the formula $ f(m, n) = f(m, 1) + (n - 1), $ where $ m $ is odd. Similarly, on even-numbered rows, we can find the numbers on or below the diagonal using the formula $ f(m, n) = f(m, 1) - (n - 1), $ where $ m $ is even.

By a similar analysis, the following rules hold when we consider the numbers in a column:

On every even-numbered column, as we go from top to bottom, the numbers increase until we reach the diagonal.
On every odd-numbered column, as we go from top to bottom, the numbers decrease until we reach the diagonal.

Now the numbers on or above the diagonal can be found using the formula $ f(m, n) = f(1, n) - (m - 1) $ when $ n $ is odd and $ f(m, n) = f(1, n) + (m - 1), $ when $ n $ is even.

Can we determine from the values of $ m $ and $ n $ if the number $ f(m, n) $ is above the diagonal or below it? Yes, if $ m \le n, $ then $ f(m, n) $ lies on or above the diagonal. However, if $ m \ge n, $ then $ f(m, n) $ lies on or below the diagonal.

We now have everything we need to write a general formula for finding the numbers anywhere in the grid. Using the four formulas and the two inequalities obtained in this section, we get \[ f(m, n) = \begin{cases} f(1, n) + (m - 1) & \text{if } m \le n \text{ and } n \equiv 0 \pmod{2}, \\ f(1, n) - (m - 1) & \text{if } m \le n \text{ and } n \equiv 1 \pmod{2}, \\ f(m, 1) - (n - 1) & \text{if } m \ge n \text{ and } m \equiv 0 \pmod{2}, \\ f(m, 1) + (n - 1) & \text{if } m \ge n \text{ and } m \equiv 1 \pmod{2}. \\ \end{cases} \] Using the equations for $ f(1, n) $ and $ f(m, 1) $ from the previous section, the above formulas can be rewritten as \[ f(m, n) = \begin{cases} (n - 1)^2 + 1 + (m - 1) & \text{if } m \le n \text{ and } n \equiv 0 \pmod{2}, \\ n^2 - (m - 1) & \text{if } m \le n \text{ and } n \equiv 1 \pmod{2}, \\ m^2 - (n - 1) & \text{if } m \ge n \text{ and } m \equiv 0 \pmod{2}, \\ (m - 1)^2 + 1 + (n - 1) & \text{if } m \ge n \text{ and } m \equiv 1 \pmod{2}. \\ \end{cases} \] Simplifying the expressions on the right-hand side, we get \[ f(m, n) = \begin{cases} (n - 1)^2 + m & \text{if } m \le n \text{ and } n \equiv 0 \pmod{2}, \\ n^2 - m + 1 & \text{if } m \le n \text{ and } n \equiv 1 \pmod{2}, \\ m^2 - n + 1 & \text{if } m \ge n \text{ and } m \equiv 0 \pmod{2}, \\ (m - 1)^2 + n & \text{if } m \ge n \text{ and } m \equiv 1 \pmod{2}. \\ \end{cases} \] This is pretty good. We now have a piecewise formula that works for any position in the grid. Let us now explore whether we can express it as a single closed-form expression.

Closed Form Expression

First, we will rewrite the piecewise formula from the previous section in the following form: \[ f(m, n) = \begin{cases} (n^2 - n + 1) + (m - n) & \text{if } m \le n \text{ and } n \equiv 0 \pmod{2}, \\ (n^2 - n + 1) - (m - n) & \text{if } m \le n \text{ and } n \equiv 1 \pmod{2}, \\ (m^2 - m + 1) + (m - n) & \text{if } m \ge n \text{ and } m \equiv 0 \pmod{2}, \\ (m^2 - m + 1) - (m - n) & \text{if } m \ge n \text{ and } m \equiv 1 \pmod{2}. \\ \end{cases} \] This is the same formula, rewritten to reveal common patterns between the four expressions on the right-hand side. In each expression, one variable plays the dominant role, occurring several times, while the other appears only once. For example, in the first two expressions, $ n $ plays the dominant role whereas $ m $ occurs only once. If we look closely, we realise that it is the variable that is greater than or equal to the other that plays the dominant role. Therefore the first and third expressions may be written as \[ \left( (\max(m, n))^2 - \max(m, n) + 1 \right) + (m - n). \] Similarly, the second and fourth expressions may be written as \[ \left( (\max(m, n))^2 - \max(m, n) + 1 \right) - (m - n). \] We have made some progress towards a closed-form expression. We have collapsed the four expressions in the piecewise formula to just two. The only difference between them lies in the sign of the second term: it is positive when the dominant variable is even and negative when it is odd. This observation allows us to unify both cases into a single expression: \[ f(m, n) = (\max(m, n))^2 - \max(m, n) + 1 + (-1)^{\max(m, n)} (m - n). \] Now we have a closed-form expression for $ f(m, n) $ that gives the number at any position in the grid.

Patterns on the Diagonal

As mentioned earlier, there is a shorter route to the same closed-form expression. This alternative approach is based on analysing the numbers along the diagonal of the grid. We still need to examine the edge numbers, but not all of them as we did in the previous section. Some of the reasoning about edge values will be repeated here to ensure this section is self-contained.

Computing Diagonal Numbers

A number on the diagonal has the same row number and column number. In other words, a diagonal number has the value $ f(n, n) $ for some positive integer $ n. $ Consider the case when $ n $ is even. In this case, the diagonal number is on a segment of the spiral that is moving to the left. The $ n \times n $ subgrid formed by the first $ n $ rows and the first $ n $ columns contains exactly $ n^2 $ consecutive numbers. Since the diagonal number is on the last row of this subgrid and the numbers in this row increase as we move from right to left, the largest number in the subgrid must be on the left edge of this row. Therefore the number at the left edge is $ f(n, 1) = n^2, $ where $ n $ is even. This is illustrated below.

\begin{array}{rrrr:rl} 1 & 2 & 9 & 10 & 25 & \cd \\ 4 & 3 & 8 & 11 & 24 & \cd \\ 5 & 6 & 7 & 12 & 23 & \cd \\ \hl 16 & 15 & 14 & \hl 13 & 22 & \cd \\ \hdashline 17 & 18 & 19 & 20 & 21 & \cd \\ \vd & \vd & \vd & \vd & \vd & \dd \end{array}

The spiral touches the left edge on the $ 4 $th row where the number is $ 4^2 $

From the diagonal to the edge of the subgrid, there are $ n $ consecutive numbers. In a sequence of $ n $ consecutive numbers, the difference between the maximum number and the minimum number is $ n - 1. $ Therefore, $ n^2 - f(n, n) = n - 1. $ This gives us \[ f(n, n) = n^2 - n + 1 \quad \text{if } n \equiv 0 \pmod{2}. \]

Now consider the case when $ n $ is odd.

\begin{array}{rrr:rrl} 1 & 2 & \hl 9 & 10 & 25 & \cd \\ 4 & 3 & 8 & 11 & 24 & \cd \\ 5 & 6 & \hl 7 & 12 & 23 & \cd \\ \hdashline 16 & 15 & 14 & 13 & 22 & \cd \\ 17 & 18 & 19 & 20 & 21 & \cd \\ \vd & \vd & \vd & \vd & \vd & \dd \end{array}

The spiral touches the top edge on the $ 3 $rd column where the number is $ 3^2 $

By a similar reasoning, for odd $ n, $ the $ n $th column has numbers that increase as we move up from the diagonal number towards the top edge. Therefore $ f(1, n) = n^2 $ and since $ n^2 - f(n, n) = n - 1, $ we again obtain \[ f(n, n) = n^2 - n + 1 \quad \text{if } n \equiv 1 \pmod{2}. \] Since $ f(n, n) $ takes the same form for both odd and even $ n, $ we can write \[ f(n, n) = n^2 - n + 1 \] for all positive integers $ n. $

Computing All Grid Numbers

If $ m \le n, $ then the number $ f(m, n) $ lies on or above the diagonal number $ f(n, n). $ If $ n $ is even, then the numbers decrease as we go from the diagonal up to the top edge. Therefore $ f(m, n) \le f(n, n) $ and $ f(m, n) = f(n, n) - (n - m). $ If $ n $ is odd, then the numbers increase as we go from the diagonal up to the top edge and therefore $ f(m, n) \ge f(n, n) $ and $ f(m, n) = f(n, n) + (n - m). $

If $ m \ge n, $ then the number $ f(m, n) $ lies on or below the diagonal number $ f(m, m). $ By a similar analysis, we find that $ f(m, n) = f(m, m) + (m - n) $ if $ n $ is even and $ f(m, n) = f(m, m) - (m - n) $ if $ n $ is odd. We summarise these results as follows: \[ f(m, n) = \begin{cases} f(n, n) - (n - m) & \text{if } m \le n \text{ and } n \equiv 0 \pmod{2}, \\ f(n, n) + (n - m) & \text{if } m \le n \text{ and } n \equiv 1 \pmod{2}, \\ f(m, m) + (m - n) & \text{if } m \ge n \text{ and } m \equiv 0 \pmod{2}, \\ f(m, m) - (m - n) & \text{if } m \ge n \text{ and } m \equiv 1 \pmod{2}. \\ \end{cases} \] Note that the above formula can be rewritten as \[ f(m, n) = \begin{cases} f(n, n) + (m - n) & \text{if } m \le n \text{ and } n \equiv 0 \pmod{2}, \\ f(n, n) - (m - n) & \text{if } m \le n \text{ and } n \equiv 1 \pmod{2}, \\ f(m, m) + (m - n) & \text{if } m \ge n \text{ and } m \equiv 0 \pmod{2}, \\ f(m, m) - (m - n) & \text{if } m \ge n \text{ and } m \equiv 1 \pmod{2}. \\ \end{cases} \]

Closed Form Expression

If we take a close look at the last formula in the previous section, we find that in each expression, one variable plays a dominant role, i.e. it occurs more frequently in the expression than the other. In the first two expressions $ n $ plays the dominant role whereas in the last two expressions $ m $ plays the dominant role. In fact, in each expression, the dominant variable is the one that is greater than or equal to the other. With this in mind, we can rewrite the above formula as \[ f(m, n) = \begin{cases} f(\max(m, n), \max(m, n)) + (m - n) & \text{if } \max(m, n) \equiv 0 \pmod{2}, \\ f(\max(m, n), \max(m, n)) - (m - n) & \text{if } \max(m, n) \equiv 1 \pmod{2}. \\ \end{cases} \] The only difference between the expressions is the sign of the second term: it is positive when $ \max(m, n) $ is even and negative when $ \max(m, n) $ is odd. As a result, we can rewrite the above formula as a single expression like this: \[ f(m, n) = f(\max(m, n), \max(m, n)) + (-1)^{\max(m, n)} (m - n). \] Using the formula $ f(n, n) = n^2 - n + 1 $ from the previous section, we get \[ f(m, n) = (\max(m, n))^2 - \max(m, n) + 1 + (-1)^{\max(m, n)} (m - n). \] We arrive again at the same closed-form expression, this time by focusing on the diagonal of the grid.

References

Number Spiral from the CSES Problem Set
Closed-Form Solution by Christopher Stover and Eric W. Weisstein
Piecewise Function by Eric W. Weisstein

Read on website | #mathematics | #puzzle

Wordle With Grep

2022-01-22T00:00:00Z

Let us solve a couple of Wordle games with the Unix grep command and the Unix words file. The Wordle games #217, #218 and #219 for 22 Jan 2022, 23 Jan 2022 and 24 Jan 22 respectively are used as examples in this post. The output examples shown below are obtained using the words file /usr/share/dict/words, GNU grep 3.6 and GNU bash 5.1.4 on Debian GNU/Linux 11.2 (bullseye).

Note that the original Wordle game uses a different word list. Further, there are several Wordle clones which may have their own word lists. For the purpose of this post, we will use the word list that comes with Debian. We will solve each Wordle in a quick and dirty manner in this post. The focus is going to be on making constant progress and reaching the solution quickly with simple shell commands.

Preliminary Work
Wordle #217
Wordle #218
Wordle #219

Preliminary Work

Before we start solving Wordle games, we will do some preliminary work. We will create a convenient shell alias that automatically selects all five-letter words from the words files. We will also find a good word to enter as the first guess into the Wordle game. The following steps elaborate this preliminary work:

Make a shell alias named words that selects all 5 letter words from the words file.

$ alias words='grep "^[a-z]\{5\}$" /usr/share/dict/words'
$ words | head -n 3
abaci
aback
abaft
$ words | tail -n 3
zoned
zones
zooms
$ words | wc -l
4594

For each letter in the English alphabet, count the number of five-letter words that contain the letter. Rank each letter by this count.
```
$ for c in {a..z}; do echo $(words | grep $c | wc -l) $c; done | sort -rn | head -n 15
2245 s
2149 e
1736 a
1404 r
1301 o
1231 i
1177 l
1171 t
975 n
924 d
810 u
757 c
708 p
633 h
623 y
```
The output shows that the letter 's' occurs in 2245 five-letter words, followed by 'e' which occurs in 2149 five-letter words and so on.
Find a word that contains the top five letters found in the previous step.
```
$ words | grep s | grep e | grep a | grep r | grep o
arose
```
We will enter this word as the first guess in every Wordle game.
In case, the word "arose" does not lead to any positive result, we will need another word to enter as our second guess. Find a word that contains the next five top letters in the list found above.
```
$ words | grep i | grep l | grep t | grep n | grep d
$ words | grep i | grep l | grep t | grep n | grep u
until
```
We found that there is no such word that contains 'i', 'l', 't', 'n' and 'd'. So we got rid of 'd' in our search and included 'u' (the next highest ranking letter after 'd') instead to find the word "until". We will enter this word as the second guess if and only if the first guess (i.e. "arose") does not lead to any positive result.

Wordle #217

Let us now solve Wordle #217 for Sat, 22 Jan 2022 with the following steps:

Use the word "arose" as the first guess. The following result appears:

A R O S E
The previous result shows that the letter 'e' occurs at the fifth place. Further, the letters 'a', 'r', 'o' and 's' do not occur anywhere in the word. Look for words satisfying these constraints.
```
$ words | grep '....e' | grep -v '[aros]' | head -n 5
beige
belie
belle
bible
bilge
```
Pick the word "beige" for the second guess and enter it into the Wordle game. Note that since we are following a quick and dirty approach here, we do not spend any time figuring out which of the various five-letter words ending with the letter 'e' is the most optimal choice for the next guess. We simply pick the first word from the output above and enter it as the second guess. The following result appears now:

B E I G E
The letter 'i' occurs somewhere in the word but not at the third place. Further the letters 'b' and 'g' do not occur anywhere in the word. Also, the letter 'e' does not occur anywhere apart from the fifth place. The letter 'e' in the gray tile in the second place confirms that the letter 'e' does not repeat in the answer word. Refine the previous command to add these constraints.
```
$ words | grep '[^e][^e][^ie][^e]e' | grep i | grep -v '[arosbg]' | head -n 5
fiche
indue
lithe
mince
niche
```
Enter "fiche" as the third guess. The following result appears:

F I C H E
The previous result shows that the letter 'i' occurs at the second place. Further, the letter 'c' occurs somewhere in the word but not at the third place. Also, the letters 'f' and 'h' do not occur anywhere in the word. Refine the previous command further to add these constraints:
```
$ words | grep '[^e]i[^iec][^e]e' | grep c | grep -v '[arosbgfh]' | head -n 5
mince
wince
```
Enter the word "mince" for the fourth guess. It leads to the following result:

M I N C E
We are almost there! We now have all the letters except the first one. The previous result shows that the letter 'm' does not occur in the word. Thus the answer word must be "wince". For the sake of completeness, here is a refined search that selects the answer word based on the constraints known so far:
```
$ words | grep '[^e]ince' | grep -v '[arosbgfhm]' | head -n 5
wince
```
It looks like we have found the answer word. Enter "wince" as the fifth guess to get the following result:

W I N C E

Done!

Wordle #218

Now that the wordle for Sat, 22 Jan 2022 is solved, let us try the same method on Wordle #219 for Sun, 23 Jan 2022 and see how well this method works. Here are the steps:

Like before, the first guess is "arose". Entering this word leads to the following result:

A R O S E
Now search for words based on the previous result.
```
$ words | grep '.r...' | grep -v '[aose]' | head -n 5
brick
bring
brink
briny
bruin
```
Enter the word "brick" as the second guess. This leads to the following result:

B R I C K
Use the previous result to refine the search further.
```
$ words | grep '.ri[^c].' | grep c | grep -v '[aosebk]' | head -n 5
crimp
```
Enter "crimp" as the third guess. This leads to the following result:

C R I M P

Done!

Wordle #219

Finally, let us solve Wordle #219 for Mon, 24 Jan 2022.

Enter "arose" as the first guess to get this result:

A R O S E
The previous result shows that the third letter is 'o' and the letters 'a', 'r', 's' and 'e' do not occur anywhere in the word. Search for words that match these constraints.
```
$ words | grep '..o..' | grep -v '[arse]' | head -n 5
block
blond
blood
bloom
blown
```
Enter "block" as the second guess. This leads to the following result:

B L O C K
The previous result shows that the letter 'l' occurs somewhere in the word but not at the second place. Similarly, the letter 'k' occurs somewhere in the word but not at the fifth place. Further, the letters 'b' and 'c' do not occur anywhere in the word. Search for words that match these constraints.
```
$ words | grep '.[^l]o.[^k]' | grep l | grep k | grep -v '[arsebc]' | head -n 5
knoll
```
Enter "knoll" as the third guess. It leads to the following result:

K N O L L

Done!

Read on website | #unix | #shell | #technology | #puzzle

Loopy C Puzzle

2011-10-01T00:00:00Z

Integer Underflow

Let us talk a little bit about integer underflow and undefined behaviour in C before we discuss the puzzle I want to share in this post.

#include <stdio.h>

int main()
{
    int i;
    for (i = 0; i < 6; i--) {
        printf(".");
    }
    return 0;
}

This code invokes undefined behaviour. The value in variable i decrements to INT_MIN after |INT_MIN| iterations. In the next iteration, there is a negative overflow which is undefined for signed integers in C. On many implementations though, INT_MIN - 1 wraps around to INT_MAX. Since INT_MAX is not less than 6, the loop terminates. With such implementations, this code prints print |INT_MIN| + 1 dots. With 32-bit integers, that amounts to 2147483649 dots. Here is one such example output:

$ gcc -std=c89 -Wall -Wextra -pedantic foo.c && ./a.out | wc -c
2147483649

It is worth noting that the above behaviour is only one of the many possible ones. The code invokes undefined behaviour and the ISO standard imposes no requirements on a specific implementation of the compiler regarding what the behaviour of such code should be. For example, an implementation could also exploit the undefined behaviour to turn the loop into an infinite loop. In fact, GCC does optimise it to an infinite loop if we compile the code with the -O2 option.

# This never terminates!
$ gcc -O2 -std=c89 -Wall -Wextra -pedantic foo.c && ./a.out

Puzzle

Let us take a look at the puzzle now.

Add or modify exactly one operator in the following code such that it prints exactly 6 dots.

for (i = 0; i < 6; i--) {
    printf(".");
}

An obvious solution is to change i-- to i++.

for (i = 0; i < 6; i++) {
    printf(".");
}

There are a few more solutions to this puzzle. One of the solutions is very interesting. We will discuss the interesting solution in detail below.

Solutions

Update on 02 Oct 2011: The puzzle has been solved in the comments section. We will discuss the solutions now. If you want to think about the problem before you see the solutions, this is a good time to pause and think about it. There are spoilers ahead.

Here is a list of some solutions:

for (i = 0; i < 6; i++)
for (i = 0; i < 6; ++i)
for (i = 0; -i < 6; i--)
for (i = 0; i + 6; i--)
for (i = 0; i ^= 6; i--)

The last solution involving the bitwise XOR operation is not immediately obvious. A little analysis is required to understand why it works.

Generalisation

Let us generalise the puzzle by replacing $ 6 $ in the loop with an arbitrary positive integer $ n. $ The loop in the last solution now becomes:

for (i = 0; i ^= n; i--) {
    printf(".");
}

If we denote the value of the variable i set by the execution of i ^= n after $ k $ dots are printed as $ f(k), $ then \[ f(k) = \begin{cases} 0 & \text{if } k = 0, \\ n \oplus (f(k - 1) - 1) & \text{if } k \gt 1 \end{cases} \] where $ k $ is a nonnegative integer, $ n $ is a positive integer and the symbol $ \oplus $ denotes bitwise XOR operation on two nonnegative integers.

Note that $ f(0) $ represents the value of i set by the execution of i ^= n when no dots have been printed yet.

If we can show that $ n $ is the least value of $ k $ for which $ f(k) = 0, $ it would prove that the loop terminates after printing $ n $ dots.

We will see in the next section that for odd values of $ n, $ \[ f(k) = \begin{cases} n & \text{if } k \text{ is even}, \\ 1 & \text{if } k \text{ is odd}. \end{cases} \] Therefore there is no value of $ k $ for which $ f(k) = 0 $ when $ n $ is odd. As a result, the loop never terminates when $ n $ is odd.

We will then see that for even values of $ n $ and $ 0 \leq k \leq n, $ \[ f(k) = 0 \iff k = n. \] Therefore the loop terminates after printing $ n $ dots when $ n $ is even.

Lemmas

We will first prove a few lemmas about some interesting properties of the bitwise XOR operation. We will then use it to prove the claims made in the previous section.

Lemma 1. For an odd positive integer $ n, $ \[ n \oplus (n - 1) = 1 \] where the symbol $ \oplus $ denotes bitwise XOR operation on two nonnegative integers.

Proof. Let the binary representation of $ n $ be $ b_m \dots b_1 b_0 $ where $ m $ is a nonnegative integer and $ b_m $ represents the most significant nonzero bit of $ n. $ Since $ n $ is an odd number, $ b_0 = 1. $ Thus $ n $ may be written as \[ b_m \dots b_1 1. \] As a result $ n - 1 $ may be written as \[ b_m \dots b_1 0. \] The bitwise XOR of both binary representations is $ 1. $

Lemma 2. For a nonnegative integer $ n, $ \[ n \oplus 1 = \begin{cases} n + 1 & \text{if } n \text{ is even}, \\ n - 1 & \text{if } n \text{ is odd}. \end{cases} \] where the symbol $ \oplus $ denotes bitwise XOR operation on two nonnegative integers.

Proof. Let the binary representation of $ n $ be $ b_m \dots b_1 b_0 $ where $ m $ is a nonnegative integer and $ b_m $ represents the most significant nonzero bit of $ n. $

If $ n $ is even, $ b_0 = 0. $ In this case, $ n $ may be written as $ b_m \dots b_1 0. $ Thus $ n \oplus 1 $ may be written as $ b_m \dots b_1 1. $ Therefore $ n \oplus 1 = n + 1. $

If $ n $ is odd, $ b_0 = 1. $ In this case, $ n $ may be written as $ b_m \dots b_1 1. $ Thus $ n \oplus 1 $ may be written as $ b_m \dots b_1 0. $ Therefore $ n \oplus 1 = n - 1. $

Note that for odd $ n, $ lemma 1 can also be derived as a corollary of lemma 2 in this manner: \[ k \oplus (k - 1) = k \oplus (k \oplus 1) = (k \oplus k) \oplus 1 = 0 \oplus 1 = 1. \]

Lemma 3. If $ x $ is an even nonnegative integer and $ y $ is an odd positive integer, then $ x \oplus y $ is odd, where the symbol $ \oplus $ denotes bitwise XOR operation on two nonnegative integers.

Proof. Let the binary representation of $ x $ be $ b_{xm_x} \dots b_{x1} b_{x0} $ and that of $ y $ be $ b_{ym_y} \dots b_{y1} b_{y0} $ where $ m_x $ and $ m_y $ are nonnegative integers and $ b_{xm_x} $ and $ b_{xm_y} $ represent the most significant nonzero bits of $ x $ and $ y $ respectively.

Since $ x $ is even, $ b_{x0} = 0. $ Since $ y $ is odd, $ b_{y0} = 1. $

Let $ z = x \oplus y $ with a binary representation of $ b_{zm_z} \dots b_{z1} b_{z0} $ where $ m_{zm_z} $ is a nonnegative integer and $ b_{zm_z} $ is the most significant nonzero bit of $ z. $

We get $ b_{z0} = b_{x0} \oplus b_{y0} = 0 \oplus 1 = 1. $ Therefore $ z $ is odd.

Theorems

Theorem 1. Let $ \oplus $ denote bitwise XOR operation on two nonnegative integers and \[ f(k) = \begin{cases} n & \text{if } n = 0, \\ n \oplus (f(n - 1) - 1) & \text{if } n \gt 1. \end{cases} \] where $ k $ is a nonnegative integer and $ n $ is an odd positive integer. Then \[ f(k) = \begin{cases} n & \text{if } k \text{ is even}, \\ 1 & \text{if } k \text{ is odd}. \end{cases} \]

Proof. This is a proof by mathematical induction. We have $ f(0) = n $ by definition. Therefore the base case holds good.

Let us assume that $ f(k) = n $ for any even $ k $ (induction hypothesis). Let $ k' = k + 1 $ and $ k'' = k + 2. $

If $ k $ is even, we get \begin{align*} f(k') & = n \oplus (f(k) - 1) && \text{(by definition)} \\ & = n \oplus (n - 1) && \text{(by induction hypothesis)} \\ & = 1 && \text{(by lemma 1)},\\ f(k'') & = n \oplus (f(k') - 1) && \text{(by definition)} \\ & = n \oplus (1 - 1) && \text{(since $ f(k') = 1 $)} \\ & = n \oplus 0 \\ & = n. \end{align*}

Since $ f(k'') = n $ and $ k'' $ is the next even number after $ k, $ the induction step is complete. The induction step shows that for every even $ k, $ $ f(k) = n $ holds good. It also shows that as a result of $ f(k) = n $ for every even $ k, $ we get $ f(k') = 1 $ for every odd $ k'. $

Theorem 2. Let $ \oplus $ denote bitwise XOR operation on two nonnegative integers and \[ f(k) = \begin{cases} n & \text{if } n = 0, \\ n \oplus (f(n - 1) - 1) & \text{if } n \gt 1. \end{cases} \] where $ k $ is a nonnegative integer, $ n $ is an even positive integer and $ 0 \leq k \leq n. $ Then \[ f(k) = 0 \iff k = n. \]

Proof. We will first show by the principle of mathematical induction that for even $ k, $ $ f(k) = n - k. $ We have $ f(0) = n $ by definition, so the base case holds good. Now let us assume that $ f(k) = n - k $ holds good for any even $ k $ where $ 0 \leq k \leq n $ (induction hypothesis).

Since $ n $ is even (by definition) and $ k $ is even (by induction hypothesis), $ f(k) = n - k $ is even. As a result, $ f(k) - 1 $ is odd. By lemma 3, we conclude that $ f(k + 1) = n \oplus (f(k) - 1) $ is odd.

Now we perform the induction step as follows: \begin{align*} f(k + 2) & = n \oplus (f(k + 1) - 1) && \text{(by definition)} \\ & = n \oplus (f(k + 1) \oplus 1) && \text{(by lemma 2 for odd $ n $)} \\ & = n \oplus ((n \oplus (f(k) - 1)) \oplus 1) && \text{(by definition)} \\ & = (n \oplus n ) \oplus ((f(k) - 1) \oplus 1) && \text{(by associativity of XOR)} \\ & = 0 \oplus ((f(k) - 1) \oplus 1) \\ & = (f(k) - 1) \oplus 1 \\ & = (f(k) - 1) - 1 && \text{(from lemma 2 for odd $ n $)} \\ & = f(k) - 2 \\ & = n - k - 2 && \text{(by induction hypothesis).} \end{align*} This completes the induction step and proves that $ f(k) = n - k $ for even $ k $ where $ 0 \leq k \leq n. $

We have shown above that $ f(k) $ is even for every even $ k $ where $ 0 \leq k \leq n $ which results in $ f(k + 1) $ as odd for every odd $ k + 1. $ This means that $ f(k) $ cannot be $ 0 $ for any odd $ k. $ Therefore $ f(k) = 0 $ is possible only even $ k. $ Solving $ f(k) = n - k = 0, $ we conclude that $ f(k) = 0 $ if and only if $ k = n. $

From Tower of Hanoi to Counting Bits

2011-09-25T00:00:00Z

Tower of Hanoi

A few weeks ago, I watched Rise of the Planet of the Apes. The movie showed a genetically engineered chimpanzee trying to solve a puzzle involving four discs, initially stacked in ascending order of size on one of three pegs. The chimpanzee was supposed to transfer the entire stack to one of the other pegs, moving only one disc at a time and never placing a larger disc on a smaller one.

The problem was called the Lucas' Tower in the movie. I have always known this problem as the Tower of Hanoi puzzle. The minimum number of moves required to solve the problem is $ 2^n - 1 $ where $ n $ is the number of discs. In the movie, the chimpanzee solved the problem in 15 moves, the minimum number of moves required when there are 4 discs.

Referring to the problem as the Lucas' Tower made me wonder why it was called so instead of calling it the Tower of Hanoi. I guessed it was probably because the puzzle was invented by the French mathematician Édouard Lucas. Later when I checked the Wikipedia article on this topic, I realised I was right about this. In fact, the article mentioned that there is another version of this problem known as the Tower of Brahma that involves 64 discs made of pure gold and three diamond needles. According to a legend, a group of Brahmin priests are working at the problem and the world will end when the last move of the puzzle is completed. Now, even if they make one move every second, it'll take 18 446 744 073 709 551 615 seconds to complete the puzzle. That's about 585 billion years. The article also had this nice animation of a solution involving four discs.

Animated solution of the Tower of Hanoi puzzle created by André Karwath (original source)

I'll not discuss the solution of this puzzle in this blog post. There are plenty of articles on the web including the Wikpedia article that describes why it takes a minimum of $ 2^n - 1 $ moves to solve the puzzle when there are $ n $ discs involved. In this post, I'll talk about an interesting result I discovered while playing with this puzzle one afternoon.

Binary Numbers

If we denote the minimum number of moves required to solve the Tower of Hanoi puzzle as $ T_n, $ then $ T_n $ when expressed in binary is the largest possible $ n $-bit integer. For example, $ T_4 = 15_{10} = 1111_{2}. $ That makes sense because $ T_n = 2^n - 1 $ indeed represents the maximum possible $ n $-bit integer where all $ n $ bits are set to $ 1. $

While playing with different values of $ T_n $ for different values of $ n, $ I stumbled upon an interesting result which I will pose as a problem in a later section below.

Assumptions

Before proceeding to the problem, let us define the bit-length of an integer to eliminate any possibility of ambiguity:

A positive integer $ x $ is said to be an $ n $-bit integer if and only if the minimum number of bits required to express the integer is $ n; $ or equivalently, $ \lfloor \log_2 x \rfloor + 1 = n. $

We will be dealing with arbitrary precision integers (bignums) in the problem, so let us also make a few assumptions:

Addition or subtraction of an $ m $-bit integer and an $ n $-bit integer ($ m \le n $) takes $ O(n) $ time.
Counting the number of $ 1 $-bits in an $ n $-bit integer takes $ O(n) $ time.

The definition along with the assumptions lead to the following conclusions:

Adding or subtracting two integers $ a $ and $ b $ takes $ O(\log(\max(a, b))) $ time.
Counting the number of $ 1 $-bits in an integer $ a $ takes $ O(\log(a)) $ time.

Binary Puzzle

We will now explore the following puzzle in the remainder of this post.

What is the most efficient way to compute the number of $ 1 $-bits in \[ T_1 + T_2 + \dots + T_n \] where $ n $ is a positive integer, each $ T_i = 2^i - 1 $ for integers $ 1 \le i \le n $ and efficiency is measured in terms of time and space complexity?

The naive approach involves adding all the $ n $ integers and counting the number of $ 1 $-bits in the sum. It takes $ O(n^2) $ time to add the $ n $ integers. The sum is an $ (n + 1) $-bit integer, so it takes $ O(n) $ time to count the number of $ 1 $-bits in the sum. Since the sum is $ (n + 1) $-bit long, it takes $ O(n) $ memory to store the sum. If $ n $ is as large as, say, $ 2^{64}, $ it takes 2 exbibytes plus one more bit of memory to store the sum.

We can arrive at a much more efficient solution if we look at what the binary representation of the sum looks like. We first arrive at a closed-form expression for the sum: \begin{align*} T_1 + T_2 + \dots + T_n & = (2 - 1) + (2^2 - 1) + \dots + (2^n - 1) \\ & = (2 + 2^2 + \dots + 2^n) - n \\ & = (2^{n + 1} - 2) - n \\ & = (2^{n + 1} - 1) - (n + 1). \end{align*} Now $ 2^{n + 1} - 1 $ is an $ (n + 1) $-bit number with all its bits set to $ 1. $ Subtracting $ n + 1 $ from it is equivalent to performing the following operation with their binary representations: for each $ 1 $-bit in $ (n + 1), $ set the corresponding bit in $ (2^{n + 1} - 1) $ to $ 0. $

If we use the notation $ \text{bitcount}(n) $ to represent the number of $ 1 $-bits in the binary representation of a positive integer $ n, $ then we get \[ \text{bitcount}(T_1 + T_2 + \dots + T_n) = (n + 1) - \text{bitcount}(n + 1). \] Now the computation involves counting the number of $ 1 $-bits in $ n + 1 $ which takes $ O(\log n) $ and subtracting this count from $ n + 1 $ which also takes $ O(\log n) $ time. Further, the largest number that we keep in memory is $ n + 1 $ which occupies $ O(\log n) $ space. Therefore, the entire problem can be solved in $ O(\log n) $ time with $ O(\log n) $ space.

What would have taken 2 exbibytes plus 1 bit of memory with the naive approach requires 8 bytes plus 1 bit of memory now.

Read on website | #mathematics | #puzzle

Langford Pairing

2011-09-17T00:00:00Z

Permutation Problem

A few days ago, I came across this problem:

There is a sequence of $ 2n $ numbers where each natural number from $ 1 $ to $ n $ is repeated twice, i.e. \[ (1, 1, 2, 2, \dots, n, n). \] Find a permutation of this sequence such that for each $ k $ where $ 1 \le k \le n, $ there are $ k $ numbers between two occurrences of $ k $ in the permutation.

Getting Started

In combinatorics, this problem has a name: Langford's problem. A permutation of $ (1, 1, 2, 2, \dots, n, n) $ that satisfies the condition given in the probem is known as a Langford pairing or Langford sequence.

For small $ n, $ say $ n = 4, $ Langford pairings can be obtained easily by trial and error: $ (4, 1, 3, 1, 2, 4, 3, 2). $ What if $ n $ is large? We need an algorithm to find a permutation that solves the problem in that case.

There is another question to consider: Is there a solution for every possible $ n? $ One can easily see that there are no Langford pairings for $ n = 1 $ and $ n = 2, $ i.e. the sequences $ (1, 1) $ and $ (1, 1, 2, 2) $ have no Langford pairings.

We need to understand two things:

For what values of $ n $ do Langford pairings exist?
For the values of $ n $ for which Langford pairings exist, how do we find the Langford pairings?

A simple Python 3 program I wrote to find Langford pairings for small values of $ n $ offers some clues. Here is the program:

def find_solutions(n, s=None):
    # If called from top-level (s=None), create a list of 2n zero
    # values.  Zeroes represent unoccupied cells.
    if s is None:
        s = [0] * (2 * n)

    # Next number to be placed.
    m = max(s) + 1

    # For each i, try to place m at s[i] and s[i + m + 1].
    for i in range(2 * n - m - 1):

        # If s[i] and s[i + m + 1] are unoccupied, ...
        if s[i] == s[i + m + 1] == 0:

            # first place m at s[i] and s[i + m + 1].
            s[i] = s[i + m + 1] = m

            # If m is the last number to be placed, ...
            if m == n:
                # then a solution has been found; yield it.
                yield s[:]
            else:
                # else try to place the next number.
                yield from find_solutions(n, s)

            # Undo placement of m.
            s[i] = s[i + m + 1] = 0


# Count solutions for 1 <= n <= 12.
for n in range(1, 13):
    count = sum(1 for s in find_solutions(n))
    print('n = {:2} => {:6} solutions'.format(n, count))

It takes a few minutes for this program to run. Here is the output of this program:

$ python3 langford.py
n =  1 =>      0 solutions
n =  2 =>      0 solutions
n =  3 =>      2 solutions
n =  4 =>      2 solutions
n =  5 =>      0 solutions
n =  6 =>      0 solutions
n =  7 =>     52 solutions
n =  8 =>    300 solutions
n =  9 =>      0 solutions
n = 10 =>      0 solutions
n = 11 =>  35584 solutions
n = 12 => 216288 solutions

Note that we always talk about Langford pairings in plural in this post. That's because either a sequence has no Langford pairings or it has two or more Langford pairings. There is never a sequence that has only one Langford pairing. That's because if we find at least one Langford pairing for a sequence, the reverse of that Langford pairing is also a Langford pairing. Therefore, when Langford pairings exist for a sequence, they must at least be two in number. Since they occur in pairs, they are always even in number. This is why we don't have to write "one or more Langford pairings" in this post. We can always write "Langford pairings" instead.

Conjecture

From the output above, we can form a conjecture:

  The sequence \( (1, 1, 2, 2, \dots, n, n) \) has Langford pairings
  if and only if \( n \equiv 0 \pmod{4} \) or
  \( n \equiv 3 \pmod{4}.  \)

For convenience, let us denote the sequence $ (1, 1, 2, 2, \dots, n, n) $ as $ S_n. $ We will now prove the above conjecture in two parts:

We will first show that the condition that either $ n \equiv 0 \pmod{4} $ or $ n \equiv 3 \pmod{4} $ must hold is a necessary condition for the sequence $ S_n $ to have Langford pairings.
We will then show that the condition that either $ n \equiv 0 \pmod{4} $ or $ n \equiv 3 \pmod{4} $ must hold is a sufficient condition for the sequence $ S_n $ to have Langford pairings.

Necessity

Let $ S_n = (1, 1, 2, 2, \dots, n, n) $ be a sequence such that it has Langford pairings. Let us pick an arbitrary Langford pairing $ s $ of $ S_n $ and split this Langford pairing $ s $ into two mutually exclusive subsequences $ s_1 $ and $ s_2 $ such that:

$ s_1 $ contains all numbers in odd numbered positions and
$ s_2 $ contains all numbers in even numbered positions.

For example, if we pick $ s = (1, 7, 1, 2, 5, 6, 2, 3, 4, 7, 5, 3, 6, 4) $ which is a Langford pairing of $ S_7, $ we split $ s $ into \begin{align*} s_1 & = (1, 1, 5, 2, 4, 5, 6), \\ s_2 & = (7, 2, 6, 3, 7, 3, 4). \end{align*}

We can make a few observations:

Both occurrences of an even number do not occur in the same subsequence.
There are $ \left\lfloor \frac{n}{2} \right\rfloor $ even numbers in each subsequence.
Both occurrences of an odd number occur in the same subsequence.
There are $ \left\lceil \frac{n}{2} \right\rceil $ odd numbers in each subsequence.

Do these observations hold good for every Langford pairing of any aribrary $ S_n $ for every positive integer value of $ n? $ Yes, they do. We will now prove them one by one:

Let us consider an even number $ k $ from a Langford pairing. If the first occurrence of $ k $ lies at the $ i $th position in the pairing, then its second occurrence lies at the $ (i + k + 1) $th position. Since $ k $ is even, $ i $ and $ i + k + 1 $ have different parities, i.e. if $ i $ is odd, then $ i + k + 1 $ is even and vice versa. Therefore, if the first occurrence of $ k $ lies at an odd numbered position, its second occurrence must lie at an even numbered position and vice versa. Thus one occurrence of $ k $ must belong to $ s_1 $ and the other must belong to $ s_2. $ This proves the first observation.
The number of even numbers between $ 1 $ and $ n, $ inclusive, is $ \left\lfloor \frac{n}{2} \right\rfloor. $ Each of these even numbers has been split equally between $ s_1 $ and $ s_2. $ This proves the second observation.
Now let us consider an odd number $ k $ from a Langford pairing. If the first occurrence of $ k $ lies at the $ i $th position in the pairing, then its second occurrence lies at the $ (i + k + 1) $th position. Since $ k $ is odd, $ i $ and $ i + k + 1 $ have the same parity. Therefore, either both occurrences of $ k $ belong to $ s_1 $ or both belong to $ s_2. $ This proves the third observation.
Each subsequence, $ s_1 $ or $ s_2 $ has $ n $ numbers because we split a Langford pairing $ s $ with $ 2n $ numbers equally between the two subsequences. We have shown that each subsequence has $ \left\lfloor \frac{n}{2} \right\rfloor $ even numbers. Therefore the number of odd numbers in each subsequence is $ n - \left\lfloor \frac{n}{2} \right\rfloor = \left\lceil \frac{n}{2} \right\rceil. $

From the third observation, we know that the odd numbers always occur in pairs in each subsequence because both occurrences of an odd number occur together in the same subsequence. Therefore, the number of odd numbers in each subsequence must be even. Since the number of odd numbers in each subsequence is $ \left\lceil \frac{n}{2} \right\rceil $ as proven for the fourth observation, we conclude that $ \left\lceil \frac{n}{2} \right\rceil $ must be even.

Now let us see what must $ n $ be like so that $ \left\lceil \frac{n}{2} \right\rceil $ is even.

Let us express $ n $ as $ 4q + r $ where $ q $ is a nonnegative integer and $ r \in \{0, 1, 2, 3\}. $

If $ n = 4q + 0, $ then$ \left\lceil \frac{n}{2} \right\rceil = \left\lceil \frac{4q}{2} \right\rceil = 2q. $
If $ n = 4q + 1, $ then$ \left\lceil \frac{n}{2} \right\rceil = \left\lceil \frac{4q + 1}{2} \right\rceil = 2q + 1. $
If $ n = 4q + 2, $ then$ \left\lceil \frac{n}{2} \right\rceil = \left\lceil \frac{4q + 2}{2} \right\rceil = 2q + 1. $
If $ n = 4q + 3, $ then$ \left\lceil \frac{n}{2} \right\rceil = \left\lceil \frac{4q + 3}{2} \right\rceil = 2q + 2. $

We see that $ \left\lceil \frac{n}{2} \right\rceil $ is even if and only if either $ n \equiv 0 \pmod{4} $ or $ n \equiv 3 \pmod{4} $ holds good.

We have shown that if a sequence $ S_n $ has Langford pairings, then either $ n \equiv 0 \pmod{4} $ or $ n \equiv 3 \pmod{4}. $ This proves the necessity of the condition.

Sufficiency

If we can show that we can construct a Langford pairing for $ (1, 1, 2, 2, \dots, n, n ) $ for both cases, i.e. $ n \equiv 0 \pmod{4} $ as well as $ n \equiv 3 \pmod{4}, $ then it would complete the proof.

Notation

Let us define some notation to make it easier to write sequences we will use in the construction of a Langford pairing:

$ (i \dots j)_{even} $ denotes a sequence of even positive integers from $ i $ to $ j, $ exclusive, arranged in ascending order.

For example, $ (1 \dots 8)_{even} = (2, 4, 6) $ and $ (1 \dots 2)_{even} = (). $
$ (i \dots j)_{odd} $ denotes a sequence of odd positive integers from $ i $ to $ j, $ exclusive, arranged in ascending order.

For example, $ (1 \dots 8)_{odd} = (3, 5, 7) $ and $ (1 \dots 3)_{odd} = (). $
$ s' $ denotes the reverse of the sequence $ s. $

For example, for a sequence $ s = (2, 3, 4, 5), $ we have $ s' = (2, 3, 4, 5)' = (5, 4, 3, 2). $
$ s \cdot t $ denotes the concatenation of sequences $ s $ and $ t. $

For example, for sequences $ s = (1, 2, 3) $ and $ t = (4, 5), $ we have $ s \cdot t = (1, 2, 3) \cdot (4, 5) = (1, 2, 3, 4, 5). $

Let $ x = \left\lceil \frac{n}{4} \right\rceil. $ Therefore, \[ x = \begin{cases} \frac{n}{4} & \text{if } n \equiv 0 \pmod{4}, \\ \frac{n + 1}{4} & \text{if } n \equiv 3 \pmod{4}. \end{cases} \] Let us now define the following eight sequences: \begin{align*} a & = (2x - 1), \\ b & = (4x - 2), \\ c & = (4x - 1), \\ d & = (4x), \\ p & = (0 \dots a)_{odd}, \\ q & = (0 \dots a)_{even}, \\ r & = (a \dots b)_{odd}, \\ s & = (a \dots b)_{even}. \end{align*} Now let us construct a Langford pairing for both cases: $ n \equiv 0 \pmod{4} $ and $ n \equiv 3 \pmod{4}. $ We will do this case by case.

Case $ n \equiv 0 \pmod{4} $

If $ n \equiv 0 \pmod{4}, $ we construct a Langford pairing with the following concatenation: \[ s' \cdot p' \cdot b \cdot p \cdot c \cdot s \cdot d \cdot r' \cdot q' \cdot b \cdot a \cdot q \cdot c \cdot r \cdot a \cdot d. \] Let us do an example with $ n = 12. $

For $ n = 12, $ we get $ x = \frac{n}{4} = 3. $ Therefore, \begin{alignat*}{2} a & = (2x - 1) && = (5), \\ b & = (4x - 2) && = (10), \\ c & = (4x - 1) && = (11), \\ d & = (4x) && = (12), \\ p & = (0 \dots a)_{odd} && = (1, 3), \\ q & = (0 \dots a)_{even} && = (2, 4), \\ r & = (a \dots b)_{odd} && = (7, 9), \\ s & = (a \dots b)_{even} && = (6, 8). \end{alignat*} After performing the specified concatenation, we get the following Langford pairing: \[ ( 8, 6, 3, 1, 10, 1, 3, 11, 6, 8, 12, 9, 7, 4, 2, 10, 5, 2, 4, 11, 7, 9, 5, 12 ). \] Let us now show that any construction of a sequence as per this specified concatenation always leads to a Langford pairing.

Each sequence $ a, $ $ b, $ $ c $ and $ d $ has one number each. Each sequence $ p, $ $ q, $ $ r $ and $ s $ has $ x - 1 $ numbers each.

The two occurrences of $ a $ have $ q, $ $ c $ and $ r $ in between, i.e. \[ (x - 1) + 1 + (x - 1) = 2x - 1 = a \] numbers in between. Similarly, we can check that the two occurrences of $ b $ have $ b $ numbers in between; likewise for $ c $ and $ d. $

The two occurrences of $ 1 $ belong to $ p $ and $ p'. $ Between these two occurrences of $ 1, $ we have only one element of $ b. $

We now show that for each $ k $ in $ p, $ there are $ k $ numbers in between. For any $ k $ in $ p, $ there is the sequence $ (0..k)'_{odd} \cdot b \cdot (0..k)_{odd} $ in between the two occurrences of $ k, $ i.e, there are $ \frac{k - 1}{2} + 1 + \frac{k - 1}{2} = k $ numbers in between. Similarly, we can check that for each $ k $ in $ q, $ there are $ k $ numbers in between.

Finally, we show that for each $ k $ in $ r, $ there are $ k $ numbers in between. For any $ k $ in $ r, $ there is the sequence $ (a..k)'_{odd} \cdot q' \cdot b \cdot a \cdot q \cdot c \cdot (a..k)_{odd} $ in between the two occurrences of $ k. $ Note that $ a $ is odd, so the number of integers in this sequence is \[ \frac{k - a - 2}{2} + (x - 1) + 1 + 1 + (x - 1) + 1 + \frac{k - a - 2}{2}. \] Simplifying the above expression and then substituting $ a = 2x - 1, $ we get \[ k - a - 2 + 2x + 1 = k. \] Similarly, we can check that for each $ k $ in $ s, $ there are $ k $ numbers in between.

Case $ n \equiv 3 \pmod{4} $

If $ n \equiv 3 \pmod{4}, $ we construct a Langford pairing with the following concatenation: \[ s' \cdot p' \cdot b \cdot p \cdot c \cdot s \cdot a \cdot r' \cdot q' \cdot b \cdot a \cdot q \cdot c \cdot r. \] Note that this concatenation of sequences is almost the same as the concatenation in the previous section with the following two differences:

The sequence $ d $ is not used here.
The sequence $ a $ in the end has moved to replace the sequence $ d $ in the middle of the concatenation.

Let us do an example with $ n = 11. $ For $ n = 12, $ we get $ x = \frac{n + 1}{4} = 3. $ Therefore, the sequences $ a, $ $ b, $ $ c, $ $ p, $ $ q, $ $ r $ and $ s $ are same as those in the last example in the previous section. After performing the specified concatenation, we get the following Langford pairing: \[ ( 8, 6, 3, 1, 10, 1, 3, 11, 6, 8, 5, 9, 7, 4, 2, 10, 5, 2, 4, 11, 7, 9 ). \] We can verify that for every $ k $ in a Langford pairing constructed in this manner, there are $ k $ numbers in between. The verification steps are similar to what we did in the previous section.

Read on website | #mathematics | #combinatorics | #puzzle

Magical Chameleons Puzzle

2011-06-19T00:00:00Z

An island contained chameleons of three different colours: red, green and blue. The chameleons were studied by some biologists and they found that when two chameleons of different colours met they changed their colours to the third one. They found that there were 2000 red chameleons and 3000 green ones on the day they counted them. They didn't get time to count the number of blue chameleons.

When the biologists returned to the island two months later they found that all chameleons were red in colour. They were certain that no chameleons died because they did not find dead remains of any chameleon. What does it say about the number of blue chameleons on the day the biologists counted the number of red and green chameleons?

See the comments page for the solution.

Read on website | #mathematics | #puzzle

Calendar Cubes Puzzle

2011-06-12T00:00:00Z

How many different ways are there to assign the ten digits of Arabic numerals (0 to 9) to each face of two cubes to ensure that we can arrange both cubes on any day such that the front faces of the cubes show the current day of the month?

For example, on February 9 the cubes would be placed side by side such that the front face of the cube on the left side shows 0 and that of the one on the right side shows 9.

Two ways of assigning the digits to the faces of the cubes are considered different if and only if it is not possible to get one assignment from the other by performing one or more of the following operrations:

Rotating (reorienting) the digits with respect to the faces they belong to.
Rotating the cubes.
Swapping the cubes.

See the comments page for the solution.

Read on website | #mathematics | #puzzle

URL in C

2011-06-03T00:00:00Z

Here is a silly little C puzzle:

#include <stdio.h>

int main(void)
{
    https://susam.net/
    printf("hello, world\n");
    return 0;
}

This code compiles and runs successfully.

$ c99 hello.c && ./a.out
hello, world

However, the C99 standard draft does not mention anywhere that a URL is a valid syntactic element in C. How does this code work then?

Update on 04 Jun 2011: The puzzle has been solved in the comments section. If you want to think about the problem before you see the solutions, this is a good time to pause and think about it. There are spoilers ahead.

The code works fine because https: is a label and // following it begins a comment. In case, you are wondering if // is indeed a valid comment in C, yes, it is, since C99. Download the C99 standard draft, go to section 6.4.9 (Comments) and read the second point which mentions this:

Except within a character constant, a string literal, or a comment, the characters // introduce a comment that includes all multibyte characters up to, but not including, the next new-line character. The contents of such a comment are examined only to identify multibyte characters and to find the terminating new-line character.

Missing Digit Puzzle

2011-05-14T00:00:00Z

There is a 10-digit multiple of 234. 9 of its digits in ascending order are: 0, 1, 1, 2, 3, 4, 5, 7 and 9. What is the missing digit?

See the comments page for the solution.

Read on website | #mathematics | #puzzle

Ternary Operator Puzzle

2011-04-06T00:00:00Z

What is the shortest statement you can write in the C or C++ programming language to express the following statement?

a = (a == 0 ? 0 : 1);

See the comments page for the solution.

Read on website | #c | #programming | #technology | #puzzle

From Out Shuffles to Multiplicative Order

2011-03-23T00:00:00Z

Out Shuffles

A perfect riffle shuffle of a deck of cards involves splitting the deck into two halves (one in each hand) and then alternately dropping one card from each half till all cards have fallen. If the shuffling is done in such a manner that the bottom and the top cards remain preserved at their positions, then it is an out shuffle.

Problem

Here is a problem that a colleague asked me recently while discussing shuffling techniques:

  How many out shuffles do we need to perform on a deck of 52 cards to
  return the deck to its initial state?

Solution

The solution to this problem is rather long, so it has been split into three parts below.

Part 1: Congruence Relation

Let us assume that there are $ n $ cards where $ n $ is a positive even integer. Let us denote these cards as $ c_0, c_1, \dots, c_{n-1} $ where $ c_0 $ is the card at index $ 0 $ (top of the deck), $ c_{n - 1} $ is the card at index $ n - 1 $ (bottom of the deck) and $ c_i $ is the card at index $ i $ where $ 0 \le i \le n - 1. $

For example, if we have $ 8 $ cards, then the cards are denoted as \[ c_0, c_1, c_2, c_3, c_4, c_5, c_6, c_7. \] After the first out shuffle, these cards are now in this order: \[ c_0, c_4, c_1, c_5, c_2, c_6, c_3, c_7. \]

From the problem description and the example above, we see that after a single out shuffle, a card at index $ i $ moves to index $ 2i \bmod (n - 1) $ for $ 0 \le i \lt n - 1 $ and the card at index $ n - 1 $ remains at the same place.

After $ m $ shuffles a card at index $ i $ moves to index $ (2^m i) \bmod (n - 1) $ for $ 0 \le i \lt n - 1. $ The card at index $ n - 1 $ always remains at the same place.

The solution to the problem then is the smallest positive integer $ m $ such that \[ 2^m i \equiv i \pmod{n - 1}. \] for all integers $ i $ that satisfy the inequality $ 0 \le i \lt n - 1. $

In modular arithmetic, we know that \[ ac \equiv bc \pmod{n} \iff a \equiv b \pmod{n / \gcd(c, n)}. \] where $ a, $ $ b, $ $ c $ and $ n $ are integers. Therefore \[ 2^m i \equiv i \pmod{n - 1} \iff 2^m \equiv 1 \pmod{(n - 1) / \gcd(i, n - 1)}. \] Let $ F_{ni} = \frac{n - 1}{\gcd(i, n - 1)} $ where $ 0 \le i \lt n - 1. $ Now the above congruence relation can be written as \[ 2^m \equiv 1 \pmod{F_{ni}}. \]

Part 2: Multiplicative Order

The smallest positive integer $ m $ that satisfies the above congruence relation is known as the multiplicative order of $ 2 $ modulo $ F_{ni}. $ It is denoted as $ \ord_{F_{ni}}(2). $

In general, given an integer $ a $ and a positive integer $ n $ with $ \gcd(a, n) = 1, $ the multiplicative order of $ a $ modulo $ n, $ denoted as $ \ord_{n}(a), $ is the smallest positive integer $ k $ such that \[ a^k \equiv 1 \pmod{n}. \] In this problem, $ n $ is even, so $ n - 1 $ is odd as a result of which $ F_{ni} $ is also odd. As a result, $ \gcd(2, F_{ni}) = 1. $ Therefore, the smallest positive integer $ m $ that satisfies the congruence relation $ 2^m \equiv 1 \pmod{F_{ni}} $ is denoted as $ \ord_{F_{ni}}(2). $

If $ n = 2, $ $ F_{n0} = F_{n1} = 1, $ therefore $ 2^m \equiv 1 \pmod{F_{ni}} $ for $ 0 \le i \lt n - 1 $ and all positive integers $ m. $ This proves the trivial observation that when there are only two cards $ c_0 $ and $ c_1, $ they remain at index $ 0 $ and index $ 1 $ respectively, after any number of out shuffles, i.e. their positions do not change with out shuffles.

Case $ n \ge 4 $

If $ n \ge 4, $ we know that there exists at least one integer between $ 1 $ and $ n - 1 $ that is coprime to $ n - 1 $ because $ \varphi(n) \ge 2 $ for $ n \ge 4 $ where $ \varphi(n) $ represents Euler's totient of $ n. $

Subcase $ i $ is coprime to $ n - 1 $

For any arbitrary $ n \ge 4, $ let $ i $ be an integer that is coprime to $ n - 1 $ such that $ 1 \lt i \lt n - 1. $ Now $ \gcd(i, n - 1 ) = 1, $ so $ F_{ni} = \frac{n - 1}{\gcd(i, n - 1)} = n - 1. $ As a result, $ \ord_{F_{ni}}(2) = \ord_{n - 1}({2}). $ This shows that any card at index $ i $ such that $ i $ is coprime to $ n - 1 $ requires a minimum of $ \ord_{n - 1}(2) $ out shuffles to return to its initial place.

Subcase $ i $ is not coprime to $ n - 1 $

For any arbitrary $ n \ge 4, $ now let us consider the case of a card at index $ i $ such that $ i $ is not coprime to $ n - 1. $ Since $ n - 1 $ is odd, we have $ \gcd(2, n - 1) = 1. $ Therefore, by definition of multiplicative order, \[ 2^{\ord_{n - 1}(2)} \equiv 1 \pmod{n - 1}. \] Since $ F_{ni} \mid n - 1, $ we get, \[ 2^{\ord_{n - 1}(2)} \equiv 1 \pmod{F_{ni}}. \] This shows that a card at index $ i $ such that $ i $ is not coprime to $ n - 1 $ also return to its initial place after $ \ord_{n - 1}(2) $ out shuffles. Actually, it takes only $ \ord_{F_{ni}}(2) $ out shuffles to return the card to its initial place. But $ \ord_{F_{ni}}(2) \mid \ord_{n - 1}(2), $ so $ \ord_{n - 1}(2) = c \ord_{F_{ni}}(2) $ for some positive integer $ c. $ Therefore performing $ \ord_{n - 1}(2) $ out shuffles is same as repeating $ \ord_{F_{ni}}(2) $ out shuffles $ c $ times. Every $ \ord_{F_{ni}}(2) $ brings back the card to its initial position, so repeating it $ c $ times also brings it back to its initial position.

We have shown that a card at index $ i $ such that $ i $ is coprime to $ n - 1 $ takes a minimum of $ \ord_{n - 1}(2) $ out shuffles to return to its initial place. We have also shown that a card at other indices also return to its initial place after the same number of out shuffles. Therefore, it takes a minimum of $ \ord_{n - 1}{2} $ out shuffles to return the deck of cards to its initial state.

Case $ n = 2 $

When there are only $ 2 $ cards in the deck, every out shuffle trivially returns the deck to its initial state. In other words, it takes only $ 1 $ out shuffle to return the deck to its initial state. Indeed $ \ord_{n - 1}(2) = \ord_{1}(2) = 1. $

We have now shown that for any positive even integer $ n, $ a deck of $ n $ cards returns to its initial state after $ \ord_{n - 1}(2) $ out shuffles.

Part 3: Computing Multiplicative Order

For a deck of $ 52 $ cards, we have $ n = 52. $ A minimum of $ \ord_{51}(2) $ out shuffles are required to return the deck to its initial state. To compute $ \ord_{51}(2) $ we first enumerate the powers of $ 2 $ modulo $ 51 $: \begin{alignat*}{2} 2^0 & \equiv 1 && \pmod{51}, \\ 2^1 & \equiv 2 && \pmod{51}, \\ 2^2 & \equiv 4 && \pmod{51}, \\ 2^3 & \equiv 8 && \pmod{51}, \\ 2^4 & \equiv 16 && \pmod{51}, \\ 2^5 & \equiv 32 && \pmod{51}, \\ 2^6 & \equiv 13 && \pmod{51}, \\ 2^7 & \equiv 26 && \pmod{51}, \\ 2^8 & \equiv 1 && \pmod{51}. \end{alignat*} The smallest positive integer $ k $ such that $ 2^k \equiv 1 \pmod{51} $ is 8, so $ \ord_51(2) = 8. $ We need $ 8 $ out shuffles to return a deck of $ 52 $ cards to its initial state.

Read on website | #mathematics | #combinatorics | #puzzle

Polar Bear Puzzle

2011-03-09T00:00:00Z

Alice asked Bob, "A bear walked 1 km south, then 1 km west, then 1 km north and it was back at the point from where it started. What colour was the bear most likely to be?"

Bob thought for a while, could not arrive at an answer and gave up. Alice explained, "Well, the answer is white. It is a polar bear. It is only when you start from the North Pole that after travelling 1 km south, 1 km west and 1 km north you would end up at the point where you started."

Bob replied, "That is an interesting solution. Now that I understand your solution, I realise that there are other starting points apart from the North Pole where one could walk 1 km south, then 1 km west and then 1 km north to return to the starting point."

Can you find all the other such starting points that Bob is talking about?

See the comments page for the solution.

Read on website | #mathematics | #puzzle

Shrinking List Puzzle

2011-02-17T00:00:00Z

The first $ 9 $ natural numbers are given in a list. You are supposed to select two numbers randomly from the list, call them $ x $ and $ y, $ remove them from the list and insert $ x + y + xy $ into the list. You keep repeating this until you are left with only one number in the list. Find the final number that is left in the list.

See the comments page for the solution.

Read on website | #mathematics | #puzzle

From Diophantine Equation to Fermat's Last Theorem

2011-01-12T00:00:00Z

Here is a puzzle I created recently for my friends who love to indulge in recreational mathematics:

  Find all integer solutions to the equation

  \[
    y^2 + 3 = \frac{x^3}{18}.
  \]

If you want to think about this puzzle, this is a good time to pause and think about it. There are spoilers ahead.

It does not take long to realise that this is a Diophantine equation of the form $ a^n + b^n = c^n. $ Here is how the equation looks after rearranging the terms: \[ x^3 = 18y^2 + 54. \]

The right hand side is positive, so any $ x $ that satisfies this equation must also be positive, i.e. $ x \gt 0 $ must hold good for any solution $ x $ and $ y. $

Also, if some $ y $ satisfies the equation, then $ -y $ also satisfies the equation because the right hand side value remains the same for both $ y $ and $ -y. $

The right hand side is $ 2(9y^2 + 3^3). $ This is of the form $ 2(3a^2b + b^3) $ where $ a = y $ and $ b = 3. $ Now $ 2(3a^2b + b^3) = (a + b)^3 - (a - b)^3. $ Using these details, we get \[ x^3 = 18y^2 + 54 = 2(9y^2 + 3^3) = (y + 3)^3 - (y - 3)^3. \] Rearranging the terms, we get \[ x^3 + (y - 3)^3 = (y + 3)^3. \] From Fermat's Last Theorem, we know that an equation of the form $ a^n + b^n = c^n $ does not have any solution for positive integers $ a, $ $ b, $ $ c $ and positive integer $ n \gt 2. $ We know that $ x \gt 0. $ Therefore $ y \gt 3 $ contradicts Fermat's Last Theorem. Thus the inequality $ y \le 3 $ must hold good. Further since for every solution $ x $ and $ y, $ there is also a solution $ x $ and $ -y, $ the inequality $ -y \le 3 $ must also hold good. Therefore values of $ x $ and $ y $ that satisfy the above equation must satisfy the following inequalities: \begin{align*} x \gt 0, \\ -3 \le y \le 3. \end{align*} Since $ y $ must be one of the seven integers between $ -3 $ and $ 3, $ inclusive, we can try solving for $ x $ with each of these seven values of $ y. $ When we do so, we find that there are only two values of $ y $ for which we get integer solutions for $ x. $ They are $ y = 3 $ and $ y = -3. $ In both cases, we get $ x = 6. $ Therefore, the solutions to the given equation are: \[ x = 6, \qquad y = \pm 3. \]

Read on website | #mathematics | #combinatorics | #puzzle

Stack Overwriting Function

2010-07-28T00:00:00Z

Skipping Over a Function Call

Here is a C puzzle that involves some analysis of the machine code generated from it followed by manipulation of the runtime stack. The solution to this puzzle is implementation-dependent. Here is the puzzle:

Consider this C code:

#include <stdio.h>

void f()
{
}

int main()
{
    printf("1\n");
    f();
    printf("2\n");
    printf("3\n");
    return 0;
}

Define the function f() such that the output of the above code is:

1
3

Printing 3 in f() and exiting is not allowed as a solution.

If you want to think about this problem, this is a good time to pause and think about it. There are spoilers ahead.

The solution essentially involves figuring out what code we can place in the body of f() such that it causes the program to skip over the machine code generated for the printf("2\n") operation. I'll share two solutions for two different implementations:

gcc 4.3.2 on 64-bit Debian 5.0.3 running on 64-bit Intel Core 2 Duo.
Microsoft Visual Studio 2005 on 32-bit Windows XP running on 64-bit Intel Core 2 Duo.

Solution for GCC

Let us first see step by step how I approached this problem for GCC. We add a statement char a = 7; to the function f(). The code looks like this:

#include <stdio.h>

void f()
{
    char a = 7;
}

int main()
{
    printf("1\n");
    f();
    printf("2\n");
    printf("3\n");
    return 0;
}

There is nothing special about the number 7 here. We just want to define a variable in f() and assign some value to it.

Then we compile the code and analyse the machine code generated for f() and main() functions.

$ gcc -c overwrite.c && objdump -d overwrite.o

overwrite.o:     file format elf64-x86-64


Disassembly of section .text:

0000000000000000 <f>:
   0:   55                      push   %rbp
   1:   48 89 e5                mov    %rsp,%rbp
   4:   c6 45 ff 07             movb   $0x7,-0x1(%rbp)
   8:   c9                      leaveq
   9:   c3                      retq

000000000000000a <main>:
   a:   55                      push   %rbp
   b:   48 89 e5                mov    %rsp,%rbp
   e:   bf 00 00 00 00          mov    $0x0,%edi
  13:   e8 00 00 00 00          callq  18 <main+0xe>
  18:   b8 00 00 00 00          mov    $0x0,%eax
  1d:   e8 00 00 00 00          callq  22 <main+0x18>
  22:   bf 00 00 00 00          mov    $0x0,%edi
  27:   e8 00 00 00 00          callq  2c <main+0x22>
  2c:   bf 00 00 00 00          mov    $0x0,%edi
  31:   e8 00 00 00 00          callq  36 <main+0x2c>
  36:   b8 00 00 00 00          mov    $0x0,%eax
  3b:   c9                      leaveq
  3c:   c3                      retq

When main() calls f(), the microprocessor saves the return address (where the control must return to after f() is executed) in stack. The line at offset 1d in the listing above for main() is the call to f(). After f() is executed, the instruction at offset 22 is executed. Therefore the return address that is saved on stack is the address at which the instruction at offset 22 would be present at runtime.

The instructions at offsets 22 and 27 are the instructions for the printf("2\n") call. These are the instructions we want to skip over. In other words, we want to modify the return address in the stack from the address of the instruction at offset 22 to that of the instruction at offset 2c. This is equivalent to skipping 10 bytes (0x2c - 0x22 = 10) of machine code or adding 10 to the return address saved in the stack.

Now how do we get hold of the return address saved in the stack when f() is being executed? This is where the variable a we defined in f() helps. The instruction at offset 4 is the instruction generated for assigning 7 to the variable a.

From the knowledge of how microprocessor works and from the machine code generated for f(), we find that the following sequence of steps are performed during the call to f():

The microprocessor saves the return address by pushing the content of RIP (instruction pointer) register into the stack.
The function f() pushes the content of the RBP (base pointer) register into the stack.
The function f() copies the content of the RSP (stack pointer) register to the RBP register.
The function f() stores the byte value 7 at the memory address specified by the content of RBP minus 1. This achieves the assignment of the value 7 to the variable a.

After 7 is assigned to the variable a, the stack is in the following state:

Address Content Size (in bytes)

&a + 5 Return address (old RIP) 8

&a + 1 Old base pointer (old RBP) 8

&a Variable a 1

Address	Content	Size (in bytes)
`&a + 5`	Return address (old RIP)	8
`&a + 1`	Old base pointer (old RBP)	8
`&a`	Variable `a`	1

If we add 9 to the address of the variable a, i.e. &a, we get the address where the return address is stored. We saw earlier that if we increment this return address by 10 bytes, it solves the problem. Therefore here is the solution code:

#include <stdio.h>

void f()
{
    char a;
    (&a)[9] += 10;
}

int main()
{
    printf("1\n");
    f();
    printf("2\n");
    printf("3\n");
    return 0;
}

Finally, we compile and run this code and confirm that the solution works fine:

$ gcc overwrite.c && ./a.out
1
3

Solution for Visual Studio

Now we will see another example solution, this time for Visual Studio 2005.

Like before we define a variable a in f(). The code now looks like this:

#include <stdio.h>

void f()
{
    char a = 7;
}

int main()
{
    printf("1\n");
    f();
    printf("2\n");
    printf("3\n");
    return 0;
}

Then we compile the code and analyse the machine code generated from it.

C:\>cl overwrite.c
Microsoft (R) 32-bit C/C++ Optimizing Compiler Version 14.00.50727.42
for 80x86
Copyright (C) Microsoft Corporation.  All rights reserved.

overwrite.c
Microsoft (R) Incremental Linker Version 8.00.50727.42
Copyright (C) Microsoft Corporation.  All rights reserved.

/out:overwrite.exe
overwrite.obj

C:\>dumpbin /disasm overwrite.obj
Microsoft (R) COFF/PE Dumper Version 8.00.50727.42
Copyright (C) Microsoft Corporation.  All rights reserved.


Dump of file overwrite.obj

File Type: COFF OBJECT

_f:
  00000000: 55                 push        ebp
  00000001: 8B EC              mov         ebp,esp
  00000003: 51                 push        ecx
  00000004: C6 45 FF 07        mov         byte ptr [ebp-1],7
  00000008: 8B E5              mov         esp,ebp
  0000000A: 5D                 pop         ebp
  0000000B: C3                 ret
  0000000C: CC                 int         3
  0000000D: CC                 int         3
  0000000E: CC                 int         3
  0000000F: CC                 int         3
_main:
  00000010: 55                 push        ebp
  00000011: 8B EC              mov         ebp,esp
  00000013: 68 00 00 00 00     push        offset $SG2224
  00000018: E8 00 00 00 00     call        _printf
  0000001D: 83 C4 04           add         esp,4
  00000020: E8 00 00 00 00     call        _f
  00000025: 68 00 00 00 00     push        offset $SG2225
  0000002A: E8 00 00 00 00     call        _printf
  0000002F: 83 C4 04           add         esp,4
  00000032: 68 00 00 00 00     push        offset $SG2226
  00000037: E8 00 00 00 00     call        _printf
  0000003C: 83 C4 04           add         esp,4
  0000003F: 33 C0              xor         eax,eax
  00000041: 5D                 pop         ebp
  00000042: C3                 ret

  Summary

           B .data
          57 .debug$S
          2F .drectve
          43 .text

Just like in the previous objdump listing, in this listing too, the instruction at offset 4 shows where the variable a is allocated and the instructions at offsets 25, 2A and 2F show the instructions we want to skip, i.e. instead of returning to the instruction at offset 25, we want the microprocessor to return to the instruction at offset 32. This involves skipping 13 bytes (0x32 - 0x25 = 13) of machine code.

Unlike the previous objdump listing, in this listing we see that the Visual Studio I am using is a 32-bit on, so it generates machine code to use 32-bit registers like EBP, ESP, etc. Thus the stack looks like this after 7 is assigned to the variable a:

Address Content Size (in bytes)

&a + 5 Return address (old EIP) 4

&a + 1 Old base pointer (old EBP) 4

&a Variable a 1

Address	Content	Size (in bytes)
`&a + 5`	Return address (old EIP)	4
`&a + 1`	Old base pointer (old EBP)	4
`&a`	Variable `a`	1

If we add 5 to the address of the variable a, i.e. &a, we get the address where the return address is stored. Here is the solution code:

#include <stdio.h>

void f()
{
    char a;
    (&a)[5] += 13;
}

int main()
{
    printf("1\n");
    f();
    printf("2\n");
    printf("3\n");
    return 0;
}

Finally, we compile and run this code and confirm that the solution works fine:

C:\>cl /w overwrite.c
Microsoft (R) 32-bit C/C++ Optimizing Compiler Version 14.00.50727.42
for 80x86
Copyright (C) Microsoft Corporation.  All rights reserved.

overwrite.c
Microsoft (R) Incremental Linker Version 8.00.50727.42
Copyright (C) Microsoft Corporation.  All rights reserved.

/out:overwrite.exe
overwrite.obj

C:\>overwrite.exe
1
3

Conclusion

The machine code that the compiler generates for a given C code is highly dependent on the implementation of the compiler. In the two examples above, we have two different solutions for two different compilers.

Even with the same brand of compiler, the way it generates machine code for a given code may change from one version of the compiler to another. Therefore, it is very likely that the above solution would not work on another system (such as your system) even if you use the same compiler that I am using in the examples above.

However, we can arrive at the solution for an implementation of the compiler by determining what number to add to &a to get the address where the return address is saved on stack and what number to add to this return address to make it point to the instruction we want to skip to after f() returns.

Read on website | #c | #programming | #technology | #puzzle

Illiteracy and Digital Weighing Scale

2010-07-06T00:00:00Z

Here is a real life problem from a silica bricks factory in a small industrial town in India. There are illiterate workers who cannot identify decimal digits. The management team of the factory is trying to figure if there is a way for these workers to operate a digital weighing scale to fill buckets with a certain mass of a given material. For example, they may be asked to fill 5.3 kg of a certain material in the bucket, i.e. decimal fractions are involved.

If the factory were using a beam balance, this would have been an easy problem to solve. The workers could then place the required weight in one pan and keep pouring the material in the other pan until the beam appears to be balanced.

However this factory uses a digital weighing scale which involves recognising decimal digits to read the measurement. What do you think is the easiest way to train the workers to do their job without having to teach them how to count?

I have a solution in mind which would involve configuring the digital weighing scale in a certain way for every measurement the workers have to make. I will propose this solution to the management team of the factory. But I would like to know any suggestions you have and take them into account as well before proposing my solution. I will also share the solution I have in mind after learning about your suggestions.

Update on 08 July 2010: Prunthaban has suggested a solution in the comments section which is pretty much what I had in mind too. I will propose this solution to the factory. The solution works like this: Say the worker has to fill 5.3 kg of a certain material into the bucket. A literate supervisor first places 5.3 kg of that material on the weighing scale. The instrument now shows "5.3 kg" on its display. Now the remainder of the solution assumes that the digital weighing balance has a calibration wheel to calibrate the instrument. The supervisor turns the calibration wheel until the display shows "0.0" kg while the 5.3 kg of material is still placed on it. Now the material is removed from the balance and the display shows "-5.3 kg". Now all a worker needs to do is pour the given material on this calibrated balance until the display shows "0.0 kg". As long as the workers can be taught to recognise the digit "0", this solution should work fine.

Update on 05 Aug 2010: The above solution was successfully implemented in OCL India Limited, the silica bricks factory where this problem was faced. The digital weighing balance involved in the problem indeed had a calibration wheel, so the above solution worked for them. Thank you, Prunthaban and others who participated in this discussion.

Read on website | #miscellaneous | #puzzle

ADAC and HE Puzzles from GEB

2009-05-16T00:00:00Z

I have been reading Gödel, Escher, Bach: An Eternal Golden Braid by Douglas R. Hofstadter for a few weeks. The book follows an interesting format of alternating between chapters and dialogues between imaginary charaters. In the words of the author:

The long and the short of it is that I eventually decided - but this took many months - that the optimal structure would be a strict alternation between chapters and dialogues. Once that was clear, then I had the joyous task of trying to pinpoint the most crucial ideas that I wanted to get across to my readers and then somehow embodying them in both the form and the content of fanciful, often punning dialogues between Achilles and the Tortoise (plus a few new friends).

After the second chapter (Chapter II: Meaning and Form in Mathematics) there is a dialogue between Achilles and the Tortoise on telephone. The title of the dialogue is Sonata for Unaccompanied Achilles. The text shows the transcript of only one end of the call, only what Achilles speaks. The Tortoise is at the far end of the call. The sentences spoken by the Tortoise at the other end are not present in the text. This makes the reading experience very interesting as we keep guessing about what is going on at the other end.

It starts in this manner:

Achilles: Hello, this is Achilles.
Achilles: Oh, hello, Mr. T. How are you?
Achilles: A torticollis? Oh, I'm sorry to hear it. Do you have any idea what caused it?

As the dialogue proceeds, they share a few puzzles. Here is the first one from the Tortoise.

Achilles: A word with the letters 'A', 'D', 'A', 'C' consecutively inside it … Hmm … What about "abracadabra"?
Achilles: True, "ADAC" occurs backwards, not forwards, in that word.
Achilles: Hours and hours? It sounds like I'm in for a long puzzle, then. Where did you hear this infernal riddle?

Here is the second puzzle from Achilles:

Achilles: Say, I once heard a word puzzle a little bit like this one. Do you want to hear it? Or would it just drive you further into distraction?
Achilles: I agree - can't do any harm. Here it is: What's a word that begins with the letters "HE" and also ends with "HE"?
Achilles: Very ingenious - but that's almost cheating. It's certainly not what I meant!
Achilles: Of course you're right - it fulfills the conditions, but it's a sort of "degenerate" solution. There's another solution which I had in mind.
Achilles: That's exactly it! How did you come up with it so fast?
Achilles: So here's a case where having a headache actually might have helped you, rather than hindering you. Excellent! But I'm still in the dark on your "ADAC" puzzle.

If you want to think about these puzzles, this is a good time to pause and think about them. There are spoilers ahead.

It did not take much time for me to solve the puzzle because I cheated with the word list file available on Linux distributions. Here is what I found with my Debian 5.0 (lenny) system:

$ grep 'adac' /usr/share/dict/words
headache
headache's
headaches
$ grep '^he.*he$' /usr/share/dict/words
headache
heartache

The answers to both puzzles seem to be "HEADACHE". Take another look at the last sentence in the dialogue above. It makes sense now as Achilles says that having a headache might have helped the Tortoise.

Later in the dialogue the Tortoise offers figure and ground as hints to the "ADAC" puzzle.

Achilles: Well, normally I don't like hints, but all right. What's your hint?
Achilles: I don't know what you mean by "figure" and "ground" in this case.
Achilles: Certainly I know Mosaic II! I know ALL of Escher's works. After all, he's my favorite artist. In any case, I've got a print of Mosaic II hanging on my wall, in plain view from here.
Achilles: Yes, I see all the black animals.
Achilles: Yes, I also see how their "negative" space - what's left out - defines the white animals.
Achilles: So THAT's what you mean by "figure" and "ground". But what does that have to do with the "ADAC" puzzle?
Achilles: Oh, this is too tricky to me. I think I'M starting to get a headache.

The famous painting discussed in the dialogue can be found here: https://www.wikiart.org/en/m-c-escher/mosaic-ii. We can see how the black animals form the figure (the positive space) and how the background or ground (the negative space) beautifully fits all the white animals.

The figure and ground in hints make sense now. The first puzzle has "ADAC" in the question. Let us consider "ADAC" as the figure or the positive space. If we remove "ADAC" from "HEADACHE", we are left with the ground or negative space, which consists of "HE" and "HE" at the beginning and the end of the word. The figure is used in the first puzzle and the ground is used in the second puzzle.

By the way, what is the first answer from the Tortoise that Achilles finds very ingenious but degenerate? I believe, it is "HE" as this word both begins and ends with "HE".

The funny thing about this dialogue is that both of them asked two puzzles to each other without knowing that the answers to them were the same. A similar thing happened to me when a colleague of mine and I challenged each other with combinatorics puzzles. See this blog post for the story: Combinatorics Coincidence.

Read on website | #miscellaneous | #book | #puzzle

Susam's Puzzles

Fizz Buzz in CSS

Fizz Buzz with Cosines

Contents

Definitions

Symbol Functions

Index Function

Fizz Buzz Sequence

From Indicator Functions to Cosines

Indicator Functions

Complex Exponentials

Cosines

Discrete Fourier Transform

One Period of Fizz Buzz

Fourier Coefficients

Inverse Transform

Conclusion

Mutually Attacking Knights

Contents

Introduction

Counting Placements as the Board Grows

Type A Squares

Type B Squares

Type C Squares

Type D Squares

Closed Form Expression

Counting Placements for Each Square

Attacking Degrees of Squares

From Attacking Degrees to Counting Placements

Closed Form Expression

Counting Placements From Minimal Attack Sections

Minimal Attack Sections

Closed Form Expression

References

Zigzag Number Spiral

Contents

Introduction

Patterns on the Edges

Computing Edge Numbers

Computing All Grid Numbers

Closed Form Expression

Patterns on the Diagonal

Computing Diagonal Numbers

Computing All Grid Numbers

Closed Form Expression

References

Wordle With Grep

Contents

Preliminary Work

Wordle #217

Wordle #218

Wordle #219

Loopy C Puzzle

Integer Underflow

Puzzle

Solutions

Generalisation

Lemmas

Theorems

From Tower of Hanoi to Counting Bits

Tower of Hanoi

Binary Numbers

Assumptions

Binary Puzzle

Langford Pairing

Permutation Problem

Getting Started

Conjecture

Necessity

Sufficiency

Notation

Case \( n \equiv 0 \pmod{4} \)

Case \( n \equiv 3 \pmod{4} \)

Magical Chameleons Puzzle

Calendar Cubes Puzzle

URL in C

Missing Digit Puzzle

Ternary Operator Puzzle

From Out Shuffles to Multiplicative Order

Out Shuffles