键盘组合电话号码

Question

我知道这个问题已经被问了一百次，但我正在寻找一种不涉及任何字符串函数或外部类的解决方案。

我已经编写了一些实际有效的类，但它们都使用String.substring或String.replace，Arraylists等，这在我的情况下是不允许的。

我已经研究了一个多星期了，我似乎没有任何进展。

我只是不能把字符串方法放在一个非常大的循环中或其他东西。

有什么想法吗？

这是我到目前为止所写的内容。

public class Oldie {
    public static void main(String[] args) {
        char[][] array = {
            { '0' }, { '1' }, { 'A', 'B', 'C' }, { 'D', 'E', 'F' },
            { 'G', 'H', 'I' }, { 'J', 'K', 'L' }, { 'M', 'N', 'O' },
            { 'P', 'Q', 'R', 'S' }, { 'T', 'U', 'V' }, { 'W', 'X', 'Y', 'Z' }
        };
        String num = "222";
        int[] number = new int[num.length()];
        char[] permutations = new char[num.length()];
        for (int i = 0; i < num.length(); i++) {
            number[i] = Character.getNumericValue(num.charAt(i));
        }
        char First, Second, Third;
        for (char i = array[number[0]][0]; i <= array[number[0]][array[number[0]].length - 1]; i++) {
            First = i;
            for (char j = array[number[1]][0]; j <= array[number[1]][array[number[1]].length - 1]; j++) {
                Second = j;
                for (char k = array[number[2]][0]; k <= array[number[2]][array[number[2]].length - 1]; k++) {
                    Third = k;
                    System.out.println("" + First + "" + Second + "" + Third);
                }
            }
        }
    }
}

如果我可以在带有 redix 等的基本类型解决方案中做到这一点会更好。

Answer 1

我不太确定你对循环的意思，但是当你修复它时，这应该是另一个不保存字符串的解决方案（现在这抛出了一个"java.lang.ArrayIndexOutOfBoundsException"，因为我不太明白，你想用你的for循环完成什么）。这段代码应该更多地被视为如何解决问题的提示，而不是完整的解决方案！这也有点保存旧的字符串。相反，您还可以删除每个 for 循环末尾字符串的最后一个字符：

public class Oldie {
    char[][] array = {
            { '0' }, { '1' }, { 'A', 'B', 'C' }, { 'D', 'E', 'F' },
            { 'G', 'H', 'I' }, { 'J', 'K', 'L' }, { 'M', 'N', 'O' },
            { 'P', 'Q', 'R', 'S' }, { 'T', 'U', 'V' }, { 'W', 'X', 'Y', 'Z' }
        };
    String num = "222";
    String savedPerm;
    int[] number = new int[num.length()];
    public static void main(String[] args) {
        Oldie oldie = new Oldie();
        oldie.givePerm(0);
    }
    Oldie(){
        for (int i = 0; i < num.length(); i++) {
            number[i] = Character.getNumericValue(num.charAt(i));
        }
    }
    private void givePerm(int position){
        String oldSavedPerm=savedPerm;
//      if(array.length!=number.length){
//          System.out.println("Different length!");
//          System.out.println(array.length+";"+number.length);
//          return;
//      }
        for (char c = array[number[position]][0]; c <= array[number[position]][array[number[position]].length - 1]; c++) {
            savedPerm=c+oldSavedPerm;
            if(position<array.length-1)
                givePerm(position+1);
            else
                System.out.println(savedPerm);
        }
    }
}

Answer 2

这是我对你问题的方法。

char[][] array = {
    { '0' }, { '1' }, { 'A', 'B', 'C' }, { 'D', 'E', 'F' },
    { 'G', 'H', 'I' }, { 'J', 'K', 'L' }, { 'M', 'N', 'O' },
    { 'P', 'Q', 'R', 'S' }, { 'T', 'U', 'V' }, { 'W', 'X', 'Y', 'Z' }
};
String num = "123";
// creates an combination Array
// for 123 this is {{1},{ABC},{DEF}}
char[][] combinationArr = new char[num.length()][];         
for(int ix = 0; ix < num.length(); ix++)
    combinationArr[ix] = array[Character.getNumericValue(num.charAt(ix))];
// now print all permutations of combination Array
// ics holds the actual index at each position
int[] ics = new int[num.length()];
boolean end = false;
while(!end){ // while there are combinations left       
    // print the actual combination
    for(int i = 0; i < combinationArr.length; i++)
        System.out.print(combinationArr[i][ics[i]]);
    System.out.println();               
    // increases one index, starting with the last one.
    // If there is no char left it starts again at 0
    // and the index before will get increased.
    // If the first one could not get increased
    // we have all combinations.
    for(int i = ics.length - 1; i >= 0; i--){
        ics[i]++;
        if(ics[i] == combinationArr[i].length)
            if(i == 0) end = true;
            else ics[i] = 0;
        else break;
    }               
}

Answer 3

这是真正对我有用的！！感谢 ctst！

public class Oldie {
private static char[][] array = { { '0' }, { '1' }, { 'A', 'B', 'C' }, { 'D', 'E', 'F' },
        { 'G', 'H', 'I' }, { 'J', 'K', 'L' }, { 'M', 'N', 'O' },
        { 'P', 'Q', 'R', 'S' }, { 'T', 'U', 'V' }, { 'W', 'X', 'Y', 'Z' } };
private static String num = "2222";
private static char[] savedPerm = new char[num.length];
private static int[] number = new int[num.length()];
public static void main(String[] args) {
    for (int i = 0; i < num.length(); i++) {
        number[i] = Character.getNumericValue(num.charAt(i));
    }
    givePerm(0);
}

private static void givePerm(int position) {
    for (char c = array[number[position]][0]; c <= array[number[position]][array[number[position]].length - 1]; c++) {
        savedPerm[position] = c;
        if (position < number.length - 1)
            givePerm(position + 1);
        else{
            for(char text: savedPerm){
                 System.out.print(""+text);
            }
            System.out.println();
        }
    }
}
}

Answer 4

我建议你做一个递归方法：

private String givePerm(String givenPerm, char[][] array, int position, int[] number){
    if(array.length!=number.length)
        return null;
    for (char c = array[number[position]][0]; c <= array[number[position]][array[number[position]].length - 1]; c++) {
        String permString;
        if(position<array.length-1)
             permString = givePerm(c+givenPerm, array, position+1);
        else
             permString = ""+c; 
        return permString;
     }
}

Answer 5

使用递归，您可以调用 permutations 方法，并通过抓取头数字并将尾部传递到下一个调用中来继续减少输入位数。

public class Oldie {
    private static final char[][] KEYS = {
        { '0' },
        { '1' },             { 'A','B','C' }, { 'D','E','F' },
        { 'G','H','I' },     { 'J','K','L' }, { 'M','N','O' },
        { 'P','Q','R','S' }, { 'T','U','V' }, { 'W','X','Y','Z' }
    };
    public static void main(String[] args) {
        try {
            permutations("222");
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
        }
    }
    public static void permutations(String inputNumber) throws IllegalArgumentException {
        permutations(toDigitArray(inputNumber), "");
    }
    private static void permutations(int[] inputDigits, String outputLetters) throws IllegalArgumentException {
        int headDigit = inputDigits[0];
        int[] tailDigits = tail(inputDigits);
        char[] letters = KEYS[headDigit];
        for (int i = 0; i < letters.length; i++) {
            char letter = letters[i];
            String result = outputLetters + letter;
            if (tailDigits.length == 0) {
                System.out.println(result);
            } else {
                permutations(tailDigits, result);
            }
        }
    }
    private static int[] toDigitArray(String str) throws IllegalArgumentException {
        return toDigitArray(str.toCharArray());
    }
    private static int[] toDigitArray(char[] arr) throws IllegalArgumentException {
        int[] intArr = new int[arr.length];
        for (int i = 0; i < intArr.length; i++) {
            if (!Character.isDigit(arr[i])) {
                throw new IllegalArgumentException("Character is not a valid digit");
            }
            intArr[i] = Character.digit(arr[i], 10);
        }
        return intArr;
    }
    private static int[] tail(int[] arr) {
        int[] dest = new int[arr.length - 1];
        System.arraycopy(arr, 1, dest, 0, dest.length);
        return dest;
    }
}

---

输出

AAA
AAB
AAC
ABA
ABB
ABC
ACA
ACB
ACC
BAA
BAB
BAC
BBA
BBB
BBC
BCA
BCB
BCC
CAA
CAB
CAC
CBA
CBB
CBC
CCA
CCB
CCC