Exemple #1
0
 public Solver(Cube a)
 {
     c = (Cube)a.Clone();
     _twoPhaseSoluton = new Algo();
     table = new CubeTable(a);
 }
Exemple #2
0
        public Algo GigaSolver()
        {
            Algo alg = new Algo();

            int[] corner, edge, slice, minDistPhase2, ax, po;

            po = new int[31];
            ax = new int[31];
            corner = new int[31];
            edge = new int[31];
            slice = new int[31];
            minDistPhase2 = new int[31];

            po[0] = 1;
            ax[0] = 0;
            corner[0] = c.CornerPerm;
            edge[0] = c.Edge8Perm;
            slice[0] = c.Slice % 24;

            minDistPhase2[1] = 1;
            int mv = 0, n = 0;
            bool busy = false;
            int depthPhase2 = 1;

            do
            {
                do
                {
                    if ((depthPhase2 - n > minDistPhase2[n + 1]) && !busy)
                    {

                        if (ax[n] == 0 || ax[n] == 1)
                            ax[++n] = 2;
                        else
                            ax[++n] = 0;
                        po[n] = (ax[n] == 2 || ax[n] == 3) ? 1 : 2;
                    }
                    else if (++po[n] > 3 || (ax[n] != 2 && ax[n] != 3 && po[n] != 2))
                    {
                        do
                        {
                            if (++ax[n] > 5)
                            {
                                if (n == 0)
                                {
                                    depthPhase2++;
                                    ax[n] = 0;
                                    po[n] = 2;
                                    busy = false;
                                    break;
                                }
                                else
                                {
                                    n--;
                                    busy = true;
                                    break;
                                }
                            }
                            else
                            {
                                po[n] = (ax[n] == 2 || ax[n] == 3) ? 1 : 2;
                                busy = false;
                            }
                        } while (n != 0 &&
                                 (ax[n - 1] == ax[n] || (ax[n - 1]%2 == 0 && ax[n - 1] + 1 == ax[n]) ||
                                  (ax[n - 1]%2 == 1 && ax[n - 1] - 1 == ax[n])));
                    }
                    else busy = false;
                } while (busy);

                mv = 3 * ax[n] + po[n] - 1;
                mv = CubeTable.getMoveNumber(mv);
                corner[n + 1] = table.cornerPermMoveTable[corner[n], mv];
                edge[n + 1] = table.edgePermMoveTable[edge[n], mv];
                slice[n + 1] = table.slicePermMoveTable[slice[n], mv];
                minDistPhase2[n + 1] = getPrune2(corner[n + 1], edge[n + 1], slice[n + 1]);

                if (minDistPhase2[n + 1] == 0)
                    break;

            } while (true);

            for (int i = 0; i <= n; i++)
                alg = alg + new Algo((new Move((FaceId)ax[i], (TurnDir)(po[i] - 1))).ToString());

            return alg;
        }
Exemple #3
0
        public Algo MegaSolver()
        {
            Algo alg = new Algo();

            int[] flip, twist, slice, minDistPhase1, ax, po;

            po = new int[31];
            ax = new int[31];
            flip = new int[31];
            twist = new int[31];
            slice = new int[31];
            minDistPhase1 = new int[31];

            po[0] = 0;
            ax[0] = 0;
            flip[0] = c.Flip;
            twist[0] = c.Twist;
            slice[0] = c.Slice / 24;

            minDistPhase1[1] = 1;// else failure for depth=1, n=0
            int mv = 0, n = 0;
            bool busy = false;
            int depthPhase1 = 1;

            // +++++++++++++++++++ Main loop ++++++++++++++++++++++++++++++++++++++++++
            do
            {
                do
                {

                    //Этот ебаный код разбираем
                    if ((depthPhase1 - n > minDistPhase1[n + 1]) && !busy)
                    {

                        if (ax[n] == 0 || ax[n] == 1)
                            ax[++n] = 2;
                        else
                            ax[++n] = 0;
                        po[n] = 1;
                    }
                    else if (++po[n] > 3)
                    {
                        do
                        {
                            if (++ax[n] > 5)
                            {
                                if (n == 0)
                                {
                                    depthPhase1++;
                                    ax[n] = 0;
                                    po[n] = 1;
                                    busy = false;
                                    break;
                                }
                                else
                                {
                                    n--;
                                    busy = true;
                                    break;
                                }
                            }
                            else
                            {
                                po[n] = 1;
                                busy = false;
                            }
                        } while (n != 0 && (ax[n - 1] == ax[n] || (ax[n - 1] % 2 == 0 && ax[n - 1] + 1 == ax[n]) || (ax[n - 1] % 2 == 1 && ax[n - 1] - 1 == ax[n])));
                    }
                    else busy = false;   // и до сюда епт
                } while (busy);

                // +++++++++++++ compute new coordinates and new minDistPhase1 ++++++++++
                // if minDistPhase1 =0, the H subgroup is reached
                mv = 3 * ax[n] + po[n] - 1;
                flip[n + 1] = table.flipMoveTable[flip[n],mv];
                twist[n + 1] = table.twistMoveTable[twist[n],mv];
                slice[n + 1] = table.sliceMoveTable[slice[n],mv];
                minDistPhase1[n + 1] = getPrune(twist[n + 1], flip[n + 1], slice[n + 1]);
                // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

                if (minDistPhase1[n + 1] == 0)
                    break;

                /*if (minDistPhase1[n + 1] == 0 && n >= depthPhase1 - 5)
                {
                    minDistPhase1[n + 1] = 10;// instead of 10 any value >5 is possible
                    if (n == depthPhase1 - 1 && (s = totalDepth(depthPhase1, maxDepth)) >= 0)
                    {
                        if (s == depthPhase1
                                || (ax[depthPhase1 - 1] != ax[depthPhase1] && ax[depthPhase1 - 1] != ax[depthPhase1] + 3))
                            return useSeparator ? solutionToString(s, depthPhase1) : solutionToString(s);
                    }

                }*/
            } while (true);

            for (int i = 0; i <= n; i++)
                alg = alg + new Algo((new Move((FaceId)ax[i],(TurnDir)(po[i]-1))).ToString());

            c.Rotate(alg);
            alg += GigaSolver();

            return alg;
        }
Exemple #4
0
        /*public Algo SuperSolver ()
        {
            int i, j, k, startPrune;
            Move a = new Move();
            Algo solution = new Algo();

            k = 0;
            startPrune = table.TwistFlipPruneTable[c.Twist * CubeTable.FLIP + c.Flip];
            for (i=0;i<startPrune;i++)
            {
                for (j = 0; j < 6; j++)
                {
                    a = new Move((FaceId) j, 0);
                    for (k = 0; k < 4; k++)
                    {
                        c.Rotate(a);
                        if (startPrune-i > table.TwistFlipPruneTable[c.Twist*CubeTable.FLIP+c.Flip])
                            goto metka;
                    }
                }
                metka:
                a.Dir = (TurnDir) k;
                solution = solution + new Algo(a.ToString());
            }

            return solution;
        }*/
        public Algo SuperSolver()
        {
            int i, j, k, startPrune;
            Move a = new Move();
            Algo solution = new Algo();

            k = 0;
            startPrune = getPrune(c.Twist, c.Flip, c.Slice/24);
            for (i = 0; i < startPrune; i++)
            {
                for (j = 0; j < 6; j++)
                {
                    a = new Move((FaceId)j, 0);
                    if (solution.Length > 0 && (a.Face == solution[solution.Length - 1].Face || ((int)a.Face % 2 == 0 && a.Face + 1 == solution[solution.Length - 1].Face) || ((int)a.Face % 2 == 1 && a.Face - 1 == solution[solution.Length - 1].Face)))
                        continue;
                    for (k = 0; k < 3; k++)
                    {
                        c.Rotate(a);
                        if (startPrune - i > getPrune(c.Twist, c.Flip, c.Slice/24))
                            goto metka;
                    }
                    c.Rotate(a);
                }
                if (j == 6)
                {
                    i--;
                    startPrune++;
                    continue;
                }
                metka:
                a.Dir = (TurnDir)k;
                solution = solution + new Algo(a.ToString());
            }

            return solution;
        }
Exemple #5
0
        public static Algo operator +(Algo a, Algo b)
        {
            Algo c;
            Move m = null;
            int i, j, k;

            for (i=a.Length-1,j=0;i>=0&&j<b.Length;)
            {
                if (a[i].Face != b[j].Face)
                    break;
                if ((int)(a[i].Dir) + (int)(b[j].Dir) == 2)
                {
                    i--;
                    j++;
                    continue;
                }
                if (a[i].Dir == b[j].Dir)
                    m = new Move(a[i].Face,TurnDir.DOUBLE);
                else if ((int)(a[i].Dir) + (int)(b[j].Dir) == 1)
                    m = new Move(a[i].Face, TurnDir.CCW);
                else m = new Move(a[i].Face, TurnDir.CW);
                i--;
                j++;
                break;
            }
            c = new Algo(i+1+b.Length-j+((m == null)?(0):(1)));
            for (k = 0; k <= i; k++)
                c[k] = new Move(a[k].Face, a[k].Dir);
            if (m != null)
            {
                c[k] = m;
                k++;
            }
            for (; j < b.Length; k++, j++)
                c[k] = new Move(b[j].Face, b[j].Dir);

            return c;
        }
Exemple #6
0
        public Algo Invert()
        {
            int i;
            Algo a = new Algo(Length);

            for (i = 0; i < Length; i++)
                a._moves[i] = _moves[_moves.Length - i - 1].Invert();

            return a;
        }
Exemple #7
0
        public object Clone()
        {
            Algo a = new Algo(Length);
            int i;

            for (i=0;i<Length;i++)
                a._moves[i] = new Move(_moves[i].Face, _moves[i].Dir);

            return a;
        }
Exemple #8
0
 public void Rotate(Algo a)
 {
     for (int i=0;i<a.Length;i++)
         Rotate(a[i]);
 }
Exemple #9
0
 public Cube(Algo a)
     : this()
 {
     Rotate(a);
 }