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

Solution in C# (judge verdict: Accepted)

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace AOJ
{
    class Program
    {
        class Dice
        {
            int[] xIndices = new int[4];
            int[] yIndices = new int[4];
            string[] numIndicesMap = new string[6];

            public Dice()
            {
                yIndices[0] = 0;
                yIndices[1] = 1;
                yIndices[2] = 5;
                yIndices[3] = 4;

                xIndices[0] = 0;
                xIndices[1] = 3;
                xIndices[2] = 5;
                xIndices[3] = 2;

                for (int i = 0; i < numIndicesMap.Length; ++i)
                {
                    numIndicesMap[i] = (i + 1).ToString();
                }
            }
            public void SetNumberIndecesMap(ref string[] map)
            {
                if (map.Length != 6)
                {
                    throw new Exception("invalid mapper");
                }
                numIndicesMap = map;
            }

            static void Swap(ref int lhs, ref int rhs)
            {
                var tmp = lhs;
                lhs = rhs;
                rhs = tmp;
            }
            static void Move(int direction, ref int[] indices)
            {
                if (direction > 0)
                {
                    for (int i = 1; i < indices.Length; ++i)
                    {
                        Swap(ref indices[i - 1], ref indices[i]);
                    }
                }
                if (direction < 0)
                {
                    for (int i = indices.Length - 1; i > 0; --i)
                    {
                        Swap(ref indices[i - 1], ref indices[i]);
                    }
                }
            }
            void MoveX(int direction)
            {
                Move(direction, ref xIndices);
                yIndices[0] = xIndices[0];
                yIndices[2] = xIndices[2];
            }
            void MoveY(int direction)
            {
                Move(direction, ref yIndices);
                xIndices[0] = yIndices[0];
                xIndices[2] = yIndices[2];
            }
            public void Move(char directionCharactor)
            {
                switch (directionCharactor)
                {
                    case 'N':
                        MoveY(1);
                        return;
                    case 'S':
                        MoveY(-1);
                        return;
                    case 'E':
                        MoveX(1);
                        return;
                    case 'W':
                        MoveX(-1);
                        return;
                    default:
                        throw new Exception("invalid input");
                }
            }
            public void MoveReverse(char directionCharactor)
            {
                switch (directionCharactor)
                {
                    case 'N':
                        MoveY(-1);
                        return;
                    case 'S':
                        MoveY(1);
                        return;
                    case 'E':
                        MoveX(-1);
                        return;
                    case 'W':
                        MoveX(1);
                        return;
                    default:
                        throw new Exception("invalid input");
                }
            }

            public string Top
            {
                get
                {
                    return numIndicesMap[xIndices[0]];
                }
            }
            public string Bottom
            {
                get
                {
                    return numIndicesMap[xIndices[2]];
                }
            }
            public string Right
            {
                get
                {
                    return numIndicesMap[xIndices[3]];
                }
            }
            public string Left
            {
                get
                {
                    return numIndicesMap[xIndices[1]];
                }
            }
            public string Front
            {
                get
                {
                    return numIndicesMap[yIndices[1]];
                }
            }
            public string Back
            {
                get
                {
                    return numIndicesMap[yIndices[3]];
                }
            }
        }

        class DiceComparetor
        {
            class Snap
            {
                public string[] faces = new string[6];

                public Snap(Dice dice)
                {
                    faces[0] = dice.Top;
                    faces[1] = dice.Bottom;
                    faces[2] = dice.Right;
                    faces[3] = dice.Left;
                    faces[4] = dice.Front;
                    faces[5] = dice.Back;
                }

                public override bool Equals(object obj)
                {
                    var rhs = obj as Snap;
                    if (rhs == null) return false;
                    for (int i = 0; i < faces.Length; ++i)
                    {
                        if (faces[i].Equals(rhs.faces[i]) == false)
                        {
                            return false;
                        }
                    }
                    return true;
                }
                public override int GetHashCode()
                {
                    int hash = 0;
                    foreach (var f in faces)
                    {
                        hash = f.GetHashCode();
                    }
                    return hash;
                }
            }

            char[] moves = new char[4] { 'N', 'S', 'E', 'W' };
            HashSet<Snap> traversedChecker = new HashSet<Snap>();
            int maxDepth = 0;   // デバッグ用
            int checkCount = 0; // デバッグ用

            public Dice dice;

            public void traverse(int depth)
            {
                maxDepth = Math.Max(maxDepth, depth);

                for (int i = 0; i < moves.Length; ++i)
                {
                    dice.Move(moves[i]);
                    var snap = new Snap(dice);
                    if (traversedChecker.Contains(snap))
                    {
                        continue;
                    }
                    traversedChecker.Add(snap);

                    ++checkCount;
                    traverse(depth + 1);

                    dice.MoveReverse(moves[i]);
                }
            }

            public bool isSame(Dice dice)
            {
                var snap = new Snap(dice);
                return traversedChecker.Contains(snap);
            }
        }
        static bool isSameDice(string[] indicesMapper0, string[] indicesMapper1)
        {
            var dice0 = new Dice();
            dice0.SetNumberIndecesMap(ref indicesMapper0);

            var dice1 = new Dice();
            dice1.SetNumberIndecesMap(ref indicesMapper1);

            var comparator = new DiceComparetor { dice = dice0 };
            comparator.traverse(0);
            return comparator.isSame(dice1);
        }

        static void Main(string[] args)
        {
            var indicesMapper0 = Console.In.ReadLine().Split(' ').ToArray();
            var indicesMapper1 = Console.In.ReadLine().Split(' ').ToArray();

            var result = "No";
            if(isSameDice(indicesMapper0, indicesMapper1)) {
                result = "Yes";
            }

            Console.Out.WriteLine(result);
        }
    }
}