kubik.py

#!/usr/bin/env python3
#
#
#            |b9 b8 b7|
#            |b6 b5 b4|
#            |b3 b2 b1|
#            ----------
#            |u1 u2 u3|
#            |u4 u5 u6|
#            |u7 u8 u9|
#            ----------
# b3|l1 l2 l3|f1 f2 f3|r1 r2 r3|b1
# b6|l4 l5 l6|f4 f5 f6|r4 r5 r6|b4
# b9|l7 l8 l9|f7 f8 f9|r7 r8 r9|b7
#            ----------
#            |d1 d2 d3|
#            |d4 d5 d6|
#            |d7 d8 d9|
#


class K:
    def __init__(self, v={}, p=[]):
        self.v = v
        self.p = p

    def __mul__(self, right):
        l, r = self.v, right.v.copy()
        product = {}
        for o in l:
            product[o] = r.pop(l[o], l[o])
        product.update(r)
        k = K(product, self.p + right.p)
        k.strip()
        return k

    def __eq__(self, r):
        return sorted(self.v.items()) == sorted(r.v.items())

    def __str__(self):
        if len(self.p) == 0:
            return ''
        if len(self.p) == 1:
            return self.p[0]
        merge = [(x, 1) for x in self.p]
        merge.append('ø')
        exp, i = '', 0
        while i < len(merge) - 1:
            if merge[i][0] == merge[i+1][0]:
                merge[i+1] = (merge[i][0], merge[i][1] + 1)
            else:
                if merge[i][1] % 4 == 0:
                    exp += ''
                elif merge[i][1] % 4 == 1:
                    exp += merge[i][0]
                elif merge[i][1] % 4 == 2:
                    exp += merge[i][0] + '2'
                else:
                    exp += merge[i][0] + "'"
            i += 1
        return exp

    def perm(self):
        return '**{0}\n=>{1}'.format(list(self.v.keys()), list(self.v.values()))

    def strip(self):
        for k in list(self.v.keys()):
            if self.v[k] == k:
                del self.v[k]
        if len(self.v) == 0:
            self.p = []


U = K({
    'l3': 'b3',
    'b3': 'r3',
    'r3': 'f3',
    'f3': 'l3',
    'l2': 'b2',
    'b2': 'r2',
    'r2': 'f2',
    'f2': 'l2',
    'l1': 'b1',
    'b1': 'r1',
    'r1': 'f1',
    'f1': 'l1',
    'u1': 'u3',
    'u3': 'u9',
    'u9': 'u7',
    'u7': 'u1',
    'u2': 'u6',
    'u6': 'u8',
    'u8': 'u4',
    'u4': 'u2',
}, ['U'])

R = K({
    'r1': 'r3',
    'r3': 'r9',
    'r9': 'r7',
    'r7': 'r1',
    'r2': 'r6',
    'r6': 'r8',
    'r8': 'r4',
    'r4': 'r2',
    'f3': 'u3',
    'u3': 'b7',
    'b7': 'd3',
    'd3': 'f3',
    'f6': 'u6',
    'u6': 'b4',
    'b4': 'd6',
    'd6': 'f6',
    'f9': 'u9',
    'u9': 'b1',
    'b1': 'd9',
    'd9': 'f9',
}, ['R'])

F = K({
    'f1': 'f3',
    'f3': 'f9',
    'f9': 'f7',
    'f7': 'f1',
    'f2': 'f6',
    'f6': 'f8',
    'f8': 'f4',
    'f4': 'f2',
    'l3': 'u9',
    'u9': 'r7',
    'r7': 'd1',
    'd1': 'l3',
    'l6': 'u8',
    'u8': 'r4',
    'r4': 'd2',
    'd2': 'l6',
    'l9': 'u7',
    'u7': 'r1',
    'r1': 'd3',
    'd3': 'l9',
}, ['F'])

U2 = U * U
F2 = F * F
R2 = R * R
U_ = U2 * U
F_ = F2 * F
R_ = R2 * R

npr = ['r{0}'.format(x) for x in range(4, 10)]
npf = ['f{0}'.format(x) for x in range(4, 10)]
npl = ['l{0}'.format(x) for x in range(4, 10)]
npb = ['b{0}'.format(x) for x in range(4, 10)]
npd = ['d{0}'.format(x) for x in range(1, 10)]
np = npr + npf + npl + npb + npd


def good(f, f_):
    t = f * f_
    for k in np:
        if k in t.v:
            return False
    return len(t.v) != 0


def shift(a, a_, candidate):
    a = a * candidate
    a_ = a_ * candidate * candidate * candidate
    if len(a.p) > 30 or len(a.p) == 0:
        return
    if good(a, a_):
        print(a * a_)
        return
    shift(a, a_, F)
    a, a_ = a * F_, a_ * F
    shift(a, a_, U)
    a, a_ = a * U_, a_ * U
    shift(a, a_, R)
    a, a_ = a * R_, a_ * R


def foo():
    shift(K(), K(), F)


if __name__ == '__main__':
    foo()