In this post I will assume that you understand the game. If you don’t, please read this page and come back.

Technical Details

From here on, the term “size of the board” will always mean the number of dots along each edge, not the number of boxes. The game board will always be a square.

Each dot is assigned a single number. The top-left dot is assigned 1, and the number is incremented by one as we move to the right (like the periodic table).

The image below shows a 4×4 board, along with the labels assigned to points.

Your submission must include a function move which accepts a single parameter board. board is an object that contains 3 members: size is a single integer that denotes the size of the board, connections is an array that consists of moves that have been performed so far (this is described below), and valid_moves is an array of moves that your bot can legally perform at this point.

Your function must return a single “move”, which is basically an array of two integers which correspond to the dots you wish to connect. For example, [1, 2] will connect the top left dot and the one immediately to its right. board['valid_moves'] and board['connections'] are arrays of moves of this sort.

Here are two sample bots: one which will perform the first valid move it is provided, and another which will perform a random move.

1
2
3
4
5
6
7

function random_element(myArray) {
  return myArray[Math.floor(Math.random() * myArray.length)];
}

function move(board) {
  return random_element(board.valid_moves);
}

1
2
3

function move(board) {
  return board['valid_moves'][0];
}

Local Development

This package will allow you to test variations of your bot locally. The tool requires that Java is installed on your computer. It has been tested on OS X (Lion), Linux (Ubuntu and Arch) and Windows (Vista). It should be able to work on any other platform as well, if you are having trouble please leave a comment below.

The package contains a JAR file and a directory. The JAR file should be run using the command:

java -Djruby.compat.version=1.9 -jar local_tournament.jar [size]

You should replace [size] with the size of the map you wish to use. You should probably run it using a size of 10, because that is the map size the tournament will be using. Do not omit the argument, doing so will result in the map size being set to 0, which is quite useless.

Results

The replays can be downloaded here.

Markov Bigrams

You are working on a new “RPG Hero Name Generator” application. In order to generate the names, rather than going for a dictionary approach you decide to explore something more along the lines of Markov-chain text generation. Since you are generating character names rather than paragraphs, you treat each character as a state, and in order to simplify matters you make the assumption that each letter is independent of all of the letters coming before it except for its immediate predecessor.

The input consists of two lines. The first character of the first line is the character to be considered. The rest of the line will consist of an arbitrary number of characters, this is the sample of text to be considered. Ignore the content of the second line. You are to output a single character, the one which occurs most frequently after the given character in the sample.

The number of characters is small enough that you need not worry about exceeding the limits of int. The character string will consist of only uppercase or lowercase alphabets, you will not encounter any other characters.

Comments and Solution

Despite the amount of jargon present, this is a fairly simple problem. The first paragraph only provides some context, and can be ignored for the sake of solving the problem. All that needs to be done in this problem is to count the frequencies of letter when they occur after a certain given character, and output the character that occurs most frequently.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

main() {
  char c = getchar(), t, p = -1;
  int freq[128] = {0};

  while ( (t = getchar()) != '\n' ) {
    if (p == c)
      freq[t] ++;
    p = t;
  }

  for (t=0; t<127; t++)
    if (freq[t] > freq[c])
      c = t;

  putchar(c);
  return 0;
}

The winning solution by M. is only 101 characters, can you bring this down to that?

F1 Score

You are working on a spam classification system using a new machine learning algorithm that you devised yourself. Surprised by its abysmal performance, you start to investigate how to improve its accuracy. You decide to run a genetic algorithm to pick the best among various variants of your algorithm. You have picked F1-score as the evaluation metric, and need an efficient implementation that will compute the F1-score.

The first line of input to your program will be a single integer m (<= 100) that represents the size of your cross-validation set. This is followed by m lines, each containing two characters. Each character will be either a ‘+’ or a ‘-’. The first character represents the correct classification of an item in the cross-validation set, and the second character represents the output of your algorithm. As you might guess, ‘+’ corresponds to a positive classification and ‘-’ is a negative classification.

Your program is to output the F1-score with respect to the cross-validation set, with two digits after the decimal point. The following formulae might help:

\[ \text{precision} = \frac { \text{true positives} } {\text{true positives} + \text{false positives} } \]
\[ \text{recall} = \frac {\text{true positives}} {\text{true positives} + \text{false negatives}} \]
\[ \text{F1-score} = \frac {2 \times \text{precision} \times \text{recall}} {\text{precision} + \text{recall}} \]

Definitions:

• A true positive is an example that was correctly classified by your algorithm as positive.
• A true negative is an example that was correctly classified as negative.
• A false positive is an example that is actually negative, but which was classified as positive.
• A false negative is a positive example that was incorrectly classified as negative.

Comments and Solution

This was by far the easiest problem, it got the most submissions by a pretty large margin. The naive solution is shown below.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

#define eq(X, a) ((X[0] == a[0]) && (X[1] == a[1]))

main() {
  int t;
  float tp, tn, fp, fn, p, r;
  tp = tn = fp = fn = 0;
  char c[3];
  scanf("%d\n", &t);

  while (t--) {
    gets(c);
    if (eq(c, "++")) tp++;
    if (eq(c, "+-")) fn++;
    if (eq(c, "-+")) fp++;
    if (eq(c, "--")) tn++;
  }

  p = tp / (tp + fp);
  r = tp / (tp + fn);

  printf("%.2f", 2*p*r / (p+r));

  return 0;
}

The size of this solution can be brought down by taking into account, for one, the fact that “true negatives” are never used anywhere. Another thing to do would be to get rid of the intermediate precision and recall computations, and to compute the F1 score directly.

The best solution by Ankit Gupta at 133 characters is truly a work of art. M.‘s solution is also quite amazing, but the second optimization was not used; this increased the size of M.’s submission.

k-Nearest Neighbors

Despite your best efforts, your classification algorithm doesn’t work out as well as you had hoped. Not one to be fazed by failure, you decide to go for a more standard algorithm this time, and after spending a short amount on Wikipedia you pick the k-Nearest Neighbors algorithm because of how easy it would be to implement.

In order to further reduce complications, you decide that you don’t want to deal with implementing kNN in a feature-space with a large number of dimensions, and so you apply Principle Component Analysis to reduce the number of features to one and hope for the best. To simplify the problem even further, you decide to set k=1.

The first line of input consists of a single integer n (< 100), the number of examples. This is followed by n lines each consisting of a single real number and a character (‘+’ or ‘-’) separated by a single space. The integer represents the value of the feature, and ‘+’ or ‘-’ represents the correct classification of the item that corresponds to the feature value.

This is followed by a line containing a single integer m (<= 100), the number of queries. After this there will be m lines each containing a single integer, which is the value of the feature for the item you must classify. For each query output the classification of the example whose feature value is closest to the given integer.

Comments and Solution

To summarize the problem, you will be given a set of integer-character pairs, and you need to output the character for which the lvalue (the integer which corresponds to the character) is closest to a given integer.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

main() {
  int n, m, k, t=0, i;
  scanf("%d\n", &n);
  int s[n][2];

  for (i=0; i<n; i++)
    scanf("%d %c\n", &s[i][0], &s[i][1]);

  scanf("%d\n", &m);

  while (m--) {
    scanf("%d\n", &k);
    for (i=0; i<n; i++) {
      if ( abs(k - s[t][0]) > abs(k - s[i][0]) )
        t = i;
    }
    putchar(s[t][1]);
  }

  return 0;
}

The best solution was submitted by Abhay Prakarsh, and has 157 characters.

Perceptron

Surprisingly even the nearest neighbor approach didn’t work well. Your faculty advisor says that it is because of your abuse of Principle Component Analysis, but you think it is more due to the fact that kNN is a high variance algorithm, and your dataset is too noisy for it to work well. After some more research, you stumble upon an algorithm called Logistic Regression (a.k.a a single layer perceptron).

The Logistic Regression algorithm basically involves fitting a given dataset to the function

\[ f(z) = \frac 1 {1 + e^{-z}} \]

where z is the dot product of two vectors: a vector containing the “intercept” and “regression coefficients” and another containing the features. The dimensionality of the first vector is one larger than the dimensionality of the feature space, this is because of the intercept term. There are two ways to treat the bias term: one is to neglect it while performing the dot product and to add it to the result, the other is to add in an extra “1” at the front of the feature vector, which ends up having the same effect as the first method because the intercept is the first term of the first vector, and 1 becomes the first term of the second.

Since this algorithm is to be used for classification, a threshold value T is used: if the output of linear regression is greater than or equal to T the example is classified as positive, otherwise it is classified as negative. You make an arbitrary choice and pick T=0.5.

You have already created the portion of the system that handles learning from the dataset, all that is left is to write the part that makes predictions on new items. The first line of input will contain two space-separated integers: the dimensionality of the feature space (d) and the number of items to be classified (q). This is followed by a line containing (d+1) integers which correspond to the vector with the intercept and regression coefficient. After this there will be q lines, each with d integers that correspond to the feature vector. For each of these q lines you are to output a single character, ‘+’ or ‘-’ depending on whether the input is classified as positive or negative. Both q and d are less than 50.

Comments and Solution

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

#define classify(x) (((x) >= 0.5) ? '+' : '-')

float sigmoid(float x) {
  return 1 / (1 + exp((double) -x));
}

main() {
  int d, q, i, a, t;
  scanf("%d %d\n", &d, &q);
  int beta[d+1];

  for (i=0; i<d; i++)
    scanf("%d ", &beta[i]);

  scanf("%d\n", &beta[i]);

  while (q--) {
    a = beta[0];
    for (i=1; d>i; i++) {
      scanf("%d ", &t);
      a += beta[i] * t;
    }
    scanf("%d\n", &t);
    a += beta[i] * t;
    putchar(classify(sigmoid(a)));
  }

  return 0;
}

Note that is is possible to completely skip computing the sigmoid function, whenever \( z \geq 0 \) the classification would be positive, and when \( z < 0 \) the classification would be negative. The best solution by Piyush Kapoor comes in at 166 characters.

Coin Toss Game

Roger challenges Dave to play a game involving coins. In the game, a fair coin is tossed n times. If, during the coin tosses, heads occurs two or more times in a row, Roger would win; otherwise Dave would win.

Dave disagrees with Roger, because as n grows, so does Roger’s chances of winning. Eventually, both of them agree to arrange the bet amounts in such a way that both players end up with an equal expected gain. For this purpose, they need your help. You need to write a program that, for a given value of n, will output the probability of Dave winning the game.

The first line of input will be a number t, the number of testcases. This will be followed by t lines, each containing a positive integer less than or equal to 20. For each integer, output the probability of Dave winning the game. Include 6 digits after the decimal point in your answer.

Comments and Solution

I am going to omit the derivation, but it can be shown that the probability is \(\frac {F(n+2)} {2^n}\), where \( F(n) \) is the nth Fibonacci number.

1
2
3
4
5
6
7
8
9
10
11
12
13

int fib(n) {
  return n < 2 ? n : fib(n-1) + fib(n-2);
}

int main() {
  int t, n;
  scanf("%d\n", &t);
  while (t--) {
    scanf("%d\n", &n);
    printf("%f\n", fib(n+2) / pow(2, n));
  }
  return 0;
}

The best solution by Piyush Kapoor comes in at 136 characters. His solution computes the relevant Fibonacci number using an inline iterative method, and uses bit shifting to avoid requiring pow().

Spiral Numbers

Dennis is programming a robot that is supposed to paint a horizontal line. Not being one to care much about efficiency, Dennis programs the robot to move in an anti-clockwise spiral as shown below.

The robot starts at position zero, then moves to position 1, then position 2 and so on. Dennis wants all of the tiles to the right of 0 to be painted black. (These tiles are represented as bold numbers in the figure above.)

Your task is to help Dennis by telling him which is the nth tile that must be painted black, with the zeroth tile being zero.

Comments and Solution

The spiral in this problem is constructed in the same way as Ulam’s Spiral. With a little bit of derivation, you can see that the nth spiral number is given by \(4n^2 – 3n\).

1
2
3
4

gets.to_i.times do
  n = gets.to_i
  puts 4*n*n - 3*n
end

Counting Stars

Galileo’s latest project involves determining the density of stars in certain regions of the sky. For this purpose he started looking for datasets online, and discovered a dataset on Newton’s blog. Newton had decomposed the night sky into a Voronoi tessellation with the generators arranged in a grid. He has stored the number of stars in a Voronoi cell at a position in a matrix that corresponds to the position of the generator in the grid.

This dataset does not directly help Galileo, because he needs to be able to query the number of stars in a rectangular portion of the sky. Galileo tried to write a program that does this on his own, but it turned out to be too slow. Can you help him?

Comments and Solution

This problem would have been far more interesting with a stricter time limit. As it is now, even solutions that take the naive approach of looping over the relevant section each time would be accepted. A more efficient way of solving this problem (given that there would be a large number of queries for a single dataset) would be to construct a “dominance matrix”, in which each element of the matrix D[x][y] is the sum of all elements of the dataset A[i][j] with \(i \leq x\) and \(j \leq y\). Using this approach, the doubly nested loop in the naive approach can be replaced with four array lookups.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

a, b = gets.split.map {|x| x.to_i }
data = []

a.times do
  data << gets.split.map {|x| x.to_i }
end

gets.to_i.times do
  px, py, qx, qy = gets.split.map {|x| x.to_i }
  sum = 0
  for x in (px-1)..(qx-1)
    for y in (py-1)..(qy-1)
      sum += data[x][y]
    end
  end
  puts sum
end

Protecting Sheep

Useless Fencing Inc. has recently scored a contract to create a fence around a bunch of sheep in light of recent wolf attacks. As implied by their name, Useless Fencing tries to use as little fencing material as possible.

In order to determine the location of each of the sheep, Useless Fencing has deployed a system consisting of laser range-finders. This has given them the location of each of the sheep, however because of errors inherent in the system, they only know that each of the sheep is inside a square of side 2 units. (Note that the orientation of all of these squares is identical, and the coordinate system has been selected so that each of the sides are parallel to one of the axes.)

The sheep are rather lazy (they never move), but none of them should be left outside the fence. Your task is to determine the minimum possible length of the fence.

Comments

This problem boils down to finding the Convex Hull. Finding the convex hull of a set of points in a plane can be thought of as stretching a rubber band so that it covers all of the points, and then releasing it so that it becomes taut. This image will probably be helpful in understanding the rubber band analogy.

There is a slight twist, however, the set of points to be considered is not the set of sheep coordinates, rather it is the set of all of the vertices of the squares that contain the sheep. In other words, each of the given center coordinates of the sheep would be transformed into four different points as illustrated by the image below, and this transformation should be applied to each one of the sheep coordinates. We would then find the length of the convex hull of the resulting set of coordinates, which would contain 4 times as many points as the original set of coordinates.

Jarvis’s march will suffice for solving this problem, but you may also consider more sophisticated algorithms like the Graham’s Scan. Jarvis’s march is much simpler to implement, and choosing it over Graham’s Scan means that precious time is saved.

Gray Codes

Gray codes were invented to prevent spurious output from electromagnetic switches. Consider the number 3 in ordinary binary encoding: when incremented from 011 to 100 it is unlikely that all of the switches will change states at the same time, so there is a possibility of reading the state of the variable while it is in between a transition (i.e., when some of the bits have flipped to the correct value but others haven’t).

To solve this problem, Frank Gray introduced a new number system in which successive numbers differ by only a single bit.

You are working on a legacy system that uses Gray codes, but are having difficulty fixing a bug related to multiplication of numbers. For the purpose of debugging, you wish to convert a number’s Gray encoding into the corresponding decimal representation.

Comments and Solution

This page has a number of interesting applications of Gray Codes. I think Karnaugh maps are the most interesting, they are used to solve boolean minimization (the problem of minimizing logical circuitry).

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

#include <stdio.h>

int gray_decode(int n) {
    int p = n;
    while (n >>= 1) p ^= n;
    return p;
}

int main() {
  int t, c;
  scanf("%d\n", &t);
  while (t--) {
    scanf("%d\n", &c);
    printf("%d\n", gray_decode(c));
  }
  return 0;
}

nCr as a Service

To test a new cloud computing service, you decide to write a program that generates the Pascal Triangle in a distributed fashion.

You wish to estimate the amount of network traffic that would be expected between nodes. Since the nodes exchange the computed values in base 10, you want to know the number of digits in the base-10 representation of nth row and rth column of Pascal’s triangle. Since your program internally represents these in base-2, you also wish to know the number of digits in the base-2 representation to get an idea of the memory usage involved.

Comments and Solution

The name of this problem is a play on the term Software as a Service. The number of digits a number \(n\) has in base \(b\) is \( \lfloor \log_b \left( n \right) \rfloor + 1 \).

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

def ncr(n, r)
  a, b = r, n-r
  a, b = b, a if a < b  # a is the larger
  numer = (a+1..n).inject(1) { |t,v| t*v }  # n!/r!
  denom = (2..b).inject(1) { |t,v| t*v }    # (n-r)!
  numer / denom
end

def ncrdigs_naive(n, r, base)
  ncr(n, r).to_s(base).length
end

gets.to_i.times do
  n, r = gets.split.map {|x| x.to_i }
  puts "#{ncrdigs_naive(n,r, 10)} #{ncrdigs_naive(n,r,2)}"
end

Balanced Primes

A balanced prime is one which is the average of the previous and the next prime number. Your task in this problem is to write a program that can calculate the nth balanced prime.

Comments and Solution

This is the sort of problem that looks like it was meant to be solved in Haskell.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

minus (x:xs) (y:ys) = case (compare x y) of
           LT -> x : minus  xs  (y:ys)
           EQ ->     minus  xs     ys
           GT ->     minus (x:xs)  ys
minus  xs     _     = xs

primesPE = 2 : primes'
  where
    primes' = sieve [3,5..] 9 primes'
    sieve (x:xs) q ps@ ~(p:t)
      | x < q     = x : sieve xs q ps
      | otherwise =     sieve (xs `minus` [q, q+2*p..]) (head t^2) t

primes_triplet = map f [1..]
  where f x = (primesPE !! (x - 1), primesPE !! x, primesPE !! (x + 1))

balanced_primes = map g $ filter f primes_triplet
  where f (a,b,c) = 2 * b == a + c
        g (a,b,c) = b

main = interact g
  where g x = unlines $ map show $ map nbp $ drop 1 $ lines x
        nbp x = balanced_primes !! ((read x) - 1)

The first two definitions (minus and primesPE) are taken verbatim from this page. There are far more efficient implementations on that page that can be dropped in, and doing so will make the program run faster, because generation of primes is the bottleneck. primesPE is an infinite list of primes. primes_triplet uses primesPE to create another list that contains triplets of prime numbers. balanced_primes applies a filter to this list of triplets, selecting only those for which twice the middle element is the sum of the extreme elements, and then selecting only the middle elements of those triplets. The final definition, main, handles IO and can be ignored.

The infinite lists take care of memoization, so that values will not be unnecessarily recomputed. The Haskell code sample above feels almost like declarative programming, in which you specify what you want computed rather than how to compute it.

Positive Term Series

Integral Test

Let \( \sum a_n \) be a positive term series, and let \( a_n = f(n) \) such that \( f(n) \) decreases as \( n \) increases. Then \( \sum a_n \) converges or diverges if \( \int_1^\infty f(x) dx \) is finite or infinite respectively.

p-Series Test

Let \( \sum a_n \) be a positive term series given by \(a_n = \frac1{n^p} \). Then, \( \sum a_n \) is convergent if \( p \gt 1 \), and divergent if \( p \leq 1 \).

Comparison Test

Let \(\sum a_n \) be a positive term series, then:

1. \( \sum a_n \) is convergent if \( \sum b_n \) is another convergent series with \( a_n \leq b_n \).
2. \( \sum a_n \) is divergent if \( \sum d_n \) is another divergent series with \( a_n \geq d_n \).

Limit Comparison Test

Let \( \sum a_n \) and \(\sum b_n \) be two positive term series.

1. If \( \lim_{n \rightarrow \infty} \frac{a_n}{b_n} \) is a finite and non-zero positive quantity, then \( \sum a_n \) and \(\sum b_n\) will converge and diverge together.
2. If \( \lim_{n \rightarrow \infty} \frac{a_n}{b_n} = 0 \) and \(\sum b_n \) is convergent, then \( \sum a_n \) is also convergent.
3. If \(\lim_{n \rightarrow \infty} \frac{a_n}{b_n} = \infty \) and \( \sum b_n \) is divergent, then \(\ sum a_n \) is also divergent.

D’Alembert’s Ratio Test / Ratio Test

Let \( \sum a_n \) be a positive term series, and let \( \lim_{n \rightarrow \infty} \frac{a_{n+1}}{a_n} = r \).

1. The series is convergent if \( r \lt 1 \).
2. The series is divergent if \( r \gt 1 \), or if \(r\) is infinite.
3. The test fails if \(r=1\).

Cauchy’s Root Test / Root Test

Let \( \sum a_n \) be a positive term series, and \( \lim_{n \rightarrow \infty} (a_n)^{\frac1n} = r \).

1. The series is convergent if \( r \lt 1 \).
2. The series is divergent if \( r \gt 1 \).
3. The test fails if \( r = 1 \).

Raabe’s Test

Let \( \sum a_n \) be a positive term series, and \( \lim_{n \rightarrow \infty} n \left( \frac{a_n}{a_{n+1}}-1 \right) = k\).

1. The series is convergent if \( k \gt 1 \).
2. The series is divergent if \( k \lt 1 \).
3. The test fails if \( k = 1 \).

Logarithmic Test

Let \( \sum a_n \) be a positive term series, and \( \lim_{n \rightarrow \infty} \log\left( \frac{a_n}{a_{n+1}} \right) = k\).

1. The series is convergent if \( k \gt 1 \).
2. The series is divergent if \( k \lt 1 \).
3. The test fails if \( k = 1 \).

Alternating Series

Leibniz’s Test

If the series \( \sum (-1)^n a_n \) is an alternating series, then the series is convergent if:

1. Each term is numerically lesser than the preceeding term. ( \( |a_{n+1}| \lt |a_n| \) )
2. \( \lim_{n \rightarrow \infty} a_n = 0 \).

For the sake of simplicity, we confine ourselves to the multiplication of square matrices.

Representation of Matrices

We shall represent Matrices as 2-dimensional arrays. Every element of the outer array will represent a row of the matrix.

We shall denote the element in the \(i\)th row and \(j\)th column of a matrix called \(C\) as \(c_{ij}\).

The Naive Method

We can find the product \(C\) of two \(n \times n\) matrices \(A\) and \(B\) using simple row-by-column multiplication:
\[ c_{ij} = \sum\limits_{k=1}^n a_{ik} \cdot b_{kj} \]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

def naive_matrix_mult(a, b)
  n = a.length
  # Create a new n x n matrix with all elements initialized to 0.
  c = Array.new(n) { Array.new(n) (0) }
  0.upto(n-1) do |i|
    0.upto(n-1) do |j|
      0.upto(n-1) do |k|
        c[i][j] += a[i][k] * b[k][j]
      end
    end
  end
  c
end

naive_matrix_mult([[1, 2], [3, 4]], [[5, 6], [7, 8]])
                       # => [[19, 22], [43, 50]]

Clearly, this will take \( \Theta(n^3) \) time to multiply two \(n
\times n \) matrices.

Divide and Conquer

Another approach is to try to use the divide-and-conquer paradigm, and split each of the matrices \(A\), \(B\) and \(C\) into four \( \frac n2 \times \frac n2 \) matrices:

\[ A = \left( \begin{array}{cc} A_{11} & A_{12} \\ A_{21} & A_{22} \end{array} \right), \]\[ B = \left( \begin{array}{cc} B_{11} & B_{12} \\ B_{21} & B_{22} \end{array} \right), \]\[ C = \left( \begin{array}{cc} C_{11} & C_{12} \\ C_{21} & C_{22} \end{array} \right). \]

We can rewrite \( C=A \cdot B \) as

\[ \left( \begin{array}{cc} C_{11} & C_{12} \\ C_{21} & C_{22} \end{array} \right) =
\left( \begin{array}{cc} A_{11} & A_{12} \\ A_{21} & A_{22} \end{array} \right) \cdot
\left( \begin{array}{cc} B_{11} & B_{12} \\ B_{21} & B_{22} \end{array} \right). \]

Hence, we get the following four equations:

\[ C_{11} = A_{11} \cdot B_{11} + A_{12} \cdot B_{21}, \]\[ C_{12} = A_{11} \cdot B_{12} + A_{12} \cdot B_{22}, \]\[ C_{21} = A_{21} \cdot B_{11} + A_{22} \cdot B_{21}, \]\[ C_{22} = A_{21} \cdot B_{12} + A_{22} \cdot B_{22}. \]

This reduces the multiplication of two \(n \times n\) matrices to eight multiplications of two \(\frac n2 \times \frac n2\) matrices and four \(\frac n2 \times \frac n2\) matrix additions.

Each addition will take \(\Theta(n^2)\) time. If the time taken by this method to multiply two \(n \times n\) matrices in \(T(n)\), then we get the recurrence:

\[ T(n) = 8 T \left( \frac n2 \right) + \Theta(n^2). \]

The solution to this recurrence is \(\Theta(n^3)\), meaning that the divide-and-conquer method is no better than the naive method.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

def partition(a)
  n = a.length
  lim = (n-1)/2
  a_11 = a[0..lim].map {|x| x[0..lim] }
  a_12 = a[0..lim].map {|x| x[(lim+1)..(n-1)] }
  a_21 = a[(lim+1)..(n-1)].map {|x| x[0..lim] }
  a_22 = a[(lim+1)..(n-1)].map {|x|  x[(lim+1)..(n-1)] }
  [a_11, a_12, a_21, a_22]
end

def combine(a_11, a_12, a_21, a_22)
  n1 = a_11.length
  n2 = a_21.length
  c = Array.new(n1+n2) { nil }
  for i in 0..(n1-1)
    c[i] = a_11[i] + a_12[i]
  end
  for i in n1..(n1+n2-1)
    c[i] = a_21[i-n1] + a_22[i-n1]
  end
  c
end

def add(a, b)
  n = a.length
  c = Array.new(n) { Array.new(n) { 0 } }
  for i in 0..(n-1)
    for j in 0..(n-1)
      c[i][j] = a[i][j] + b[i][j]
    end
  end
  c
end

def recursive_matrix_mult(a, b)
  n = a.length
  return [[]] if n == 0
  return [[a[0][0] * b[0][0]]] if n == 1
  a_11, a_12, a_21, a_22 = *partition(a)
  b_11, b_12, b_21, b_22 = *partition(b)

  c_11 = add(recursive_matrix_mult(a_11, b_11),
               recursive_matrix_mult(a_12, b_21))
  c_12 = add(recursive_matrix_mult(a_11, b_12),
               recursive_matrix_mult(a_12, b_22))
  c_21 = add(recursive_matrix_mult(a_21, b_11),
               recursive_matrix_mult(a_22, b_21))
  c_22 = add(recursive_matrix_mult(a_21, b_12),
               recursive_matrix_mult(a_22, b_22))

  combine(c_11, c_12, c_21, c_22)
end

Other methods

Strassen’s algorithm also involves breaking matrices into smaller pieces. It can multiply two \(n \times n\) matrices in \(\Theta(n^{lg\; 7}) \approx \Theta(n^{2.807})\) time. However, it is far more cumbersome to implement, and is not as numerically stable. Strassen’s method is used when numerical stability is not critical and the matrices are large enough to provide a speed advantage. (The constant factor is large enough that for smaller matrices the naive method will work better.) Implementations of Strassen’s method will typically have a crossover point, below which matrices are multiplied using the naive method.

The current theoretical optimum is the Coppersmith-Winograd algorithm which runs in \(O(n^{2.376})\) time. It is almost never used in practice because the constant factor is so large that matrices of the size required to obtain an advantage over Strassen’s method cannot be processed by current hardware.

Modular arithmetic is a system of arithmetic in which numbers wrap around, or get ‘reset’ once they reach a certain value. You can think of it as arithmetic using a number circle as opposed to a number line.

Consider a circle having circumference \(2\) units:

First, notice that if you start at the point marked \(0\) and move \(2\) units clockwise, you would return to the point marked zero. Also note that, if we start at \(0\), moving \(3\) units clockwise and \(1\) unit clockwise will result in reaching the same destination. We represent this fact using the notation, \( 3 \equiv 1 \pmod 2 \), which is read as “\(3\) is congruent to \(1\) modulo \(2\)”. This is equivalent to saying that \(3\) and one leave the same remainder when divided by \(2\), or that \( (3 – 1) \) is an integral multiple of \(2\).

Hence, the statement \( x \equiv y \pmod a \) is equivalent to the following statements:

1. \( x-y \) is an integral multiple of \(a\), and
2. \(x\) and \(y\) leave the same remainder upon division by \(a\).

Modular arithmetic is very useful because of some of the properties of congruence relations. If \( a_1 \equiv b_1 \pmod n \) and \( a_2 \equiv b_2 \pmod n\), then the following properties will hold true.

$$ (a_1 + a_2) \equiv (b_1 + b_2) \pmod n $$ $$ (a_1 – a_2) \equiv (b_1 – b_2) \pmod n $$ $$ (a_1 \cdot a_2) \equiv (b_1 \cdot b_2) \pmod n $$

We will find the last property to be particularly useful.

Example 1: Remainder upon dividing \( 2^{100} \) by \( 3 \)

First, we note that \( 2 \equiv -1 \pmod 3 \).

Because of the last property, this implies that \( 2^{100} \equiv (-1)^{100} \pmod 3 \).

Because \( (-1)^{100} = 1 \), the remainder will be 1. This can be verified using Wolfram|Alpha.

Example 2: Remainder upon dividing \( \; 7^{2010} \) by \(25\)

First, we note that \( 7^{2010} = 49^{1005} \). Now, because \( 49 \equiv -1 \pmod {25} \),

$$ 49^{1005} \equiv (-1)^{1005} \pmod {25} $$ $$ \Rightarrow 49^{1005} \equiv -1 \pmod {25} $$ $$ \Rightarrow 49^{1005} \equiv 24 \pmod {25} $$

In the last step, I added \(25\) to the right side of the congruence. I was able to do so because of the first property.

Hence, the remainder on dividing \( 7^{2010} \) by \(25\) is \(24\).