Algorithmus für Permutation für ein Mathematisches Problem

import java.util.*;

public class Test1 {

    // Die Aufgabe ist, aus den Zahlen 9988776655443322 sollen 
    // zwei beliebige 8 Stellige Zahlen erstellt werden, Zahl_A und Zahl_B.
    // Gefragt ist nach der Kombination von Zahl_A und Zahl_B bei der die Rechnung: 
    // (Zahl_A) - (2 x (Zahl_B)) das Ergebnis der kleinste Betrag ist.
    // 98872655  - (2 * 49436327) = 1

    public static void main(String args) {
        char tmp;
        int diff = 99999999;
        
        for (int i = 49438833; i>= 22334455; i--) {
            if (i%10 == 0 || i%10 == 1) {
                continue;
            } else {
                for (int j = 98877665; j >= 44668910; j--) {
                    if (j%10 == 0 || j%10 == 1) {
                        continue;
                    } else {
                        tmp = (String.valueOf(i) + String.valueOf(j)).toCharArray();
                    	
                        Arrays.sort(tmp);
                    	
                        if (String.valueOf(tmp).equals("2233445566778899")) {  
                            if (j - 2 * i >= 0 && j - 2 * i <= diff) {
                        	     diff = j - 2 * i;
	    		     System.out.println("Zahl A: " + String.valueOf(j));  
	    		     System.out.println("Zahl B: " + String.valueOf(i));  
	    		     System.out.println("Betrag: " + String.valueOf(j - 2 * i));  
                            }
                        }
                    }
                }
            }
        }
    }
}

public class Test1 {

    // Die Aufgabe ist, aus den Zahlen 9988776655443322 sollen zwei beliebige 8 Stellige Zahlen erstellt werden, Zahl_A und Zahl_B.
    // Gefragt ist nach der Kombination von Zahl_A und Zahl_B bei der die Rechnung: 
    // (Zahl_A) - (2 x (Zahl_B)) das Ergebnis der kleinste Betrag ist.
	// 98872655  - (2 * 49436327) = 1

    public static void main(String args) {
        char tmp;
        int diff = 99999999;
        
        for (int i = 49438833; i>=22334455; i--) {
 //       	System.out.println(i);
        	
            if (i%10 == 0 || i%10 == 1) {
                continue;
            } else {
                for (int j = 98877665; j >= 2 * i; j--) {
                    if (j%10 == 0 || j%10 == 1) {
                        continue;
                    } else {
                    	tmp = (String.valueOf(i) + String.valueOf(j)).toCharArray();
                    	
                    	Arrays.sort(tmp);
                    	
                    	if (String.valueOf(tmp).equals("2233445566778899")) {  
                    		if (j - 2 * i <= diff) {
                        		diff = j - 2 * i;
                        		j = 2 * i + diff;
	    		                System.out.println("Zahl A: " + String.valueOf(j));  
	    		                System.out.println("Zahl B: " + String.valueOf(i));  
	    		                System.out.println("Betrag: " + String.valueOf(j - 2 * i));  
                    		}
                    	}
                    }
                }
            }
        }
    }
}

import java.util.*;

public class Aufgabe {

    // Die Aufgabe ist, aus der Zahlenmenge 9988776655443322 sollen zwei beliebige
    // 8 Stellige Zahlen erstellt werden, Zahl_A und Zahl_B.
    // Gesucht werden die Kombinationen aus Zahl_A und Zahl_B bei der die Rechnung:
    // (Zahl_A) - (2 x (Zahl_B)) als Ergebnis den kleinsten Betrag liefern.
    // Überlegungen:
    // max auf 98877665 gesetzt, da 99887766/2 = 49943883 bereits 4 mal die Zahl 9 enthält
    // zahl_a und zahl_b können nicht auf 0 oder 1 enden
    // zahl_a muss mindestens doppelt so groß wie zahl_b sein

    public static void main(String args) {
        char tmp;
        int  max = 98877665, min = 22334455, diff = 99999999, zahl_a;

        for (int zahl_b = max / 2; zahl_b >= min; zahl_b--) {
            // zahl_b kann nicht auf 0 oder 1 enden
            if (zahl_b % 10 == 0 || zahl_b % 10 == 1) {
                continue;
            } else {
                // solange diff nicht geändert wurde zähle zahl_a von max runter 
                zahl_a = diff == 99999999 ? max : 2 * zahl_b + diff;

                // solange zahl_a größer 2 * zahl_b
                while (zahl_a >= 2 * zahl_b) {
                    // zahl_b kann nicht auf 0 oder 1 enden
                    if (zahl_a % 10 == 0 || zahl_a % 10 == 1) {
                        zahl_a--;
                        continue;
                    } else {
                        // bilde aus zahl_a und zahl_b eine String und teile ihn in ein Char-Array
                        tmp = (String.valueOf(zahl_b) + String.valueOf(zahl_a)).toCharArray();

                        // sortiere das Char-Array
                        Arrays.sort(tmp);

                        // wenn das sortierte Char-Array der Zahlenmenge entspricht 
                        // und der Betrag <= diff ist
                        if (String.valueOf(tmp).equals("2233445566778899")) {  
                            if (zahl_a - 2 * zahl_b <= diff) {
                                diff = zahl_a - 2 * zahl_b;
                                System.out.println("Betrag: " + String.valueOf(zahl_a - 2 * zahl_b)   
                                                              + "\tZahl_A: " + String.valueOf(zahl_a)   
                                                              + "\tZahl_B: " + String.valueOf(zahl_b));  
                            }
                        }
                        zahl_a--;
                    }
                }
            }
        }
    }
}