Problem:
Problem C: Colored Cubes There are several colored cubes. All of them are of the same size but they may be colored
differently. Each face of these cubes has a single color. Colors of distinct faces of a cube may or
may not be the same. Two cubes are said to be identically colored if some suitable rotations of one of the cubes give
identical looks to both of the cubes. For example, two cubes shown in Figure 2 are identically
colored. A set of cubes is said to be identically colored if every pair of them are identically
colored. A cube and its mirror image are not necessarily identically colored. For example, two cubes
shown in Figure 3 are not identically colored. You can make a given set of cubes identically colored by repainting some of the faces, whatever
colors the faces may have. In Figure 4, repainting four faces makes the three cubes identically
colored and repainting fewer faces will never do. Your task is to write a program to calculate the minimum number of faces that needs to be
repainted for a given set of cubes to become identically colored. Input The input is a sequence of datasets. A dataset consists of a header and a body appearing in this
order. A header is a line containing one positive integer n and the body following it consists
of n lines. You can assume that 1 ≤ n ≤ 4. Each line in a body contains six color names
separated by a space. A color name consists of a word or words connected with a hyphen (-).
A word consists of one or more lowercase letters. You can assume that a color name is at most
24-characters long including hyphens. A dataset corresponds to a set of colored cubes. The integer n corresponds to the number of
cubes. Each line of the body corresponds to a cube and describes the colors of its faces. Color
names in a line is ordered in accordance with the numbering of faces shown in Figure 5. A line  color 1  color 2  color 3  color 4  color 5  color 6  The end of the input is indicated by a line containing a single zero. It is not a dataset nor a
part of a dataset.     Output For each dataset, output a line containing the minimum number of faces that need to be repainted
to make the set of cubes identically colored. Sample Input 3
scarlet green blue yellow magenta cyan
blue pink green magenta cyan lemon
purple red blue yellow cyan green
2
red green blue yellow magenta cyan
cyan green blue yellow magenta red
2
red green gray gray magenta cyan
cyan green gray gray magenta red
2
red green blue yellow magenta cyan
magenta red blue yellow cyan green
3
red green blue yellow magenta cyan
cyan green blue yellow magenta red
magenta red blue yellow cyan green
3
blue green green green green blue
green blue blue green green green
green green green green green sea-green
3
red yellow red yellow red yellow
red red yellow yellow red yellow
red red red red red red
4
violet violet salmon salmon salmon salmon
violet salmon salmon salmon salmon violet
violet violet salmon salmon violet violet
violet violet violet violet salmon salmon
1
red green blue yellow magenta cyan
4
magenta pink red scarlet vermilion wine-red
aquamarine blue cyan indigo sky-blue turquoise-blue
blond cream chrome-yellow lemon olive yellow
chrome-green emerald-green green olive vilidian sky-blue
0 Output for the Sample Input 4
2
0
0
2
3
4
4
0
16

Solution (Python):
def rotateX(dice):
    d1, d2, d3, d4, d5, d6 = dice
    return [d2, d6, d3, d4, d1, d5]


def rotateY(dice):
    d1, d2, d3, d4, d5, d6 = dice
    return [d4, d2, d1, d6, d5, d3]


def rotateZ(dice):
    d1, d2, d3, d4, d5, d6 = dice
    return [d1, d3, d5, d2, d4, d6]


def check():
    global n, s_count
    diff = [[0 for i in range(s_count)] for j in range(6)]
    for dice in color_list[:-1]:
        for i in range(6):
            if color_list[-1][i] != dice[i]:
                diff[i][dice[i]] += 1
    count = 0

    for c in diff:
        c_max = max(c)
        c_sum = sum(c)
        if n - c_max < c_sum:
            count += n - c_max
        else:
            count += c_sum

    return count


def solve(i):
    global ans
    if i == len(color_list) - 1:
        count = check()
        if ans > count:
            ans = count
    else:
        dice_memo = []
        for x in range(4):
            temp_dice = rotateX(color_list[i])
            for y in range(4):
                temp_dice = rotateY(temp_dice)
                for z in range(4):
                    temp_dice = rotateZ(temp_dice)
                    color_list[i] = temp_dice
                    if color_list[i] in dice_memo:
                        continue
                    dice_memo.append(color_list[i])
                    solve(i + 1)


while True:
    n = int(input())
    if n == 0:
        break

    memo = {}
    s_count = 0
    color_list = [[0 for j in range(6)] for i in range(n)]
    for i in range(n):
        for j, s in enumerate(input().split(" ")):
            if s not in memo:
                color_list[i][j] = memo.setdefault(s, s_count)
                s_count += 1
            else:
                color_list[i][j] = memo[s]

    if n == 1:
        print(0)
        continue
    ans = float("inf")
    solve(0)
    print(ans)

Solution (Python):
def solve():
    from itertools import product
    from sys import stdin
    f_i = stdin

    
    indices = ((0, 1, 2, 3, 4, 5), (0, 2, 4, 1, 3, 5),
               (0, 4, 3, 2, 1, 5), (0, 3, 1, 4, 2, 5),
               (1, 0, 3, 2, 5, 4), (1, 3, 5, 0, 2, 4),
               (1, 5, 2, 3, 0, 4), (1, 2, 0, 5, 3, 4),
               (2, 0, 1, 4, 5, 3), (2, 1, 5, 0, 4, 3),
               (2, 5, 4, 1, 0, 3), (2, 4, 0, 5, 1, 3),
               (3, 0, 4, 1, 5, 2), (3, 4, 5, 0, 1, 2),
               (3, 5, 1, 4, 0, 2), (3, 1, 0, 5, 4, 2),
               (4, 0, 2, 3, 5, 1), (4, 2, 5, 0, 3, 1),
               (4, 5, 3, 2, 0, 1), (4, 3, 0, 5, 2, 1),
               (5, 1, 3, 2, 4, 0), (5, 3, 4, 1, 2, 0),
               (5, 4, 2, 3, 1, 0), (5, 2, 1, 4, 3, 0))

    while True:
        n = int(f_i.readline())
        if n == 0:
            break

        cubes = tuple(tuple(f_i.readline().split()) for i in range(n))

        if n == 1:
            print(0)
            continue

        cube1 = cubes[0]
        cubes = cubes[1:]

        cnt = 6 * (n - 1)
        for tpl in product(indices, repeat=n-1):
            tmp = 0
            for idx, color1 in zip(zip(*tpl), cube1):
                d = {color1: 1}
                for c, i in zip(cubes, idx):
                    color = c[i]
                    if color in d:
                        d[color] += 1
                    else:
                        d[color] = 1
                tmp += n - max(d.values())
                if tmp >= cnt:
                    break
            else:
                cnt = tmp

        print(cnt)

if __name__ == '__main__':
    solve()

Solution (Python):
import copy


def turn(box):
    turnlist = []
    for j in range(4):
        for i in range(4):
            turnlist.append(box)
            box = [box[0], box[3], box[1], box[4], box[2], box[5]]
        box = [box[3], box[1], box[0], box[5], box[4], box[2]]
    box = [box[1], box[5], box[2], box[3], box[0], box[4]]
    for j in range(2):
        for i in range(4):
            turnlist.append(box)
            box = [box[0], box[3], box[1], box[4], box[2], box[5]]
        box = [box[0], box[3], box[1], box[4], box[2], box[5]]
        box = [box[5], box[4], box[2], box[3], box[1], box[0]]

    return turnlist


def solve():
    ans = float('inf')
    if n == 1:
        return 0

    for d1 in turn(color[0]):
        if n > 2:
            for d2 in turn(color[1]):
                if n > 3:
                    for d3 in turn(color[2]):
                        tmp = 0
                        for num in range(6):
                            tmp += fourcheck([d1[num], d2[num], d3[num], color[3][num]])
                        ans = min(ans, tmp)
                else:
                    tmp = 0
                    for num in range(6):
                        tmp += threecheck(d1[num], d2[num], color[2][num])
                    ans = min(ans, tmp)
        else:
            tmp = 0
            for num in range(6):
                if color[1][num] != d1[num]:
                    tmp += 1
            ans = min(tmp, ans)
    return ans


def threecheck(a, b, c):
    if a == b and b == c:
        return 0
    if a == b or b == c or c == a:
        return 1
    return 2


def fourcheck(dlist):
    tdict = {}
    for check in dlist:
        if check not in tdict:
            tdict[check] = 0
        tdict[check] += 1

    if max(tdict.values()) == 4:
        return 0
    if max(tdict.values()) == 3:
        return 1
    if max(tdict.values()) == 2:
        return 2
    return 3

while True:
    n = int(input())
    if n == 0:
        break

    color = [input().split() for i in range(n)]
    colordict = dict()

    tmp = 0
    for i in range(n):
        for j in range(6):
            if color[i][j] not in colordict.keys():
                colordict[color[i][j]] = tmp
                tmp += 1
            color[i][j] = colordict[color[i][j]]
    print(solve())

Solution (Python):
def solve():
    from itertools import product
    from sys import stdin
    f_i = stdin
    
    
    indices = ((0, 1, 2, 3, 4, 5), (0, 2, 4, 1, 3, 5),
               (0, 4, 3, 2, 1, 5), (0, 3, 1, 4, 2, 5),
               (1, 0, 3, 2, 5, 4), (1, 3, 5, 0, 2, 4),
               (1, 5, 2, 3, 0, 4), (1, 2, 0, 5, 3, 4),
               (2, 0, 1, 4, 5, 3), (2, 1, 5, 0, 4, 3),
               (2, 5, 4, 1, 0, 3), (2, 4, 0, 5, 1, 3),
               (3, 0, 4, 1, 5, 2), (3, 4, 5, 0, 1, 2),
               (3, 5, 1, 4, 0, 2), (3, 1, 0, 5, 4, 2),
               (4, 0, 2, 3, 5, 1), (4, 2, 5, 0, 3, 1),
               (4, 5, 3, 2, 0, 1), (4, 3, 0, 5, 2, 1),
               (5, 1, 3, 2, 4, 0), (5, 3, 4, 1, 2, 0),
               (5, 4, 2, 3, 1, 0), (5, 2, 1, 4, 3, 0))
    
    while True:
        n = int(f_i.readline())
        if n == 0:
            break
        
        cubes = tuple(tuple(f_i.readline().split()) for i in range(n))
        
        if n == 1:
            print(0)
            continue
        
        cube1 = cubes[0]
        cubes = cubes[1:]
        
        cnt = 6 * (n - 1)
        for tpl in product(indices, repeat=n-1):
            tmp = 0
            for idx, color1 in zip(zip(*tpl), cube1):
                d = {color1: 1}
                for c, i in zip(cubes, idx):
                    color = c[i]
                    if color in d:
                        d[color] += 1
                    else:
                        d[color] = 1
                tmp += n - max(d.values())
                if tmp >= cnt:
                    break
            else:
                cnt = tmp
        
        print(cnt)

solve()