Java实现EAT+THAT=APPLE密码算术题遇无限结果，求循环与条件优化

我正在解决密码算术题EAT + THAT = APPLE，每个字母对应0-9中不同的数字，需要找出所有符合条件的组合。但我编写的Java代码运行后出现无限输出，希望优化循环和条件判断部分。

原代码 #

public class Main {
    public static void main(String[] args) {
        int count = 0;
        int E,A,T,P,L,H;

        for (E = 0; E <=9; E++)   
        {
            for (A = 0; A <=9; A++)
                for (T = 0; T <=9; T++)
                    for (P = 0; P <=9; P++)
                        for (L = 0; L <=9; L++)
                            for (H = 0; H <=9; H++)

            if (((E != A) && (E != L) && (E != T)&&(E !=P) &&(E!=L)&&(E!=H) && 
                    (T != A) && (T != L) && (T != E) &&(T!=P)&&(T!=L)&&(T!=H)))
            {
                System.out.println("A"+A+"P"+P+"P"+P+"L"+L+"E"+E);
            }
            else count = count +1;    
        }
        System.out.println(count);
    }
}

原代码问题分析 #

1. 循环缩进错误：内层for循环未加大括号，导致if语句仅与最内层的H循环绑定，外层循环逻辑混乱，引发无限输出。
2. 核心逻辑缺失：完全没实现EAT + THAT = APPLE的数值等式判断，仅做了部分字母去重，根本没解决问题。
3. 去重判断不完整且重复：重复判断E!=L、T!=L，还漏掉了A、P、L、H之间的互斥检查，无法保证所有字母对应不同数字。
4. 未考虑首位规则：密码算术题中，多位数的首位字母不能为0（EAT是三位数、THAT是四位数、APPLE是五位数，所以E≠0、T≠0、A≠0）。

优化后的代码 #

public class AppleCryptarithmetic {
    public static void main(String[] args) {
        int validSolutions = 0;
        // 字母：E, A, T, P, L, H，均为0-9不同数字，且首位E、T、A不能为0
        for (int E = 1; E <= 9; E++) {
            for (int A = 1; A <= 9; A++) {
                if (A == E) continue; // 提前去重，减少内层循环
                for (int T = 1; T <= 9; T++) {
                    if (T == E || T == A) continue;
                    for (int P = 0; P <= 9; P++) {
                        if (P == E || P == A || P == T) continue;
                        for (int L = 0; L <= 9; L++) {
                            if (L == E || L == A || L == T || L == P) continue;
                            for (int H = 0; H <= 9; H++) {
                                if (H == E || H == A || H == T || H == P || H == L) continue;
                                
                                // 转换为数值
                                int eat = E * 100 + A * 10 + T;
                                int that = T * 1000 + H * 100 + A * 10 + T;
                                int apple = A * 10000 + P * 1000 + P * 100 + L * 10 + E;
                                
                                // 判断等式是否成立
                                if (eat + that == apple) {
                                    validSolutions++;
                                    System.out.printf("找到解：E=%d, A=%d, T=%d, P=%d, L=%d, H=%d\n", E, A, T, P, L, H);
                                    System.out.printf("验证：%d + %d = %d\n", eat, that, apple);
                                }
                            }
                        }
                    }
                }
            }
        }
        System.out.println("总符合条件的解数：" + validSolutions);
    }
}

优化说明 #

1. 修复循环结构：给每个for循环添加明确的范围控制，避免逻辑混乱。
2. 提前去重判断：在进入内层循环前就判断当前字母是否与外层重复，减少无效循环次数。
3. 加入首位非0限制：E、A、T从1开始循环，直接排除无效情况。
4. 完整实现算术等式：将字母转换为对应数值，判断EAT + THAT = APPLE是否成立，这是解题核心。
5. 清晰的输出：打印每个解的字母对应数字，同时输出数值验证结果，方便核对。

内容的提问来源于stack exchange，提问作者user19705717