Unlock Multiplication Without Tables: Russian Peasant Multiplication Explained and Implemented in Python

What Is Russian Peasant Multiplication?

Russian peasant multiplication (RPM) is an arithmetic technique that allows you to multiply large numbers without memorizing the full multiplication table. Its origins are uncertain, with possible links to ancient Egyptian methods, but it remains a fascinating algorithm.

Step‑by‑Step Example: 89 × 18

To compute 89 × 18, create two adjacent columns: the halving column (starting with 89) and the doubling column (starting with 18). Repeatedly halve the first number, discarding remainders, and double the second number until the halving column reaches 1.

After constructing the full table, delete every row where the halving value is even. Finally, sum the remaining values in the doubling column to obtain the product (1602).

The method works because the halving column records the binary expansion of the first multiplier, and the corresponding doubling values represent powers of two multiplied by the second multiplier.

Why Use RPM?

RPM demonstrates that even a basic operation like multiplication can be performed creatively, often with lower memory usage at the cost of speed. It highlights the trade‑off between computational speed and memory consumption, a key consideration in algorithm design.

Python Implementation of RPM

The algorithm can be implemented concisely in Python. Below is a complete example using only built‑in functions and the pandas library for table handling.

n1 = 89
n2 = 18

import math
halving = [n1]
while min(halving) > 1:
    halving.append(math.floor(min(halving) / 2))

doubling = [n2]
while len(doubling) < len(halving):
    doubling.append(max(doubling) * 2)

import pandas as pd
half_double = pd.DataFrame(zip(halving, doubling))
# Keep rows where the halving value is odd
half_double = half_double.loc[half_double[0] % 2 == 1, :]
# Sum the remaining doubling values
answer = sum(half_double.loc[:, 1])
print(answer)  # 1602

Placing the smaller multiplier in the halving column generally yields a faster execution because the halving process terminates sooner.

Takeaway

RPM illustrates how binary representation underlies a simple yet powerful multiplication technique, offering a low‑memory alternative to traditional methods and encouraging exploration of unconventional algorithms.