Java 反向魔方'；s立方体算法

我整天都在努力完成这个简单的函数，但我不能让它像我想的那样工作。一开始可能看起来很简单，实际上在Stack Overflow中还有另外一个条目谈到了它。然而，当括号被引入时，事情会变得一团糟。 假设我们可以得到一个Rubiks立方体的算法，它看起来像 （ru'U）U'（ru'R'） 重要的是要注意，在每次移动之后，无论是否有“'”符号，都会有一个空格，除了结束括号之前的空格。 现在，对于魔方上的每一个算法，都存在它的逆运算，即撤销它的逆运算。例如，R的逆是R'，U的逆是U，ru的逆是U'R'。因此，该示例的反例是： (ru)(U"ru") 还有一点很重要，就是有很多动作（F，B，D，U，U，F，M，S，x，y，z…） 此外，每个alg都有自己的逆（R有R’，反之亦然， 你能用Java来实现这个功能吗？ 我尝试了无限循环的ifelse，例如，开关。。。 我将留下我的一些尝试仅供参考

        String fullAlg = text.toString() + " ";
        String reversedAlg = "hh";
        int numSpaces = 1;
        int pos1 = 0, pos2 = 0;
        for (int i = 0; i < text.length(); i++) {
            if (text.charAt(i) == ' ' && numSpaces == 0) {
                numSpaces++;
                pos1 = i;
            }

            if (text.charAt(i) == ' ' && numSpaces == 1) {
                numSpaces++;
                pos2 = i;
            }
            if (numSpaces == 2) {
                if (fullAlg.substring(pos1, pos2).matches("[a-zA-Z]+")){
                    Toast.makeText(this, "YES", Toast.LENGTH_SHORT).show();
                }
                switch (fullAlg.substring(pos1, pos2)) {

                    //Begin with (
                    case "(" + "[a-zA-Z]+":
                        reversedAlg += ")'" + fullAlg.substring(pos1, pos2).charAt(1);
                        break;
                    case "(" + "[a-zA-Z]+" + "\'":
                        reversedAlg += ")" + fullAlg.substring(pos1, pos2).charAt(1);
                        break;
                    case "(" + "[a-zA-Z]+" + "2":
                        reversedAlg += ")2" + fullAlg.substring(pos1, pos2).charAt(1);
                        break;

                    //No ()
                    case "[a-zA-Z]+":
                        reversedAlg += " '" + fullAlg.substring(pos1, pos2).charAt(0);
                        break;
                    case "[a-zA-Z]+" + "\'":
                        reversedAlg += " '" + fullAlg.substring(pos1, pos2).charAt(0);
                        break;
                    case "[a-zA-Z]+" + "2":
                        reversedAlg += " 2" + fullAlg.substring(pos1, pos2).charAt(0);
                        break;

                    //End with )
                    case "[a-zA-Z]+" + ")":
                        reversedAlg += " '" + fullAlg.substring(pos1, pos2).charAt(1) + "(";
                        break;
                    case "[a-zA-Z]+" + "\'" + ")":
                        reversedAlg += " " + fullAlg.substring(pos1, pos2).charAt(1) + "(";
                        break;
                    case "[a-zA-Z]+" + "2" + ")":
                        reversedAlg += " )2" + fullAlg.substring(pos1, pos2).charAt(1) + "(";
                        break;

                    //Encapsulated in ()
                    case "(" + "[a-zA-Z]+" + ")":
                        reversedAlg += " )'" + fullAlg.substring(pos1, pos2).charAt(1) + "(";
                        break;
                    case "(" + "[a-zA-Z]+" + "\'" + ")":
                        reversedAlg += " )" + fullAlg.substring(pos1, pos2).charAt(1) + "(";
                        break;
                    case "(" + "[a-zA-Z]+" + "2" + ")":
                        reversedAlg += " )2" + fullAlg.substring(pos1, pos2).charAt(1) + "(";
                        break;
                }
                numSpaces = 0;
            }
        }

        StringBuilder returnAlg = new StringBuilder(reversedAlg).reverse();
        algTV.setText(fullAlg.substring(pos1, pos2));

    }

字符串fullAlg=text.toString（）+“”；
字符串反转dalg=“hh”；
int numSpaces=1；
int pos1=0，pos2=0；
对于（int i=0；i

还是这个

        String fullAlg = text.toString();
        String fullAldReversed = "";
        int posStart = 0, posEnd = 0;
        for (int i = 0; i < fullAlg.length(); i++) {
            if (fullAlg.charAt(i) == '('){
                posStart = i;
            } else if (fullAlg.charAt(i) == ')'){
                posEnd = i;
                fullAldReversed += "(" + reverseAlg(fullAlg.substring(posStart, posEnd)) + ")";
                posStart = 0;
            }
        }
        if (posEnd == 0){
            fullAldReversed = "" + reverseAlg(fullAlg);
        }
        algTV.setText(fullAldReversed);
    }

    private StringBuilder reverseAlg(CharSequence text) {

        StringBuilder builder;
        if (!(text.charAt(0) == ' ' || text.charAt(text.length() - 1) == ' ')) {
            builder = new StringBuilder(text + " ");
        } else {
            builder = new StringBuilder(text);
        }
        int subStart = 0;
        StringBuilder auxBuilder;
        String substring = "", auxString = "";
        for (int i = 0; i < builder.length(); i++) {
            substring = "";
                int subEnd = i;
                int identifierMove = 0;
                for (int j = subStart; j <= subEnd; j++) {
                    if (builder.charAt(j) == '\'')
                        identifierMove = 1;
                    else if (builder.charAt(j) == '2')
                        identifierMove = 2;
                    else if (identifierMove == 0)
                        identifierMove = 3;
                }

                String letterMove;

                switch (identifierMove) {
                    case 1:
                        letterMove = builder.substring(subStart, subEnd - 1);
                        subStart = subEnd + 1;
                        substring = " " + letterMove;
                        break;
                    case 2:
                        letterMove = builder.substring(subStart, subEnd - 1);
                        subStart = subEnd + 1;
                        substring = " 2" + letterMove;
                        break;
                    case 3:
                        letterMove = builder.substring(subStart, subEnd);
                        subStart = subEnd + 1;
                        substring = " '" + letterMove;
                        break;
                }
            auxString += substring;
        }

        auxBuilder = new StringBuilder(auxString);
        auxBuilder.reverse().toString();
        return auxBuilder;
    }

String fullAlg=text.toString（）；
字符串fullAldReversed=“”；
int posStart=0，posEnd=0；
对于（int i=0；i对于（int j=subStart；j很抱歉耽搁了您的时间！在我看来，您的尝试过于复杂了。我认为创建一个类来表示Rubix多维数据集算法是最好的选择，因为它有点复杂，而且该类还将留有进一步扩展的空间。无论如何，它的工作方式很简单。类构造函数需要一个字符串作为输入，将文本转换为整数以便于存储和操作。从这里开始，反转算法非常简单！您所要做的就是反转数组的顺序并将所有整数乘以-1！（它们的相反方向）
import java.util.ArrayDeque;
import java.util.Arrays;
import java.util.Deque;

public class Rubiks
{
  public static void main(String[] args)
  {
    // (R U R' U) U' (R U' R')
    Instruction g1 = new Algorithm(Move.fore('R'), Move.fore('U'), Move.back('R'), Move.back('U'));
    Instruction g2 = new Algorithm(Move.fore('R'), Move.back('U'), Move.back('R'));
    Instruction full = new Algorithm(g1, Move.back('U'), g2);
    System.out.println("This algorithm: " + full);
    System.out.println("Inverts to be:  " + full.inverted());
  }
}

class Move implements Instruction
{
  private final char side;
  private final boolean inverse;

  private Move(final char side, final boolean inverse)
  {
    this.side = side;
    this.inverse = inverse;
  }

  public static Move fore(final char side)
  {
    return new Move(side, false);
  }
  public static Move back(final char side)
  {
    return new Move(side, true);
  }

  public Move inverted()
  {
    return new Move(side, !inverse);
  }

  @Override
  public String toString()
  {
    return side + (inverse ? "'" : "");
  }

  @Override
  public String toSubString()
  {
    return toString();
  }
}

class Algorithm implements Instruction
{
  private final Deque<Instruction> moves;

  private Algorithm(Deque<Instruction> moves)
  {
    this.moves = moves;
  }

  public Algorithm(Instruction... moves)
  {
    this.moves = new ArrayDeque<>(Arrays.asList(moves));
  }

  public Algorithm inverted()
  {
    Deque<Instruction> newMoves = new ArrayDeque<>(moves.size());
    for (Instruction instruction : (Iterable<Instruction>) moves::descendingIterator)
    {
      newMoves.add(instruction.inverted());
    }
    return new Algorithm(newMoves);
  }

  @Override
  public String toString()
  {
    StringBuilder sb = new StringBuilder();
    boolean first = true;
    for (Instruction instruction : moves)
    {
      if(! first)
      {
        sb.append(' ');
      }
      first = false;
      sb.append(instruction.toSubString());
    }
    return sb.toString();
  }
}

interface Instruction
{
  /**
   * Returns the inverse of this instruction
   * @return an instruction that undoes this instruction
   */
  Instruction inverted();

  /**
   * Returns the string representation of the instruction, if it were nested in another instruction
   * @return the result of toString, with parentheses if this is a complex instruction
   */
  default String toSubString()
  {
    return "(" + toString() + ")";
  }
}

This algorithm: (R U R' U') U' (R U' R')
Inverts to be:  (R U R') U (U R U' R')

private void reverseAlg(CharSequence text) {
        StringBuilder fullAlg;
        if (!(text.charAt(0) == ' ' || text.charAt(text.length() - 1) == ' ')) {
            fullAlg = new StringBuilder(text + " ");
        } else {
            fullAlg = new StringBuilder(text);
        }
        StringBuilder reversedAlg = new StringBuilder();
        for (int i = 0; i < text.length(); i++) {
            if (fullAlg.charAt(i) != '(' && fullAlg.charAt(i) != ')' && fullAlg.charAt(i) != ' '
                    && fullAlg.charAt(i) != '\'' && fullAlg.charAt(i) != '2') {

                if (fullAlg.charAt(i + 1) == '\'') {

                    if (fullAlg.charAt(i + 2) == ')') {
                        reversedAlg.append(fullAlg.charAt(i)).append(")");
                    } else {
                        reversedAlg.append(fullAlg.charAt(i));
                    }

                } else if (fullAlg.charAt(i + 1) == ' ') {

                    reversedAlg.append("\'").append(fullAlg.charAt(i));

                } else if (fullAlg.charAt(i + 1) == '2') {

                    if (fullAlg.charAt(i + 2) == ')') {
                        reversedAlg.append("2").append(fullAlg.charAt(i)).append(")");
                    } else {
                        reversedAlg.append("2").append(fullAlg.charAt(i));
                    }

                } else if (fullAlg.charAt(i + 1) == ')') {

                    reversedAlg.append("\'").append(fullAlg.charAt(i)).append(")");

                }

            } else if (fullAlg.charAt(i) == ' ' || fullAlg.charAt(i) == '(') {
                reversedAlg.append(fullAlg.charAt(i));
            }
        }

        StringBuilder aux = new StringBuilder(reversedAlg.toString()).reverse();
        for (int i = 0; i < aux.length(); i++) {
            if (aux.charAt(i) == '(') {
                aux.setCharAt(i, ')');
            } else if (aux.charAt(i) == ')') {
                aux.setCharAt(i, '(');
            }
        }
        algTV.setText(aux);
    }