Problem:


  MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});

Dice III

  Write a program which reads the two dices constructed in the same way as Dice I, and determines whether these two dices are identical. You can roll a dice in the same way as Dice I, and if all integers observed from the six directions are the same as that of another dice, these dices can be considered as identical.

Input

  In the first line, six integers assigned to faces of a dice are given in ascending order of their corresponding labels.

    In the second line, six integers assigned to faces of another dice are given in ascending order of their corresponding labels.

Output

  Print "Yes" if two dices are identical, otherwise "No" in a line.

Constraints

$0 \leq $ the integer assigned to a face $ \leq 100$

Sample Input 1

1 2 3 4 5 6
6 2 4 3 5 1

Sample Output 1

Yes

Sample Input 2

1 2 3 4 5 6
6 5 4 3 2 1

Sample Output 2

No



Sample input:
1 2 3 4 5 6
6 2 4 3 5 1


Sample output:
Yes

Submission status: Accepted

Solution code:
class Dice:
    def __init__(self, a, b, c, d, e, f):
        # サイコロの現在一番上にある面
        self.a = a
        self.b = b
        self.c = c
        self.d = d
        self.e = e
        self.f = f

        # 他のダイスと一致したかどうか
        self.result = 0

    def move(self, move_str):
        for i in move_str:
            if i == "N":
                self.move_N()
            elif i == "E":
                self.move_E()
            elif i == "W":
                self.move_W()
            elif i == "S":
                self.move_S()

    def move_N(self):
        tmp1 = self.a
        tmp2 = self.e
        self.a = self.b
        self.b = self.f
        self.e = tmp1
        self.f = tmp2

    def move_E(self):
        tmp1 = self.a
        tmp2 = self.c
        self.a = self.d
        self.c = tmp1
        self.d = self.f
        self.f = tmp2

    def move_W(self):
        tmp1 = self.a
        tmp2 = self.d
        self.a = self.c
        self.c = self.f
        self.d = tmp1
        self.f = tmp2

    def move_S(self):
        tmp1 = self.a
        tmp2 = self.b
        self.a = self.e
        self.b = tmp1
        self.e = self.f
        self.f = tmp2

    def check_one_around(self, dice):
        """チェックのために時計回りに一周させる"""
        for _ in range(4):
            """時計回りに回転"""
            tmp1 = self.b
            tmp2 = self.d
            self.b = self.c
            self.c = self.e
            self.d = tmp1
            self.e = tmp2

            # ダイスが一致しているかチェック
            self.check_dice_same(dice)

    def check_dice_same(self, dice):
        """引数指定したダイスと同一面かチェック"""
        if (
            self.a == dice.a and
            self.b == dice.b and
            self.c == dice.c and
            self.d == dice.d and
            self.e == dice.e and
            self.f == dice.f
        ):
            self.result += 1

    def all_check(self, dice):
        dice1.check_one_around(dice)
        # b面をトップにする
        dice1.move("N")
        dice1.check_one_around(dice)

        # c面をトップにする
        dice1.move("W")
        dice1.check_one_around(dice)

        # e面をトップにする
        dice1.move("W")
        dice1.check_one_around(dice)

        # d面をトップにする
        dice1.move("W")
        dice1.check_one_around(dice)

        # f面をトップにする
        dice1.move("N")
        dice1.check_one_around(dice)

    def clear_result(self):
        self.result = 0


a, b, c, d, e, f = map(int, input().split())
dice1 = Dice(a, b, c, d, e, f)
a, b, c, d, e, f = map(int, input().split())
dice2 = Dice(a, b, c, d, e, f)
dice1.all_check(dice2)

if dice1.result != 0:
    print("Yes")
else:
    print("No")

Submission status: Accepted

Solution code:
class Dice():
    #0:上面、1:前面、2:側面(見える方)、3:側面(裏側)、4:背面、5:底面
    def __init__(self,numlist):
        self.lst=numlist
    
    def roll(self,direction):
        for x in direction:
            if x=="S" : self.lst=[self.lst[4],self.lst[0],self.lst[2],self.lst[3],self.lst[5],self.lst[1]]
            elif x=="N" : self.lst=[self.lst[1],self.lst[5],self.lst[2],self.lst[3],self.lst[0],self.lst[4]]
            elif x=="W" : self.lst=[self.lst[2],self.lst[1],self.lst[5],self.lst[0],self.lst[4],self.lst[3]]
            elif x=="E" : self.lst=[self.lst[3],self.lst[1],self.lst[0],self.lst[5],self.lst[4],self.lst[2]]        
    
    def dice_set_make(self):
        self.dice_set=[]
        for x in ["","W","WW","WWW","SE","SW"]:
            self.work=Dice(self.lst[:])
            self.work.roll(x)
            self.dice_set.append(self.work.lst)
            for _ in range(3):
                self.work.roll("S")
                self.dice_set.append(self.work.lst)
        

lst=list(map(int,input().split()))
d1=Dice(lst)
d1.dice_set_make()
dice_set=d1.dice_set
lst2=list(map(int,input().split()))

if lst2 in dice_set:
    print("Yes")
else : print("No")

Submission status: Accepted

Solution code:
class Dice:
    D = {'E': (3, 1, 0, 5, 4, 2),
         'W': (2, 1, 5, 0, 4, 3),
         'S': (4, 0, 2, 3, 5, 1),
         'N': (1, 5, 2, 3, 0, 4)}
    def __init__(self, a, b, c, d, e, f):
        self.nbrs = [a, b, c, d, e, f]
        self.tp = a
        self.fwd = b
        self.rs = c
        self.ls = d
        self.bk = e
        self.bm = f
    def rll(self, dr):
        self.nbrs = [self.nbrs[i] for i in self.D[dr]]
        self.tp = self.nbrs[0]
        self.fwd = self.nbrs[1]
        self.rs = self.nbrs[2]
        self.ls = self.nbrs[3]
        self.bk = self.nbrs[4]
        self.bm = self.nbrs[5]


a, b, c, d, e, f = input().split()
dice1 = Dice(a, b, c, d, e, f)
a, b, c, d, e, f = input().split()
dice2 = Dice(a, b, c, d, e, f)
for i in 'NNNN':
    dice2.rll(i)
    for i in 'EEEE':
        dice2.rll(i)
        for i in 'NNNN':
            dice2.rll(i)
            if dice2.nbrs == dice1.nbrs:
                print('Yes')
                exit()
print('No')

Submission status: Accepted

Solution code:
class Dice():
    def __init__(self, spots):
        self.spots = [spots[i] for i in range(6)]
    
    def roll(self, direction):
        if direction == 0:
            self.spots = [self.spots[i] for i in [1, 5, 2, 3, 0, 4]]
        elif direction == 1:
            self.spots = [self.spots[i] for i in [3, 1, 0, 5, 4, 2]]
        elif direction == 2:
            self.spots = [self.spots[i] for i in [4, 0, 2, 3, 5, 1]]
        elif direction == 3:
            self.spots = [self.spots[i] for i in [2, 1, 5, 0, 4, 3]]
            
dice_a = list(map(int, input().split()))
dice_b = list(map(int, input().split()))

my_dice = Dice(dice_a)

a, b = dice_b[0], dice_b[1]

if b == my_dice.spots[0]:
    my_dice.roll(2)
elif b == my_dice.spots[1]:
    pass
elif b == my_dice.spots[2]:
    my_dice.roll(3)
    my_dice.roll(2)
elif b == my_dice.spots[3]:
    my_dice.roll(1)
    my_dice.roll(2)
elif b == my_dice.spots[4]:
    my_dice.roll(2)
    my_dice.roll(2)
elif b == my_dice.spots[5]:
    my_dice.roll(0)

if a == my_dice.spots[0]:
    pass
elif a == my_dice.spots[2]:
    my_dice.roll(3)
elif a == my_dice.spots[3]:
    my_dice.roll(1)
elif a == my_dice.spots[5]:
    my_dice.roll(1)
    my_dice.roll(1)
    
if my_dice.spots == dice_b:
    print('Yes')
else:
    print('No')

Submission status: Accepted

Solution code:
dice = list(input().split(' '))
a = list('NNNNWNNNWNNNENNNENNNWNNN')
x = 0
aa,bb,cc,dd,ee,ff  = input().split(' ')
for i in a:
    if i == 'W':
        dice = [dice[2],dice[1],dice[5],dice[0],dice[4],dice[3]]
    elif i == 'S':
        dice = [dice[4],dice[0],dice[2],dice[3],dice[5],dice[1]]
    elif i == 'N':
        dice = [dice[1],dice[5],dice[2],dice[3],dice[0],dice[4]]
    elif i == 'E':
        dice = [dice[3],dice[1],dice[0],dice[5],dice[4],dice[2]]
    if dice[0] == aa and dice[1] == bb and dice[2] == cc and dice[3] == dd and dice[4] == ee and dice[5] == ff:
        x = x + 1
kome = 'Yes' if x > 0 else 'No'
print(kome)

Submission status: Accepted

Solution code:
class Dice:
    def __init__(self, top, south, east, west, north, bottom):
        self.top = top
        self.south = south
        self.east = east
        self.west = west
        self.north = north
        self.bottom = bottom

    def toN(self):
        tmp = self.top
        self.top = self.south
        self.south = self.bottom
        self.bottom = self.north
        self.north = tmp

    def toE(self):
        tmp = self.top
        self.top = self.west
        self.west = self.bottom
        self.bottom = self.east
        self.east = tmp

    def toS(self):
        tmp = self.top
        self.top = self.north
        self.north = self.bottom
        self.bottom = self.south
        self.south = tmp

    def toW(self):
        tmp = self.top
        self.top = self.east
        self.east = self.bottom
        self.bottom = self.west
        self.west = tmp

    def printTop(self):
        print(self.top)

    def printWest(self):
        print(self.west)

    def printEast(self):
        print(self.east)

    def getTop(self, target):
        if self.top == target:
            return
        for i in range(3):
            self.toN()
            if self.top == target:
                return
        for i in range(3):
            self.toE()
            if self.top == target:
                return

        if self.top != target:
            print("Error")

    def getSouth(self, target):
        if self.south == target:
            return
        for i in range(3):
            self.lotate()
            if self.south == target:
                return
    
    def lotate(self):
        tmp = self.north
        self.north = self.east
        self.east = self.south
        self.south = self.west
        self.west = tmp

    def isSame(self, other):
        if self.top == other.top and \
           self.north == other.north and \
           self.east == other.east and \
           self.south == other.south and \
           self.west == other.west and \
           self.bottom == other.bottom:
            return True
        else:
            return False

    def compare(self, other):
        for i in range(4):
            for j in range(4):
                if self.isSame(other) == True:
                    return True
                self.lotate()
            self.toN()

        for i in range(4):
            for j in range(4):
                if self.isSame(other) == True:
                    return True
                self.lotate()
            self.toE()
        return False

n = input().split()
dice1 = Dice(int(n[0]), int(n[1]), int(n[2]), int(n[3]), int(n[4]), int(n[5]))                                                 
n = input().split()
dice2 = Dice(int(n[0]), int(n[1]), int(n[2]), int(n[3]), int(n[4]), int(n[5]))

if dice1.compare(dice2) == True:
    print("Yes")
else:
    print("No")

Submission status: Accepted

Solution code:
class Dice:
    def __init__(self, ary): # [top, front, right, left, back, bottom]
        self.__top = ary[0]
        self.__fro = ary[1]
        self.__rit = ary[2]
        self.__lft = ary[3]
        self.__bak = ary[4]
        self.__btm = ary[5]

    def turn_e(self): # 右に転がる
        self.__top, self.__lft, self.__btm, self.__rit = \
        self.__lft, self.__btm, self.__rit, self.__top

    def turn_s(self): # 手前に転がる
        self.__top, self.__fro, self.__btm, self.__bak = \
        self.__bak, self.__top, self.__fro, self.__btm

    def turn_w(self): # 左に転がる
        self.__top, self.__lft, self.__btm, self.__rit = \
        self.__rit, self.__top, self.__lft, self.__btm

    def turn_n(self): # 奥に転がる
        self.__top, self.__fro, self.__btm, self.__bak = \
        self.__fro, self.__btm, self.__bak, self.__top

    def spin_r(self): # 右回転 
        self.__rit, self.__fro, self.__lft, self.__bak = \
        self.__bak, self.__rit, self.__fro, self.__lft

    def spin_l(self): # 左回転
        self.__rit, self.__fro, self.__lft, self.__bak = \
        self.__fro, self.__lft, self.__bak, self.__rit

    def is_same_setting(self, ary): # 同じように置いているか
        if self.__top == ary[0] and self.__fro == ary[1] and self.__rit == ary[2] and \
            self.__lft == ary[3] and self.__bak == ary[4] and self.__btm == ary[5]:
            return True

    def is_same_dice(self, ary): # 回転させて同じダイスになるか
        is_same = False
        for _ in range(2):
            for _ in range(3):
                for _ in range(4):
                    if self.is_same_setting(ary):
                        is_same = True
                    self.spin_r()
                self.turn_n()
            self.spin_r()
            self.turn_s()
        return is_same

    def show_top(self): # 上面の値を表示
        return self.__top


surfaces1 = list(map(int,input().split()))
surfaces2 = list(map(int,input().split()))

dice = Dice(surfaces1)

if dice.is_same_dice(surfaces2):
    print('Yes')
else:
    print('No')

Submission status: Accepted

Solution code:
import sys
reverse = {
    "E":"W",
    "W":"E",
    "S":"N",
    "N":"S"
    }
        
class dice:
    def __init__(self,A):
        self.list = sorted(A)
        self.max = max(A)
        self.min = min(A)
        self.side = {
            "TOP":A[0],
            "S":A[1],
            "E":A[2],
            "W":A[3],
            "N":A[4],
            "BOT":A[5],
            }
    def get_list(self):
        return self.list
    def get_dict(self):
        return self.side
    def check(self):
        pass
    def main(self,A):
        for s in A:
            var = int(self.side[s])
            self.side[s] = self.side["TOP"]
            self.side["TOP"] = self.side[reverse[s]]
            self.side[reverse[s]] = self.side["BOT"]
            self.side["BOT"] = var
    def rot(self):
        var = self.side["N"]
        self.side["N"] = self.side["E"]
        self.side["E"] = self.side["S"]
        self.side["S"] = self.side["W"]
        self.side["W"] = var
    def rotate(self,top,flont):
        self.top_set(top)
        for x in range(4):
            if self.side["S"] == flont:
                break
            else:
                var = int(self.side["N"])
                self.side["N"] = self.side["E"]
                self.side["E"] = self.side["S"]
                self.side["S"] = self.side["W"]
                self.side["W"] = var
        return list([self.side["TOP"],self.side["S"],self.side["E"]])
    def top_set(self,top):
        if self.side["BOT"] == top:
            self.main("NN")
        elif self.side["N"] == top:
            self.main("S")
        elif self.side["S"] == top:
            self.main("N")
        elif self.side["E"] == top:
            self.main("W")
        elif self.side["W"] == top:
            self.main("E")


a = dice(list(map(int,input().split())))
b = dice(list(map(int,input().split())))

a_list = a.get_list()
b_list = b.get_list()

if a_list != b_list:
    print("No")
else:
    a_dict = a.get_dict()
    for do in ["N","N","N","N","E","EE"]:
        b.main(do)
        for i in range(4):
            b.rot()
            if a_dict == b.get_dict():
                print("Yes")
                sys.exit()
                break
        else:
            continue
        break

print("No")

Submission status: Accepted

Solution code:
patterns = [
    [1, 2, 3, 4, 5, 6],
    [1, 3, 5, 2, 4, 6],
    [1, 5, 4, 3, 2, 6],
    [1, 4, 2, 5, 3, 6],
    [2, 6, 3, 4, 1, 5],
    [2, 3, 1, 6, 4, 5],
    [2, 1, 4, 3, 6, 5],
    [2, 4, 6, 1, 3, 5],
    [3, 6, 5, 2, 1, 4],
    [3, 5, 1, 6, 2, 4],
    [3, 1, 2, 5, 6, 4],
    [3, 2, 6, 1, 5, 4],
    [4, 6, 2, 5, 1, 3],
    [4, 2, 1, 6, 5, 3],
    [4, 1, 5, 2, 6, 3],
    [4, 5, 6, 1, 2, 3],
    [5, 3, 6, 1, 4, 2],
    [5, 6, 4, 3, 1, 2],
    [5, 4, 1, 6, 3, 2],
    [5, 1, 3, 4, 6, 2],
    [6, 2, 4, 3, 5, 1],
    [6, 3, 2, 5, 4, 1],
    [6, 4, 5, 2, 3, 1], 
    [6, 5, 3, 4, 2, 1]
]

a = list(map(int,input().split()))
b = list(map(int, input().split()))

d = dict(zip(list(range(1, 7)), a))

ds = []
for pattern in patterns:
    c = [d.get(x) for x in pattern]
    ds.append(c)

if b  in ds:
    print('Yes')
else:
    print('No')

Submission status: Accepted

Solution code:
import sys
input = sys.stdin.readline


class Dice:
    """
    0:top, 1:south, 2:east, 3:west, 4:north, 5:bottom
    """

    def __init__(self, surfaces):
        self.init_surface = surfaces
        self.surface = surfaces

    def init_dice(self):
        self.surface = self.init_surface

    def roll(self, direction: str):
        if direction == "E":
            self.surface = [self.surface[3], self.surface[1], self.surface[0],
                            self.surface[5], self.surface[4], self.surface[2]]

        elif direction == "N":
            self.surface = [self.surface[1], self.surface[5], self.surface[2],
                            self.surface[3], self.surface[0], self.surface[4]]

        elif direction == "S":
            self.surface = [self.surface[4], self.surface[0], self.surface[2],
                            self.surface[3], self.surface[5], self.surface[1]]

        elif direction == "W":
            self.surface = [self.surface[2], self.surface[1], self.surface[5],
                            self.surface[0], self.surface[4], self.surface[3]]

        return

    def spin(self):
        self.surface = [self.surface[0], self.surface[3], self.surface[1],
                        self.surface[4], self.surface[2], self.surface[5]]
        return

    def get_surface(self, num):
        if num in self.surface:
            indexes = [i for i, x in enumerate(self.surface) if x == num]
            return indexes
        else:
            return None

    def get_top(self):
        return self.surface[0]

    def get_south(self):
        return self.surface[1]

    def get_east(self):
        return self.surface[2]


def main():
    surface = [int(i) for i in input().strip().split()]
    dice1 = Dice(surface)
    surface = [int(i) for i in input().strip().split()]
    dice2 = Dice(surface)

    top1 = dice1.get_top()
    indexes = dice2.get_surface(top1)
    for cur in indexes:
        dice2.init_dice()
        if cur == 0:
            pass
        elif cur == 1:
            dice2.roll("N")
        elif cur == 2:
            dice2.roll("W")
        elif cur == 3:
            dice2.roll("E")
        elif cur == 4:
            dice2.roll("S")
        elif cur == 5:
            dice2.roll("S")
            dice2.roll("S")
        for _ in range(4):
            dice2.spin()
            if dice1.surface == dice2.surface:
                print("Yes")
                return
    print("No")


if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
class Dice(object):
    def __init__(self):
        self.number = [0 for _ in range(6)]
        self.before = [0 for _ in range(6)]
        self.init = [0 for _ in range(6)]

    def set_number(self, l):
        for i in range(6):
            self.number[i] = l[i]

    def roll(self, loc):
        d = {
            'N': (1, 5, 2, 3, 0, 4),
            'S': (4, 0, 2, 3, 5, 1),
            'E': (3, 1, 0, 5, 4, 2),
            'W': (2, 1, 5, 0, 4, 3)
        }
        for i in range(6):
            self.before[i] = self.number[i]

        for i, j in enumerate(d[loc]):
            self.number[i] = self.before[j]

    def roll_clockwise(self):
        for i in range(6):
            self.before[i] = self.number[i]
        self.number = [self.before[i] for i in (0, 2, 4, 1, 3, 5)]

    def set_Top_and_Front(self, top, front):
        top_index = self.number.index(top)
        if top_index == 5:
            self.roll('E')
            self.roll('E')
        elif top_index == 4:
            self.roll('S')
        elif top_index == 3:
            self.roll('E')
        elif top_index == 2:
            self.roll('W')
        elif top_index == 1:
            self.roll('N')
        front_index = self.number.index(front)
        if front_index == 1:
            pass
        elif front_index == 2:
            self.roll_clockwise()
        elif front_index == 3:
            self.roll_clockwise()
            self.roll_clockwise()
            self.roll_clockwise()
        elif front_index == 4:
            self.roll_clockwise()
            self.roll_clockwise()

    def set_Top(self, idx):
        if idx == 5:
            self.roll('E')
            self.roll('E')
        elif idx == 4:
            self.roll('S')
        elif idx == 3:
            self.roll('E')
        elif idx == 2:
            self.roll('W')
        elif idx == 1:
            self.roll('N')
        elif idx == 0:
            pass

    def check_identity(self, another_dice):
        res = False

        for i in range(6):
            self.init[i] = self.number[i]

        for i in range(6):
            self.set_Top(i)
            for j in range(4):
                if j == 0:
                    pass
                else:
                    self.roll_clockwise()
                if self.number == another_dice:
                    res = True
                    break
            if res:
                break
            for i in range(6):
                self.number[i] = self.init[i]
        return res


if __name__ == '__main__':
    l = list(map(int, input().split()))
    dice_a = Dice()
    dice_a.set_number(l)
    m = list(map(int, input().split()))
    print('Yes' if dice_a.check_identity(m) else 'No')

Submission status: Accepted

Solution code:
class Dice():
    def __init__(self):
        self.num = [0 for _ in range(6)]
    
    def set_num(self, n0, n1, n2, n3, n4, n5):
        self.num[0] = n0
        self.num[1] = n1
        self.num[2] = n2
        self.num[3] = n3
        self.num[4] = n4
        self.num[5] = n5
    
    
    def roll(self, order):
        tmp = self.num.copy()
        
        if order == "N":
            self.set_num(tmp[1], tmp[5], tmp[2], tmp[3], tmp[0], tmp[4])
        elif order == "S":
            self.set_num(tmp[4], tmp[0], tmp[2], tmp[3], tmp[5], tmp[1])
        elif order == "E":
            self.set_num(tmp[3], tmp[1], tmp[0], tmp[5], tmp[4], tmp[2])
        elif order == "W":
            self.set_num(tmp[2], tmp[1], tmp[5], tmp[0], tmp[4], tmp[3])
        elif order == "rot_Clock":
            self.set_num(tmp[0], tmp[2], tmp[4], tmp[1], tmp[3], tmp[5])
        else:
            print("Error: 不正な入力です")

    def get_top_num(self):
        return self.num[0]
        
    
# Input
init_num1 = [int(_) for _ in input().split()]
init_num2 = [int(_) for _ in input().split()]

# Set Dice
dice1 = Dice()
dice2 = Dice()
dice1.set_num(init_num1[0], init_num1[1], init_num1[2], init_num1[3], init_num1[4], init_num1[5])
dice2.set_num(init_num2[0], init_num2[1], init_num2[2], init_num2[3], init_num2[4], init_num2[5])

# 1st way
checker = False
for i in range(3):
    for j in range(3):
        orders = "N" * (i + 1) + "E" * (j + 1)
        # print(orders)
        
        for order in orders:
            dice2.roll(order)
        if dice1.num == dice2.num:
            checker = True
        
for i in range(3):
    for j in range(3):
        orders = "E" * (i + 1) + "N" * (j + 1)
        # print(orders)
        
        for order in orders:
            dice2.roll(order)
        if dice1.num == dice2.num:
            checker = True

for i in range(3):
    for j in range(3):
        for k in range(3):
            orders = "E" * (i + 1) + "N" * (j + 1) + "E" * (k + 1)
            # print(orders)
            
            for order in orders:
                dice2.roll(order)
            if dice1.num == dice2.num:
                checker = True

for i in range(3):
    for j in range(3):
        for k in range(3):
            orders = "N" * (i + 1) + "E" * (j + 1) + "N" * (k + 1)
            # print(orders)
            
            for order in orders:
                dice2.roll(order)
            if dice1.num == dice2.num:
                checker = True


# 2nd way
if checker == False:
    num_dice1_top, num_dice1_front = dice1.num[0], dice1.num[1]
    
    index_top = dice2.num.index(num_dice1_top)
    index_front = dice2.num.index(num_dice1_front)
    
    counter = 0
    while (index_top != 0) & (counter < 3):
        counter += 1
        if index_top in [0, 1, 4, 5]:
            dice2.roll("N")
            index_top = dice2.num.index(num_dice1_top)
            index_front = dice2.num.index(num_dice1_front)
        else:
            dice2.roll("E")
            index_top = dice2.num.index(num_dice1_top)
            index_front = dice2.num.index(num_dice1_front)
    
    counter = 0
    while (index_front != 1) & (counter < 3):
            dice2.roll("rot_Clock")
            index_top = dice2.num.index(num_dice1_top)
            index_front = dice2.num.index(num_dice1_front)
    
    # print(f"dice1: {dice1.num}")
    # print(f"dice2: {dice2.num}")
    
    if dice1.num == dice2.num:
        checker = True

if checker:
    print("Yes")
else:
    print("No")

Submission status: Accepted

Solution code:
from enum import Enum
import sys
import math

BIG_NUM = 2000000000
MOD = 1000000007
EPS = 0.000000001

# 0:中央 1:南 2:東 3:西 4:北 5:裏側


class Dice():

    def __init__(self):
        self.number = [i for i in range(6)]
        self.work = [i for i in range(6)]
        self.order = 'NNNNWNNNWNNNENNNENNNWNNN'

    def setNumber(self, n0, n1, n2, n3, n4, n5):
        self.number[0] = n0
        self.number[1] = n1
        self.number[2] = n2
        self.number[3] = n3
        self.number[4] = n4
        self.number[5] = n5

    def roll(self, loc):
        for i in range(6):
            self.work[i] = self.number[i]

        if loc == 'E':
            self.setNumber(self.work[3], self.work[1], self.work[0],
                           self.work[5], self.work[4], self.work[2])
        elif loc == 'N':
            self.setNumber(self.work[1], self.work[5], self.work[2],
                           self.work[3], self.work[0], self.work[4])
        elif loc == 'S':
            self.setNumber(self.work[4], self.work[0], self.work[2],
                           self.work[3], self.work[5], self.work[1])
        elif loc == 'W':
            self.setNumber(self.work[2], self.work[1], self.work[5],
                           self.work[0], self.work[4], self.work[3])

    def equals(self, another):

        ret = False

        for i in range(len(self.order)):
            self.roll(self.order[i])
            FLG = True
            for k in range(6):
                if self.number[k] != another.number[k]:
                    FLG = False
                    break
            if FLG == True:
                return True

        return ret


diceA = Dice()
diceB = Dice()

table = list(map(int, input().split()))
diceA.setNumber(table[0], table[1], table[2], table[3], table[4], table[5])

table = list(map(int, input().split()))
diceB.setNumber(table[0], table[1], table[2], table[3], table[4], table[5])

if diceA.equals(diceB):
    print("Yes")
else:
    print("No")

Submission status: Accepted

Solution code:
class dice:
    def __init__(self,label):
        self.top, self.front, self.right, self.left, self.rear, self.bottom \
                = label
  
    def roll(self,op):
        if   op=='N': self.top, self.front, self.bottom, self.rear = \
                                self.front, self.bottom, self.rear , self.top
        elif op=='E': self.top, self.left , self.bottom, self.right = \
                                self.left , self.bottom, self.right, self.top
        elif op=='W': self.top, self.right, self.bottom, self.left = \
                                self.right, self.bottom, self.left , self.top
        elif op=='S': self.top, self.rear , self.bottom, self.front = \
                                self.rear , self.bottom, self.front, self.top
  
    def print_top(self): print(self.top)
    def print_right(self): print(self.right)
  
    def get_label(self):
        return [self.top, self.front, self.right, self.left, self.rear, self.bottom]
   
label = list(map(int,input().split()))
d0 = dice(label)
d1 = list(map(int,input().split()))
for op in 'EEENEEENEEESEEESEEENEEEN':
    if d0.get_label() == d1:
        print('Yes')
        break
    d0.roll(op)
else:
    print('No')

Submission status: Accepted

Solution code:
class Dice():

    def __init__(self):
        self.number = [i for i in range(6)]
        self.work = [i for i in range(6)]
        self.order = 'NNNNWNNNWNNNENNNENNNWNNN'

    def setNumber(self, n0, n1, n2, n3, n4, n5):
        self.number[0] = n0
        self.number[1] = n1
        self.number[2] = n2
        self.number[3] = n3
        self.number[4] = n4
        self.number[5] = n5

    def roll(self, loc):
        for i in range(6):
            self.work[i] = self.number[i]

        if loc == 'E':
            self.setNumber(self.work[3], self.work[1], self.work[0], self.work[5], self.work[4], self.work[2])
        elif loc == 'N':
            self.setNumber(self.work[1], self.work[5], self.work[2], self.work[3], self.work[0], self.work[4])
        elif loc == 'S':
            self.setNumber(self.work[4], self.work[0], self.work[2], self.work[3], self.work[5], self.work[1])
        elif loc == 'W':
            self.setNumber(self.work[2], self.work[1], self.work[5], self.work[0], self.work[4], self.work[3])

    def equals(self, another):

        ret = False;

        for i in range(len(self.order)):
            self.roll(self.order[i])
            FLG = True
            for k in range(6):
                if self.number[k] != another.number[k]:
                    FLG = False
                    break
            if FLG == True:
                return True

        return ret


diceA = Dice()
diceB = Dice()

table = list(map(int, input().split()))
diceA.setNumber(table[0], table[1], table[2], table[3], table[4], table[5])

table = list(map(int, input().split()))
diceB.setNumber(table[0], table[1], table[2], table[3], table[4], table[5])

if diceA.equals(diceB):
    print("Yes")
else:
    print("No")

Submission status: Accepted

Solution code:
# サイコロ        初期状態
#    [1]           N
# [4][2][3][5]   W[1]E
#    [6]           S
#
# 上記の順番でラベルに対する整数が与えられる
# l1 l2 l3 l4 l5 l6
# 2つのサイコロが一致するか

class Dice:
    def __init__(self, l1, l2, l3, l4, l5, l6):
        self.l1 = l1
        self.l2 = l2
        self.l3 = l3
        self.l4 = l4
        self.l5 = l5
        self.l6 = l6
        self.tmp = 0
    def move_n(self):
        self.tmp = self.l5
        self.l5 = self.l1
        self.l1 = self.l2
        self.l2 = self.l6
        self.l6 = self.tmp
    def move_s(self):
        self.tmp = self.l2
        self.l2 = self.l1
        self.l1 = self.l5
        self.l5 = self.l6
        self.l6 = self.tmp
    def move_e(self):
        self.tmp = self.l3
        self.l3 = self.l1
        self.l1 = self.l4
        self.l4 = self.l6
        self.l6 = self.tmp
    def move_w(self):
        self.tmp = self.l4
        self.l4 = self.l1
        self.l1 = self.l3
        self.l3 = self.l6
        self.l6 = self.tmp
    def show(self):
        return self.l1, self.l2, self.l3, self.l4, self.l5, self.l6

yn_f = False
d1 = Dice(*map(int, input().split()))
d2 = Dice(*map(int, input().split()))

if set(d1.show()) == set(d2.show()):
    ne_switch = 0
    while d1.l2 != d2.l2:
        if ne_switch < 3:
            d1.move_n()
            ne_switch+=1
        elif 3 <= ne_switch :
            d1.move_e()
            ne_switch+=1
        if ne_switch == 6: ne_switch = 0
    e_cnt = 0
    while d1.l1 != d2.l1 and e_cnt <= 3:
        d1.move_e()
        e_cnt+=1

if d1.l3 == d2.l3 and d1.l4 == d2.l4 and d1.l5 == d2.l5 and d1.l6 == d2.l6:
    yn_f = True

print('Yes' if yn_f else 'No')