Programming Contest Question: Counting Polyominos

Question

Please see my own answer, I think I did it!

---

Hi,

An example question for a programming contest was to write a program that finds out ho

Answer 1

Here is my full Python solution inspired by @marcog's answer. It prints the number of polyominos of sizes 2..10 in about 2s on my laptop.

The algorithm is straightforward:

• Size 1: start with one square
• Size n + 1: take all pieces of size n and try adding a single square to all possible adjacent positions. This way you find all possible new pieces of size n + 1. Skip duplicates.

The main speedup came from hashing pieces to quickly check if we've already seen a piece.

import itertools
from collections import defaultdict

n = 10
print("Number of Tetris pieces up to size", n)

# Times:
# n is number of blocks
# - Python O(exp(n)^2): 10 blocks 2.5m
# - Python O(exp(n)): 10 blocks 2.5s, 11 blocks 10.9s, 12 block 33s, 13 blocks 141s (800MB memory)

smallest_piece = [(0, 0)]  # We represent a piece as a list of block positions
pieces_of_size = {
  1: [smallest_piece],
}

# Returns a list of all possible pieces made by adding one block to given piece
def possible_expansions(piece):
    # No flatMap in Python 2/3:
    # https://stackoverflow.com/questions/21418764/flatmap-or-bind-in-python-3
    positions = set(itertools.chain.from_iterable(
         [(x - 1, y), (x + 1, y), (x, y - 1), (x, y + 1)] for (x, y) in piece
    ))
    # Time complexity O(n^2) can be improved
    # For each valid position, append to piece
    expansions = []
    for p in positions:
        if not p in piece:
            expansions.append(piece + [p])
    return expansions

def rotate_90_cw(piece):
    return [(y, -x) for (x, y) in piece]

def canonical(piece):
    min_x = min(x for (x, y) in piece)
    min_y = min(y for (x, y) in piece)
    res = sorted((x - min_x, y - min_y) for (x, y) in piece)
    return res

def hash_piece(piece):
    return hash(tuple(piece))

def expand_pieces(pieces):
    expanded = []
    #[
    #  332322396: [[(1,0), (0,-1)], [...]],
    #  323200700000: [[(1,0), (0,-2)]]
    #]
    # Multimap because two different pieces can happen to have the same hash
    expanded_hashes = defaultdict(list)
    for piece in pieces:
        for e in possible_expansions(piece):
            exp = canonical(e)
            is_new = True
            if exp in expanded_hashes[hash_piece(exp)]:
                is_new = False
            for rotation in range(3):
                exp = canonical(rotate_90_cw(exp))
                if exp in expanded_hashes[hash_piece(exp)]:
                    is_new = False
            if is_new:
                expanded.append(exp)
                expanded_hashes[hash_piece(exp)].append(exp)
    return expanded


for i in range(2, n + 1):
    pieces_of_size[i] = expand_pieces(pieces_of_size[i - 1])
    print("Pieces with {} blocks: {}".format(i, len(pieces_of_size[i])))

Answer 2

There are only 4,461 polynominoes of size 10, so we can just enumerate them all.

Start with a single stone. To expand it by one stone, try add the new stone in at all empty cells that neighbour an existing stone. Do this recursively until reaching the desired size.

To avoid duplicates, keep a hash table of all polynominoes of each size we've already enumerated. When we put together a new polynomino, we check that its not already in the hash table. We also need to check its 3 rotations (and possibly its mirror image). While duplicate checking at the final size is the only strictly necessary check, checking at each step prunes recursive branches that will yield a new polynomino.

Here's some pseudo-code:

polynomino = array of n hashtables
function find_polynominoes(n, base):
  if base.size == n:
    return
  for stone in base:
    for dx, dy in [(-1, 0), (1, 0), (0, -1), (0, 1)]:
      new_stone.x = stone.x + dx
      new_stone.y = stone.y + dy
      if new_stone not in base:
        new_polynomino = base + new_stone
        is_new = true
        for rotation in [0, 90, 180, 270]:
          if new_polynomino.rotate(rotation) in polynomino[new_polynomino.size]:
            is_new = false
            break
        if is_new:
          polynomino[new_polynomino.size].add(new_polynomino)

Answer 3

Here's some python that computes the answer. Seems to agree with Wikipedia. It isn't terribly fast because it uses lots of array searches instead of hash tables, but it still takes only a minute or so to complete.

#!/usr/bin/python                                                                                                                                                 

# compute the canonical representation of polyomino p.                                                                                                            
# (minimum x and y coordinate is zero, sorted)                                                                                                                    
def canonical(p):
  mx = min(map(lambda v: v[0], p))
  my = min(map(lambda v: v[1], p))
  return sorted(map(lambda v: (v[0]-mx, v[1]-my), p))

# rotate p 90 degrees                                                                                                                                               
def rotate(p):
  return canonical(map(lambda v: (v[1], -v[0]), p))

# add one tile to p                                                                                                                                               
def expand(p):
  result = []
  for (x,y) in p:
    for (dx,dy) in ((-1,0),(1,0),(0,-1),(0,1)):
      if p.count((x+dx,y+dy)) == 0:
        result.append(canonical(p + [(x+dx,y+dy)]))
  return result

polyominos = [[(0,0)]]

for i in xrange(1,10):
  new_polyominos = []
  for p in polyominos:
    for q in expand(p):
      dup = 0
      for r in xrange(4):
        if new_polyominos.count(q) != 0:
          dup = 1
          break
        q = rotate(q)
      if not dup: new_polyominos.append(q)
  polyominos = new_polyominos
  print i+1, len(polyominos)

Answer 4

The most naive solution is to start with a single X, and for each iteration, build the list of unique possible next-states. From that list, build the list of unique states by adding another X. Continue this until the iteration you desire.

I'm not sure if this runs in reasonable time for N=10, however. It might, depending on your requirements.

Answer 5

Here's my solution in Java to the same problem. I can confirm Martijn's numbers (see below). I've also added in the rough time it takes to compute the results (mid-2012 Macbook Retina Core i7). I suppose substantial performance improvements could be achieved via parallelization.

numberOfStones -> numberOfPolyominos
        1  -> 1
        2  -> 1
        3  -> 2
        4  -> 7
        5  -> 18
        6  -> 60
        7  -> 196
        8  -> 704      (3 seconds)
        9  -> 2500     (46 seconds)
        10 -> 9189     (~14 minutes)

.

    /*
 * This class is a solution to the Tetris unique shapes problem. 
 * That is, the game of Tetris has 7 unique shapes. These 7 shapes
 * are all the possible unique combinations of any 4 adjoining blocks
 * (i.e. ignoring rotations).
 * 
 * How many unique shapes are possible with, say, 7 or n blocks? 
 * 
 * The solution uses recursive back-tracking to construct all the possible
 * shapes. It uses a HashMap to store unique shapes and to ignore rotations.
 * It also uses a temporary HashMap so that the program does not needlessly
 * waste time checking the same path multiple times.
 * 
 * Even so, this is an exponential run-time solution, with n=10 taking a few
 * minutes to complete.
 */
package com.glugabytes.gbjutils;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

public class TetrisBlocks {

    private HashMap uShapes;
    private HashMap tempShapes;

    /* Get a map of unique shapes for n squares. The keys are string-representations
     * of each shape, and values are corresponding boolean[][] arrays.
     * @param squares - number of blocks to use for shapes, e.g. n=4 has 7 unique shapes
     */
    public Map getUniqueShapes(int squares) {
        uShapes = new HashMap();
        tempShapes = new HashMap();

        boolean[][] data = new boolean[squares*2+1][squares*2+1];
        data[squares][squares] = true;
        make(squares, data, 1);             //start the process with a single square in the center of a boolean[][] matrix

        return uShapes;
    }

    /* Recursivelly keep adding blocks to the data array until number of blocks(squares) = required size (e.g. n=4)
     * Make sure to eliminate rotations. Also make sure not to enter infinite backtracking loops, and also not 
     * needlessly recompute the same path multiple times.
     */
    private void make(int squares, boolean[][] data, int size) {
        if(size == squares) {   //used the required number of squares
            //get a trimmed version of the array
            boolean[][] trimmed = trimArray(data);
            if(!isRotation(trimmed)) {  //if a unique piece, add it to unique map
                uShapes.put(arrayToString(trimmed), trimmed);
            }

        } else {
            //go through the grid 1 element at a time and add a block next to an existing block
            //do this for all possible combinations
            for(int iX = 0; iX < data.length; iX++) {
                for(int iY = 0; iY < data.length; iY++) {
                    if(data[iX][iY] == true) {      //only add a block next to an existing block
                        if(data[iX+1][iY] != true) {    //if no existing block to the right, add one and recuse
                            data[iX+1][iY] = true;
                            if(!isTempRotation(data)) {         //only recurse if we haven't already been on this path before
                                make(squares, data, size+1);
                                tempShapes.put(arrayToString(data), data);  //store this path so we don't repeat it later
                            }
                            data[iX+1][iY] = false; 
                        }

                        if(data[iX-1][iY] != true) {    //repeat by adding a block on the left
                            data[iX-1][iY] = true;      
                            if(!isTempRotation(data)) {
                                make(squares, data, size+1);
                                tempShapes.put(arrayToString(data), data);
                            }
                            data[iX-1][iY] = false; 
                        }

                        if(data[iX][iY+1] != true) {   //repeat by adding a block down
                            data[iX][iY+1] = true;      
                            if(!isTempRotation(data)) {
                                make(squares, data, size+1);
                                tempShapes.put(arrayToString(data), data);
                            }
                            data[iX][iY+1] = false; 
                        }

                        if(data[iX][iY-1] != true) {   //repeat by adding a block up
                            data[iX][iY-1] = true;      
                            if(!isTempRotation(data)) {
                                make(squares, data, size+1);
                                tempShapes.put(arrayToString(data), data);
                            }
                            data[iX][iY-1] = false; 
                        }
                    }
                }
            }
        }
    }

    /**
     * This function basically removes all rows and columns that have no 'true' flags,
     * leaving only the portion of the array that contains useful data.
     * 
     * @param data
     * @return 
     */
    private boolean[][] trimArray(boolean[][] data) {
        int maxX = 0;
        int maxY = 0;
        int firstX = data.length;
        int firstY = data.length;

        for(int iX = 0; iX < data.length; iX++) {
            for (int iY = 0; iY < data.length; iY++) {
                if(data[iX][iY]) {
                    if(iY < firstY) firstY = iY;
                    if(iY > maxY) maxY = iY;
                }
            }
        }

        for(int iY = 0; iY < data.length; iY++) {
            for (int iX = 0; iX < data.length; iX++) {
                if(data[iX][iY]) {
                    if(iX < firstX) firstX = iX;
                    if(iX > maxX) maxX = iX;
                }
            }
        }



        boolean[][] trimmed = new boolean[maxX-firstX+1][maxY-firstY+1];
            for(int iX = firstX; iX <= maxX; iX++) {
                for(int iY = firstY; iY <= maxY; iY++) {
                    trimmed[iX-firstX][iY-firstY] = data[iX][iY];
                }
            }

        return trimmed;
    }

    /**
     * Return a string representation of the 2D array.
     * 
     * @param data
     * @return 
     */
    private String arrayToString(boolean[][] data) {
        StringBuilder sb = new StringBuilder();
        for(int iX = 0; iX < data.length; iX++) {
            for(int iY = 0; iY < data[0].length; iY++) {
                sb.append(data[iX][iY] ? '#' : ' ');
            }
            sb.append('\n');
        }

        return sb.toString();
    }

    /**
     * Rotate an array clockwise by 90 degrees.
     * @param data
     * @return 
     */
    public boolean[][] rotate90(boolean[][] data) {
        boolean[][] rotated = new boolean[data[0].length][data.length];

        for(int iX = 0; iX < data.length; iX++) {
            for(int iY = 0; iY < data[0].length; iY++) {
                rotated[iY][iX] = data[data.length - iX - 1][iY];
            }
        }

        return rotated;
    }

    /**
     * Checks to see if two 2d boolean arrays are the same
     * @param a
     * @param b
     * @return 
     */
    public boolean equal(boolean[][] a, boolean[][] b) {
        if(a.length != b.length || a[0].length != b[0].length) {
            return false;
        } else {
            for(int iX = 0; iX < a.length; iX++) {
                for(int iY = 0; iY < a[0].length; iY++) {
                    if(a[iX][iY] != b[iX][iY]) {
                        return false;
                    }
                }
            }
        }

        return true;
    }

    public boolean isRotation(boolean[][] data) {
        //check to see if it's a rotation of a shape that we already have
        data = rotate90(data);                      //+90*
        String str = arrayToString(data);
        if(!uShapes.containsKey(str)) {
            data = rotate90(data);                  //180*
            str = arrayToString(data);
            if(!uShapes.containsKey(str)) {
                data = rotate90(data);              //270*
                str = arrayToString(data);
                if(!uShapes.containsKey(str)) {
                    return false;
                }
            }
        }
        return true;
    }

    public boolean isTempRotation(boolean[][] data) {
        //check to see if it's a rotation of a shape that we already have
        data = rotate90(data);                      //+90*
        String str = arrayToString(data);
        if(!tempShapes.containsKey(str)) {
            data = rotate90(data);                  //180*
            str = arrayToString(data);
            if(!tempShapes.containsKey(str)) {
                data = rotate90(data);              //270*
                str = arrayToString(data);
                if(!tempShapes.containsKey(str)) {
                    return false;
                }
            }
        }
        return true;
    }

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {

        TetrisBlocks tetris = new TetrisBlocks();
        long start = System.currentTimeMillis();
        Map shapes = tetris.getUniqueShapes(8);
        long end = System.currentTimeMillis();

        Iterator it = shapes.keySet().iterator();
        while(it.hasNext()) {
            String shape = (String)it.next();
            System.out.println(shape);
        }

        System.out.println("Unique Shapes: " + shapes.size());
        System.out.println("Time: " + (end-start));
    }
}

Answer 6

I think I did it!

EDIT: I'm using the SHA-256 algorithm to hash them, now it works correct.

Here are the results:

numberOfStones -> numberOfPolyominos
            1  -> 1
            2  -> 1
            3  -> 2
            4  -> 7
            5  -> 18
            6  -> 60
            7  -> 196
            8  -> 704
            9  -> 2500
            10 -> terminated

Here is the code (Java):

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;

/* VPW Template */

public class Main
{

    /**
     * @param args
     */
    public static void main(String[] args) throws IOException
    {
        new Main().start();
    }

public void start() throws IOException
{

    /* Read the stuff */
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    String[] input = new String[Integer.parseInt(br.readLine())];
    for (int i = 0; i < input.length; ++i)
    {
        input[i] = br.readLine();
    }
    /* Process each line */
    for (int i = 0; i < input.length; ++i)
    {
        processLine(input[i]);
    }
}

public void processLine(String line)
{
    int n = Integer.parseInt(line);
    System.out.println(countPolyminos(n));
}

private int countPolyminos(int n)
{
    hashes.clear();
    count = 0;
    boolean[][] matrix = new boolean[n][n];
    matrix[n / 2][n / 2] = true;
    createPolyominos(matrix, n - 1);
    return count;
}

private List<BigInteger> hashes = new ArrayList<BigInteger>();
private int count;

private void createPolyominos(boolean[][] matrix, int n)
{
    if (n == 0)
    {
        boolean[][] cropped = cropMatrix(matrix);
        BigInteger hash = hashMatrixOrientationIndependent(cropped);
        if (!hashes.contains(hash))
        {
            // System.out.println(count + " Found!");
            // printMatrix(cropped);
            // System.out.println();
            count++;
            hashes.add(hash);
        }
        return;
    }
    for (int x = 0; x < matrix.length; ++x)
    {
        for (int y = 0; y < matrix[x].length; ++y)
        {
            if (matrix[x][y])
            {
                if (x > 0 && !matrix[x - 1][y])
                {
                    boolean[][] clone = copy(matrix);
                    clone[x - 1][y] = true;
                    createPolyominos(clone, n - 1);
                }
                if (x < matrix.length - 1 && !matrix[x + 1][y])
                {
                    boolean[][] clone = copy(matrix);
                    clone[x + 1][y] = true;
                    createPolyominos(clone, n - 1);
                }
                if (y > 0 && !matrix[x][y - 1])
                {
                    boolean[][] clone = copy(matrix);
                    clone[x][y - 1] = true;
                    createPolyominos(clone, n - 1);
                }
                if (y < matrix[x].length - 1 && !matrix[x][y + 1])
                {
                    boolean[][] clone = copy(matrix);
                    clone[x][y + 1] = true;
                    createPolyominos(clone, n - 1);
                }
            }
        }
    }
}

public boolean[][] copy(boolean[][] matrix)
{
    boolean[][] b = new boolean[matrix.length][matrix[0].length];
    for (int i = 0; i < matrix.length; ++i)
    {
        System.arraycopy(matrix[i], 0, b[i], 0, matrix[i].length);
    }
    return b;
}

public void printMatrix(boolean[][] matrix)
{
    for (int y = 0; y < matrix.length; ++y)
    {
        for (int x = 0; x < matrix[y].length; ++x)
        {
            System.out.print((matrix[y][x] ? 'X' : ' '));
        }
        System.out.println();
    }
}

public boolean[][] cropMatrix(boolean[][] matrix)
{
    int l = 0, t = 0, r = 0, b = 0;
    // Left
    left: for (int x = 0; x < matrix.length; ++x)
    {
        for (int y = 0; y < matrix[x].length; ++y)
        {
            if (matrix[x][y])
            {
                break left;
            }
        }
        l++;
    }
    // Right
    right: for (int x = matrix.length - 1; x >= 0; --x)
    {
        for (int y = 0; y < matrix[x].length; ++y)
        {
            if (matrix[x][y])
            {
                break right;
            }
        }
        r++;
    }
    // Top
    top: for (int y = 0; y < matrix[0].length; ++y)
    {
        for (int x = 0; x < matrix.length; ++x)
        {
            if (matrix[x][y])
            {
                break top;
            }
        }
        t++;
    }
    // Bottom
    bottom: for (int y = matrix[0].length - 1; y >= 0; --y)
    {
        for (int x = 0; x < matrix.length; ++x)
        {
            if (matrix[x][y])
            {
                break bottom;
            }
        }
        b++;
    }

    // Perform the real crop
    boolean[][] cropped = new boolean[matrix.length - l - r][matrix[0].length - t - b];
    for (int x = l; x < matrix.length - r; ++x)
    {
        System.arraycopy(matrix[x], t, cropped[x - l], 0, matrix[x].length - t - b);
    }
    return cropped;
}

public BigInteger hashMatrix(boolean[][] matrix)
{
    try
    {
        MessageDigest md = MessageDigest.getInstance("SHA-256");
        md.update((byte) matrix.length);
        md.update((byte) matrix[0].length);
        for (int x = 0; x < matrix.length; ++x)
        {
            for (int y = 0; y < matrix[x].length; ++y)
            {
                if (matrix[x][y])
                {
                    md.update((byte) x);
                } else
                {
                    md.update((byte) y);
                }
            }
        }
        return new BigInteger(1, md.digest());
    } catch (NoSuchAlgorithmException e)
    {
        System.exit(1);
        return null;
    }
}

public BigInteger hashMatrixOrientationIndependent(boolean[][] matrix)
{
    BigInteger hash = hashMatrix(matrix);
    for (int i = 0; i < 3; ++i)
    {
        matrix = rotateMatrixLeft(matrix);
        hash = hash.add(hashMatrix(matrix));
    }
    return hash;
}

public boolean[][] rotateMatrixRight(boolean[][] matrix)
{
    /* W and H are already swapped */
    int w = matrix.length;
    int h = matrix[0].length;
    boolean[][] ret = new boolean[h][w];
    for (int i = 0; i < h; ++i)
    {
        for (int j = 0; j < w; ++j)
        {
            ret[i][j] = matrix[w - j - 1][i];
        }
    }
    return ret;
}

public boolean[][] rotateMatrixLeft(boolean[][] matrix)
{
    /* W and H are already swapped */
    int w = matrix.length;
    int h = matrix[0].length;
    boolean[][] ret = new boolean[h][w];
    for (int i = 0; i < h; ++i)
    {
        for (int j = 0; j < w; ++j)
        {
            ret[i][j] = matrix[j][h - i - 1];
        }
    }
    return ret;
}