Solving this cryptarithmetic program gives infinite results

Question

I am doing the EAT+ THAT= APPLE, where each letter represents a different number from 0-9. I need to find all combinations. I was wondering if there is a better way to write it, especially 'if' and 'for'

I've tried writing it like this but it gave me infinite results

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);

    }
}

Answer 1

When facing such problems it is of great importance to simplify the problem as much as possible.

Let's create a sub problem:

Assume that THAT must equal 8208. What are the values of each character?

You can notice that you are just solving an equation: T * 1000 + H * 100 + A * 10 + T = 8208 (The only solution is T = 8, H = 2, A = 0)

Back to our main problem:

Using the logic above simplify the main problem to an equation,

EAT + THAT= APPLE => EAT + THAT - APPLE = 0;

That in fact means:

E * 100 + A * 10 + T + T * 1000 + H * 100 + A * 10 + T - A * 10000 - P * 1000 - P * 1000 - L * 10 - E = 0

After simplification you get: -9980 * A - 1100 * P + 1002 * T + 100 * H + 99 * E - 10 * L = 0

As the values for each variable are very limited we are free to brute force the solution.

public class MyClass {
   public static int[] calc(){
      for(int A = 0; A < 10; A++){
          for(int P = 0; P < 10; P++){
              for(int T = 0; T < 10; T++){
                  for(int H = 0; H < 10; H++){
                      for(int E = 0; E < 10; E++){
                          for(int L = 0; L < 10; L++){
                              if(A!=P && A != T && A != H && A != E && A != L && P != T && P != H && P != E && P != L && T != H && T != E && T != L && H != E && H != L && E != L){
                                 //In your code you are lacking this statment, it checks whether values are indeed a solution of the equation
                                 if(-9980 * A - 1100 * P + 1002 * T + 100 * H + 99 * E - 10 * L == 0){
                                     int[] outArr = {A, P, T, H, E, L};
                                     return outArr;
                                 }
                              }
                          }
                      }
                  }
              }
           }
       }
       return null;
   }
    
   public static void main(String args[]) {
     int[] answer = calc();
     System.out.println("A" + answer[0] + " P" + answer[1] + " P" + answer[1] + " L" + answer[5] + " E" + answer[4]);
   }
}

If you don't want your if statement to be this massive, you can always create an array of size 10 filled with zeroes and for each variable (let's call it i) increase the value for the given index with array[i]++;, if at any point at any index array[x] > 1 you will know that values repeat.

There are ways of optimizing how the script works, by acknowledging the relations between digits (for example you can observe that A can only equal either 0 or 1, whereas 0 leads up to a contradictory equation, so A must equal 1 and so on and so forth until you find the exact value for each digit just by using logic), but in the end you will end up with purely mathematical solution and I don't think that's what you want to end up with.

Answer 2

**Second Version of Code**

public class EatingApple {
 ArrayList<Permutation>  eat = new ArrayList();
static      ArrayList<Permutation> that = new ArrayList();
static     ArrayList<Permutation> apples = new ArrayList();
      
    public static void main(String[] args) throws IOException {
      EatingApple apples  = new EatingApple();
        apples.makePermutation();
        apples.searchAppleEqualsSum();
        
        
         
        }

  public void searchAppleEqualsSum() 
 {
     for(Permutation eatP : eat)
     {
         int E_eat = (Integer) eatP.getCharacterValue("E");
         int A_eat = (Integer) eatP.getCharacterValue("A");
         int T_eat = (Integer) eatP.getCharacterValue("T");
         for(Permutation thatP : that)
         {
               int T_that = (Integer) thatP.getCharacterValue("T");
               int A_that = (Integer) thatP.getCharacterValue("A");
               if(T_eat == T_that&&A_eat ==A_that)
                    for(Permutation apple : apples)
                    {
                        int A_apple = (Integer) apple.getCharacterValue("A");
                        int E_apple = (Integer) apple.getCharacterValue("E");
                        if(A_apple==E_eat&&E_apple==E_eat)
                        {
                          int  eat_value = Integer.parseInt(eatP.permutationString);
                          int  that_value = Integer.parseInt(thatP.permutationString);
                          int  apple_value = Integer.parseInt(apple.permutationString);
                          if(apple_value == (that_value + eat_value)&&apple_value!=0)
                          {
                              System.out.println("EAT :" + eatP.permutationString);
                              System.out.println("THAT :" + thatP.permutationString);
                              System.out.println("Apple :" + apple.permutationString);
                              System.out.println(".............");
                          }
                        }
                    }
                        
               
                   
         }
           
     }
 }
    public void makePermutation()
    {
          for(int e=0;e<10;e++)
            for(int a=0;a<10;a++)
                for(int t=0;t<10;t++)
                {
                    String permutationString = ""+e+a+t;
                    int value = e+a+t;
                    Permutation eatCombination = new Permutation(permutationString,value);
                    eatCombination.addCharToMap("E", e);
                    eatCombination.addCharToMap("A", a);
                    eatCombination.addCharToMap("T", t);
                    eatCombination.permutationValue=value;
                    
                    
                    eat.add(eatCombination);
                    
                }
          
            for (int t = 0; t < 10; t++)
            for (int h = 0; h < 10; h++) 
                for(int a = 0; a < 10;a++)
                {
                    String permutationString = ""+t+h+a+t;
                    int value = t + h + a + t;
                    
                    Permutation thatCombination = new Permutation(permutationString,value);
                    
                    
                    thatCombination.addCharToMap("T", t);
                    thatCombination.addCharToMap("H", h);
                    thatCombination.addCharToMap("A", a);
                    thatCombination.permutationValue=value;
                    
                    that.add(thatCombination);
                    
                }
            for (int a = 0; a < 10; a++)
            for (int p = 0; p  < 10; p++) 
                for(int l = 0; l <10;l++)
                    for(int e = 0; e < 10; e++)
                
                {
                    String permutationString = ""+a+p+p+l+e;
                    int value = a+p+p+l+e;
                    
                    
                     Permutation appleCombination = new Permutation(permutationString,value);
                    
                     appleCombination.addCharToMap("A", a);
                    appleCombination.addCharToMap("P", p);
                    appleCombination.addCharToMap("L", l);
                    appleCombination.addCharToMap("E", e);
                   
                    appleCombination.permutationValue=value;
                    
                    apples.add(appleCombination);
                  
                    
                }
        
        
    }
   class Permutation
  {
      String permutationString="";
      int permutationValue =0;
       HashMap wordMap;

        public int getPermuttionValue() {
            return permutationValue;
        }
    Permutation(String pString, int pValue)
    {
        this.wordMap = new HashMap();
        this.permutationString=pString;
        this.permutationValue=pValue;
    }
    public int getCharacterValue(String character)
    {
        if(wordMap.get(character)==null)
            return -1;
        return (Integer) wordMap.get(character);
                
            
    }
    public  void  addCharToMap(String character, int value)
    {
        
            wordMap.put(character, value);
    }
   

  
  }
}