Counting Squares

def getAvailablePositions(points):
        positions = []
        for p in points:
                for (dx,dy) in [ (-1,0), (1,0), (0,-1), (0,1) ]:
                        nx = p[0] + dx
                        ny = p[1] + dy
                        # ensure our first point is always the lowest of first column
                        if nx < 0  or  (nx == 0 and ny < 0):
                                continue
                        if not (nx,ny) in points and not (nx,ny) in positions:
                                        positions += [ (nx,ny) ]
        return positions

def removeDoubles(pointsList):
        map(lambda x:x.sort(), pointsList)
        pointsList.sort()
        i = 1 
        while i < len(pointsList):
                if pointsList[i] == pointsList[i-1]:
                        pointsList.pop(i)
                else:
                        i += 1

# adds <howMany> blocks to a list of points
def addBlocks(points, howMany):
        if howMany == 0:
                return [ points ]
        r = []
        for p in getAvailablePositions(points):
                r += addBlocks(points + [p], howMany - 1)
        removeDoubles(r)
        return r

def symetry(points):
        return map(lambda t:(-t[0],t[1]), points)
def rot(points):
        return map(lambda t:(-t[0],-t[1]), points)
def rotL(points):
        return map(lambda t:(-t[1],t[0]), points)
def rotR(points):
        return map(lambda t:(t[1],-t[0]), points)

# moves lowest left point to (0,0)
def center(points):
        minX = min([t[0] for t in points])
        minY = min([t[1] for t in points if t[0] == minX])
        return map(lambda t:(t[0]-minX, t[1]-minY), points)

# returns different symetries and rotations
def transforms(points):
        ret = [points]
        sym = symetry(points)
        for t in [ rotL(points), rotR(points), rot(points), sym, rotL(sym), rotR(sym), rot(sym) ]:
                t = center(t)
                t.sort()
                if not t in ret:
                        ret += [t] 
        return ret[1:]


polyominoes = addBlocks([(0,0)], 9)

# removing identical polyominoes after transformation
i = 0
while i < len(polyominoes):
        for p in transforms(polyominoes[i]):
                polyominoes.remove(p)
        i += 1

print len(polyominoes)