如何在Java中对单词进行所有可能的转换

我目前正在开发一个程序，该程序将尝试根据单词中的字符生成每个可能的单词转换。例如，如果单词是hello，那么程序将打印出所有不同的变体，例如hello、hello、hello、h3ll0、h3ll0等等，直到每个组合都完成。这是我到目前为止所做的计划：

import java.io.*;

public class Transformer{
    String input = null;

    public Transformer(){
        run();
    }

    public void run(){
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        System.out.println("Please enter a word:");

        try {
            input = br.readLine();
        } catch (IOException e) {
            System.out.println("Error");
            System.exit(1);
        }

        //Convert String into char array
        char charArray[] = input.toCharArray();

        //Capitalise first letter
        if(Character.isLetter(charArray[0])){
            charArray[0] = Character.toUpperCase(charArray[0]);
        }
        System.out.println(charArray);

        //Reset transformation
        charArray = input.toCharArray();

        //Capitalise last letter
        if(Character.isLetter(charArray[charArray.length - 1])){
            charArray[charArray.length - 1] = Character.toUpperCase(charArray[charArray.length - 1]);
        }
        System.out.println(charArray);

        //Reset transformation
        charArray = input.toCharArray();


        //Iterate through charArray to make transformations to characters
        for(int i = 0; i < charArray.length; i++){
            if(charArray[i] == 'a'){
                charArray[i] = '@';
                System.out.println(charArray);
            }

            if(charArray[i] == 'o'){
                charArray[i] = '0';
                System.out.println(charArray);
            }

            if(charArray[i] == 'e'){
                charArray[i] = '3';
                System.out.println(charArray);
            }

            if(charArray[i] == 's'){
                charArray[i] = '5';
                System.out.println(charArray);
            }

            if(charArray[i] == 'i'){
                charArray[i] = '1';
                System.out.println(charArray);
            }

            if(charArray[i] == 'l'){
                charArray[i] = '7';
                System.out.println(charArray);
            }
        }
    }
}

import java.io.*；
公共级变压器{
字符串输入=null；
公共变压器（）{
run（）；
}
公开募捐{
BufferedReader br=新的BufferedReader（新的InputStreamReader（System.in））；
System.out.println（“请输入一个单词：”）；
试一试{
输入=br.readLine（）；
}捕获（IOE异常）{
System.out.println（“错误”）；
系统出口（1）；
}
//将字符串转换为字符数组
charcharray[]=input.toCharArray（）；
//大写第一个字母
if（Character.isleter（charArray[0]））{
charArray[0]=Character.toUpperCase（charArray[0]）；
}
系统输出打印LN（charArray）；
//复位变换
charArray=input.toCharArray（）；
//大写最后一个字母
if（Character.isleter（charArray[charArray.length-1]））{
charArray[charArray.length-1]=Character.toUpperCase（charArray[charArray.length-1]）；
}
系统输出打印LN（charArray）；
//复位变换
charArray=input.toCharArray（）；
//迭代charArray以对字符进行转换
for（int i=0；i

---

问题是，这只会创建有限数量的转换，并将它们彼此相加，而不是一次执行一个转换，然后执行两个转换，依此类推。我能想到的唯一解决方案是一个永无止境的if语句列表，但即使如此，我也不完全确定如何跟踪这些更改。实现这一目标的最佳方法是什么？

我告诉过你这样的事情：

public class WordTransformer {

    private HashMap<Character, char[]> transformMap = new HashMap<Character, char[]>();
    {
        transformMap.put('h', new char[]{'H', 'h'});
        transformMap.put('e', new char[]{'3', 'E'});
        transformMap.put('l', new char[]{'I', 'L'});
        transformMap.put('o', new char[]{'0', 'O'});
    }

    public List<String> doTransform(String s){
        char[] stringChars = s.toCharArray();
        List<String> versions = new ArrayList<String>();
        doTransform(s, stringChars, 0, versions);
        return versions;
    }

    //This method is recursive
    private void doTransform(String s, char[] stringChars, int index,
        List<String> versions){

        //if we reached the end of string in current iteration
        //add generated variant into list
        if(index==s.length()){
            versions.add(new String(stringChars));
            return;
        }

        char c = s.charAt(index);
        if(transformMap.containsKey(c)){
            char[] transforms = transformMap.get(c);
            for(char t : transforms){
                stringChars[index] = t;
                //And this is recursive invocation, that means method calls itself
                doTransform(s, stringChars, index+1, versions);
            }
        }else {
            //if there is no such character in transform map, process next index
            doTransform(s, stringChars, index+1, versions);
        }
    }

}

---

希望这会有所帮助。

您可以为每个字符绘制转换映射，然后使用递归方法转换所有可能的方式。我理解按顺序进行转换是如何工作的，如hello，hello，h3llo，hello，但这是否也适用于重复，然后进行更改，如h3llo，heLl0，H3ll0等等？函数如何知道何时完成了所有可能的转换，从而可以结束而不是永远循环？转换的变体数量有限。所以你的循环不会是无止境的，但是你是对的，根据组合数学的规则，可能有很多转换。特别是，长话短说，构造递归函数的最佳方法是什么？对于字符的映射，我可以这样做：

Map charMap=newhashmap（）；私有ArrayList a=新ArrayList（）；a、 放置（'a'）；a、 put（'@'）；charMap.put（'A'，A）WordTransformer transformer = new WordTransformer();
List<String> list = transformer.doTransform("hello");
for(String s : list){
    System.out.println(s);
}