Ausprobieren beschleunigen?

F

Firephoenix

Gast
Hi Leute,
ich habe mal versucht das bekannte Zahlenrätsel (E+I+N+S=1, Z+W+E+I=2... bis 12) durch ausprobieren zu lösen.
Ich bin mir sicher, dass mein Code so funktioniert, er arbeitet ja nicht anders als eine dumme Brute-Force ;)

Allerdings läuft der Pc nach dem Aufruf und in der Konsole erscheint nichts - java läuft nur mit 13% durch :)
Ein Ende habe ich auch nach 15-20 Minuten nicht erreicht.

Gibt es eine Möglichkeit java beim starten (also "java Zahlenraetsel") irgendwie zu beschleunigen?
oder im Code selbst noch eine Möglichkeit Laufzeit zu sparen (z.b. indem ich die checkMethoden direkt in die If setze?)

Hier mal der Code:

Java:
public class Zahlenraetsel{
	public static int A,B,C,D,E,F,H,I,L,N,O,R,S,T,U,V,W,Z,zaehler;


	public static void main(String[] args){
		
		for(E=0; E<=1; E++){
			for(I=0; I<=1; I++){
				for(N=0; N<=1; N++){
					for(S=0; S<=1; S++){
						for(Z=0; Z<=2; Z++){
							for(W=0; W<=2; W++){
								for(D=0; D<=3; D++){
									for(R=0; R<=3; R++){
										for(V=0; V<=4; V++){
											for(F=0; F<=5; F++){
												for(U=0; U<=5; U++){
													for(U=0; U<=5; U++){
														for(C=0; C<=6; C++){
															for(H=0; H<=6; H++){
																for(B=0; B<=7; B++){
																	for(A=0; A<=8; A++){
																		for(T=0; T<=8; T++){
																			for(L=0; L<=11; L++){
																				for(O=0; O<=12; O++){
																					if(checkEins() && checkZwei() && checkDrei() && checkVier() && checkFuenf() && checkSechs() && checkSieben()
																						&& checkAcht() && checkNeun() && checkZehn() && checkElf() && checkZwoelf()){
																						zaehler++;
																						System.out.println("A ="+A+ " B= "+B+" C= "+C+" D= "+D+ " E= "+E);
																						System.out.println("F ="+F+ " H= "+H+" I= "+I+" L= "+L+ " N= "+N);
																						System.out.println("O ="+O+ " R= "+R+" S= "+S+" T= "+T+ " U= "+U);
																						System.out.println("V ="+V+ " W= "+W+" Z= "+Z);
																						System.out.println("---------------");
																					} 
																					else;
																				}			
																			}						
																		}
																	}					
																}
															}
														}
													}
												}
											}
										}
									}
								}
							}
						}
					}
				}
			}
		}
		
		System.out.println("Es wurden "+zaehler+" Loesungen gefunden");
	}
	
	

	
	
	//Bedingung eins überprüfen
	public static boolean checkEins(){
		if((E+I+N+S) == 1)
			return true;
		else
			return false;
	}
	
		//Bedingung zwei überprüfen
	public static boolean checkZwei(){
		if((Z+W+E+I) == 2)
			return true;
		else
			return false;
	}
		//Bedingung drei überprüfen
	public static boolean checkDrei(){
		if((D+R+E+I) == 3)
			return true;
		else
			return false;
	}
		//Bedingung vier überprüfen
	public static boolean checkVier(){
		if((V+I+E+R) == 4)
			return true;
		else
			return false;
	}
		//Bedingung fünf überprüfen
	public static boolean checkFuenf(){
		if((F+U+E+N+F) == 5)
			return true;
		else
			return false;
	}
		//Bedingung sechs überprüfen
	public static boolean checkSechs(){
		if((S+E+C+H+S) == 6)
			return true;
		else
			return false;
	}
		//Bedingung sieben überprüfen
	public static boolean checkSieben(){
		if((S+I+E+B+E+N) == 7)
			return true;
		else
			return false;
	}
		//Bedingung acht überprüfen
	public static boolean checkAcht(){
		if((A+C+H+T) == 8)
			return true;
		else
			return false;
	}
		//Bedingung neun überprüfen
	public static boolean checkNeun(){
		if((N+E+U+N) == 9)
			return true;
		else
			return false;
	}
		//Bedingung zehn überprüfen
	public static boolean checkZehn(){
		if((Z+E+H+N) == 10)
			return true;
		else
			return false;
	}
		//Bedingung elf überprüfen
	public static boolean checkElf(){
		if((E+L+F) == 11)
			return true;
		else
			return false;
	}
		//Bedingung zwölf überprüfen
	public static boolean checkZwoelf(){
		if((Z+W+O+E+L+F) == 12)
			return true;
		else
			return false;
	}
	
}

Ich hab die Methoden jetzt eher zu erklärzwecken Verwendet, da ich jemand anderem Java per VPN erkläre - und das kam halt dabei raus ;) die Logikabfragen zusammenzufassen ist aber kein großes Thema. Andere Ideen wären aber auf alle Fälle hilfreich.

Danke für Antworten
Gruß Firephoenix
 

faetzminator

Gesperrter Benutzer
Wenn die Zahlen nur positiv sein können, heisst dass, dass jede der vorkommenden Ziffern nie grösser als die Summe sein kann. So können die Ziffern [c]e[/c], [c]i[/c], [c]n[/c] und [c]s[/c] (kleingeschrieben, da nicht finale Variablen!) jeweils nur [c]0[/c] oder [c]1[/c] erhalten.
 
F

Firephoenix

Gast
Ich denke das habe ich hiermit doch berücksichtigt oder:
Java:
        for(E=0; E<=1; E++){
            for(I=0; I<=1; I++){
                for(N=0; N<=1; N++){
                    for(S=0; S<=1; S++){

E kann doch nie größer als Eins werden, sobald e i n oder s größer als 1 sind springt Java ja aus den Schleifen.

Gruß
 

XHelp

Top Contributor
Meiner Meinung nach sind es etwas zu viele Schleifen...
Wenn du die Summe 1 Suchst, dann brauchst du ja die 2 nicht zu betrachten... aber da bei dir alles verschachtelt ist, sieht es auf anhieb nicht richtig aus.

Außerdem kannst du das ganze auch Rückwärts machen... du hast z.B. die "2" und brauchst jetzt 4 Zahlen, die in der Summe 1 ergeben:
0,0,0,2... dann sämtliche Kombinationen davon, z.b. 0,2,0,0 etc
0,0,1,1... dann sämtliche Kombinationen davon...
Dann bist du auch schon fertig.

P.S. an diesem Code würde ich dir raten keinem Java erklären zu wollen...
 
Zuletzt bearbeitet:

faetzminator

Gesperrter Benutzer
Ach so, ja. Tschuldigung, hab ich überlesen ;)
Nunja, ich denke, es lässt sich sicher jeweils mathematisch noch weiter einschränken. Ich würde eine Datenklasse verwenden, welche das Min, Max und so speichert. So könnte man das min noch einschränken (min ist immer zahl - [Summe von max von allen anderen Ziffern]).
Das initiale Max der "Digits" könnte man z.B. so erstellen:
Java:
public static Map<Character, Digit> createDigits(String... numbers) {
    Map<Character, Digit> digits = new HashMap<Character, Digit>();
    for (int i = 0; i < numbers.length; i++) {
        for (char c : numbers[i].toCharArray()) {
            if (!digits.containsKey(c)) {
                digits.put(c, new Digit());
            }
            Digit digit = digits.get(c);
            digit.setMax(Math.min(digit.getMax(), i + 1));
        }
    }
    return digits;
}
[c]createDigits("EINS", "ZWEI", "DREI", ...);[/c]
 

Hansdampf

Bekanntes Mitglied
Du loopst zweimal über 'U', deshalb hast du eine Endlosschleife.
Die println würde ich nur zum Debuggen drin lassen, sonst wird die Berechnung ca. 2 Wochen dauern. Daher wahrscheinlich auch die geringe Auslastung (die Konsole kommt mit den println nicht nach)

edit: das mit der Konsole und den println war Quatsch (wird ja nur bei einem Treffer ausgegeben), wahrscheinlich hast du 8 Kerne, deshalb 13%
 
Zuletzt bearbeitet:
F

Firephoenix

Gast
Nur zur erklärung warum ich alle geschachtelt habe:

Ich wollte das ganze auf einen gewissen Zahlenbereich testen, im eigentlichen Rätsel kann man allerdings für jede Zahl jeden Wert nehmen (auch negative), so dass e z.B. auch -10 sein kann und i z.B. auch 10

Da ich das ganze allerdings erstmal vortesten will habe ich diese Beschränkungen gesetzt.
Eigentlich müsste man jede Schleife z.B. bei -10 anfangen lassen und bis z.B. 20 Rechnen lassen (was sich natürlich nicht gerade positiv auf die Rechenzeit ausübt.

Ich will hier auch bewusst einen Algorythmus durch ausprobieren anwenden und keinen durch Regeln (da kann ich ja schon fast Prolog benutzen :) )

Gruß Firephoenix
 

XHelp

Top Contributor
Dann verstehe ich nicht, was du beschleunigen willst. BruteForce dauert nun mal...
Du kannst höhstens das Ding parallelisieren, so dass dein ganzer i7 arbeitet.
 
F

Firephoenix

Gast
Das Bruteforce sehr rechenintensiv ist ist mir schon bewusst ;)
Ich wollte nur wissen ob jemand möglichkeiten sieht den Code an sich zu verbessern (es kann ja sein, dass ich irgendwo Abfragen drin habe die man einfacher hätte gestalten können).
Wenn ein eine Möglichkeit gibt den Code über alle 8 Kerne ausführen zu lassen wäre die natürlich auch sehr interessant.

Ich glaube mir ist aber gerade nochwas eingefallen ^^ zumindest wie ich ein paar Schleifendurchläufe sparen kann - ich setz mich morgen da nochmal dran und setze ein paar weitere Abfragen in die einzelnen Schleifen, den Code stell ich dann hier rein.
Gruß Firephoenix
 

XHelp

Top Contributor
Naja... du suchst die Kombinationen für Summe 1... und die Kombinationen für Summe 2... und die Kombinationen für Summe 3...
eine Möglichkeit der Parallelisierung sollte ins Auge springen ;)

Und was Codeverbesserungen angeht: ich verstehe immer noch nicht, warum ALLE schleifen (sowohl für Summe 1, als auch für Summe 10) geschlachtelt sind.
 
F

Firephoenix

Gast
Ich denke ich kanns noch etwas aufstricken aber ich bin mir nicht Sicher wieviel ich bei der Schachtelung sparen kann.

Als beispiel nur mal das "e":

Das "e" kommt in allen Zahlen von 1-12 außer in der 8 vor.
Somit könnte ich z.B. das "a" und das "t" rausnehmen. "c" und "h" sind z.B. in sechs wieder mit "e" verbunden.

Ich kann aber über Abfragen in der Schachtelung eingrenzen, dass Zahlen gewählt werden die nicht funktionieren - Stichwort continue.
So bin ich damals auch an Give+More=Money herangegangen und habe da etwas Durchlaufzeit gespart.
Danke für die Hilfe und
Gruß Firephoenix
 
G

Gast2

Gast
Du kannst dir für jedes Einzelproblem (E+I+N+S, Z+W+E+I, etc.) erstmal jeweils unabhängig alle möglichen gültigen konfigurationen berechnen.
Wenn du damit durch bist berechnest du einfach den Schnitt der, in diesem Fall 12, Einzellösungen und hast deine Gesamtlösung.
 
F

Firephoenix

Gast
Das war auch zuerst ein Ansatz von mir.
Nur da:
-Zahlen doppelt vorkommen dürfen
-Zahlen sowohl positiv als auch negativ sein können
-Zahlen zwar nur ganzzahlig aber erstmal unbeschränkt im Wertebereich sind

gibt das alleine für das
E+I+N+S schon unendliche Kombinationsmöglichkeiten.
Erst durch die verschachtelung der Abfragen grenze ich ja die Lösungsmenge ein.
Gruß
 

XHelp

Top Contributor
Sofern min und max begrenz sind (z.B. von -10...10), dann gibt es auch eine endliche Menge an Kombinationsmöglichkeiten.
Falls es keine Grenze gibt, dann macht die Aufgabe keinen Sinn, denn dann gibt es auch unendlich viele Möglichkeiten, die du unendlich lange ausrechnen wirst.
Da du auch ALLE Kombinationen durchgehen willst, ist es dir auch ziemlich egal, ob die Zahlen doppelt vorkommen dürfen, oder nicht... genau wie mit postiv und negativ.

Generell sind es nicht die Zahlenordnungen, wo der Rechner lange brauchen sollte. Meine mit sicherheit noch optimierbare Lösung braucht für alle Kombinationen von 1..12 bei positiven Zahlen 198 ms.
 
F

Firephoenix

Gast
Hi Leute,
erstmal danke für die vielen Hilfsbeiträge.

Ich hab das ganze nochmal verbessert und umgebaut (meinen ersten Code hab ich abends mal durchlaufen lassen -> führt zu keiner Lösung bzw findet keine).

Hier die korrigierte Form:

Java:
public class Zahlenraetsel{
    //Speicher für das ausprobieren
    public static int a,b,c,d,e,f,h,i,l,n,o,r,s,t,u,v,w,z,zaehler;
    //Speicher für die gefundene Lösung (vorbelegt um kleiner-Abfrage zu ermöglichen - Lösung muss auf alle Fälle kleiner sein)
    public static int a1=10,b1=10,c1=10,d1=10,e1=10,f1=10,h1=10,i1=10,l1=10,n1=10,o1=10,r1=10,s1=10,t1=10,u1=10,v1=10,w1=10,z1=10;
    
    

    public static void main(String[] args){
        
        int un = Integer.valueOf(args[0]); //unterer Wertebereich
        int ob = Integer.valueOf(args[1]); //oberer Wertebereich
        
        for(e=un; e<=ob; e++){
            for(i=un; i<=ob; i++){
                for(n=un; n<=ob; n++){
                    for(s=un; s<=ob; s++){
                        if(!checkEins()) continue;
                        else
                        for(z=un; z<=ob; z++){
                            for(w=un; w<=ob; w++){
                                if(!checkZwei()) continue;
                                else
                                for(d=un; d<=ob; d++){
                                    for(r=un; r<=ob; r++){
                                        if(!checkDrei()) continue;
                                        else
                                        for(v=un; v<=ob; v++){
                                            if(!checkVier()) continue;
                                            else
                                            for(f=un; f<=ob; f++){
                                                for(u=un; u<=ob; u++){
                                                    if(!checkFuenf()) continue;
                                                    else
                                                    for(c=un; c<=ob; c++){
                                                        for(h=un; h<=ob; h++){
                                                            if(!checkSechs()) continue;
                                                            else
                                                            for(b=un; b<=ob; b++){
                                                                if(!checkSieben()) continue;
                                                                else
                                                                for(a=un; a<=ob; a++){
                                                                    for(t=un; t<=ob; t++){
                                                                        if(!checkAcht()) continue;
                                                                        else
                                                                        for(l=un; l<=ob; l++){
                                                                            if(!checkElf()) continue;
                                                                            else
                                                                            for(o=un; o<=ob; o++){
                                                                                //wenn eine Lösung gefunden wurde wird sie gezählt und mit der letzten verglichen
                                                                                if(checkEins() && checkZwei() && checkDrei() && checkVier() && checkFuenf() && checkSechs() && checkSieben()
                                                                                    && checkAcht() && checkNeun() && checkZehn() && checkElf() && checkZwoelf()){
                                                                                    zaehler++;
                                                                                    checkKleineLoesung();
                                                                                    
                                                                                } 
                                                                                else;
                                                                            }            
                                                                        }                        
                                                                    }
                                                                }                    
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
        //Endgültige Lösung ausgeben
        System.out.println("a ="+a1+ " b= "+b1+" c= "+c1+" d= "+d1+ " e= "+e1);
        System.out.println("f ="+f1+ " h= "+h1+" i= "+i1+" l= "+l1+ " n= "+n1);
        System.out.println("o ="+o1+ " r= "+r1+" s= "+s1+" t= "+t1+ " u= "+u1);
        System.out.println("v ="+v1+ " w= "+w1+" z= "+z1);
        System.out.println("---------------");
        System.out.println("Addierter Betrag aller Zahlen: "+(Math.abs(a1)+Math.abs(b1)+Math.abs(c1)+Math.abs(d1)+Math.abs(e1)+Math.abs(f1)+Math.abs(h1)+Math.abs(i1)+Math.abs(l1)+Math.abs(n1)+
                            Math.abs(o1)+Math.abs(r1)+Math.abs(s1)+Math.abs(t1)+Math.abs(u1)+Math.abs(v1)+Math.abs(w1)+Math.abs(z1)));
        System.out.println("Es wurden "+(zaehler-1)+" andere Loesungen gefunden");
    }
    
    //suchen ob die Summe der Beträge der Zahlen der akt. Lösung kleiner ist als die der vorigen Lösung.
    //falls das zutrifft wird die gefundene Lösung in die aktuelle gespeichert
    public static void checkKleineLoesung(){
            if ((Math.abs(a)+Math.abs(b)+Math.abs(c)+Math.abs(d)+Math.abs(e)+Math.abs(f)+Math.abs(h)+Math.abs(i)+Math.abs(l)+Math.abs(n)+
            Math.abs(o)+Math.abs(r)+Math.abs(s)+Math.abs(t)+Math.abs(u)+Math.abs(v)+Math.abs(w)+Math.abs(z))<
            (Math.abs(a1)+Math.abs(b1)+Math.abs(c1)+Math.abs(d1)+Math.abs(e1)+Math.abs(f1)+Math.abs(h1)+Math.abs(i1)+Math.abs(l1)+Math.abs(n1)+
            Math.abs(o1)+Math.abs(r1)+Math.abs(s1)+Math.abs(t1)+Math.abs(u1)+Math.abs(v1)+Math.abs(w1)+Math.abs(z1))){
                a1=a;
                b1=b;
                c1=c;
                d1=d;
                e1=e;
                f1=f;
                h1=h;
                i1=i;
                l1=l;
                n1=n;
                o1=o;
                r1=r;
                s1=s;
                t1=t;
                u1=u;
                v1=v;
                w1=w;
                z1=z;
            }
    }
    
    
    //Bedingung eins überprüfen
    public static boolean checkEins(){
        if((e+i+n+s) == 1)
            return true;
        else
            return false;
    }
    
        //Bedingung zwei überprüfen
    public static boolean checkZwei(){
        if((z+w+e+i) == 2)
            return true;
        else
            return false;
    }
        //Bedingung drei überprüfen
    public static boolean checkDrei(){
        if((d+r+e+i) == 3)
            return true;
        else
            return false;
    }
        //Bedingung vier überprüfen
    public static boolean checkVier(){
        if((v+i+e+r) == 4)
            return true;
        else
            return false;
    }
        //Bedingung fünf überprüfen
    public static boolean checkFuenf(){
        if((f+u+e+n+f) == 5)
            return true;
        else
            return false;
    }
        //Bedingung sechs überprüfen
    public static boolean checkSechs(){
        if((s+e+c+h+s) == 6)
            return true;
        else
            return false;
    }
        //Bedingung sieben überprüfen
    public static boolean checkSieben(){
        if((s+i+e+b+e+n) == 7)
            return true;
        else
            return false;
    }
        //Bedingung acht überprüfen
    public static boolean checkAcht(){
        if((a+c+h+t) == 8)
            return true;
        else
            return false;
    }
        //Bedingung neun überprüfen
    public static boolean checkNeun(){
        if((n+e+u+n) == 9)
            return true;
        else
            return false;
    }
        //Bedingung zehn überprüfen
    public static boolean checkZehn(){
        if((z+e+h+n) == 10)
            return true;
        else
            return false;
    }
        //Bedingung elf überprüfen
    public static boolean checkElf(){
        if((e+l+f) == 11)
            return true;
        else
            return false;
    }
        //Bedingung zwölf überprüfen
    public static boolean checkZwoelf(){
        if((z+w+o+e+l+f) == 12)
            return true;
        else
            return false;
    }
    
}

Mit den Abfragen in den Schleifen verhindere ich, dass das ganze weiterläuft wenn schon die 1. Bedingungen nicht erfüllt sind (daher habe ich die Buchstaben auch nach diesem System geschachtelt).

Die eigentliche Lösungsbedingung sieht so aus, dass die Summe der Beträge der Variablen möglichst klein sein muss. Ich habe also noch eine Funktion geschrieben, die mir jeweils die gefundene mit der gespeicherten Lösung vergleicht.

Falls ihr das testen wollt: der Aufruf mit -5 7 liefert schon gute 27.000 Lösungen, -5 8 liefert fast 68.000 :)

Mir fällt aber keine gute Struktur ein das ganze in Threads zu unterteilen, da die Zahlen voneinander abhängen kann ich ja nicht einen Thread von -20 bis 0 und einen von 0 bis 20 suchen lassen.

Gruß Firephoenix
 
Zuletzt bearbeitet von einem Moderator:

XHelp

Top Contributor
Du gehst das Problem völlig falsch an, deswegen fällt dir auch keine Struktur ein...
Die Suchen von EINS und ZWEI haben absolut nichts gemeinsam und sollten somit auch nicht verschachtelt werden.

P.S. Irgendwie sind da etwas zu wenig Lösungen.
 
F

Firephoenix

Gast
Einen Fehler hab ich gerade noch rausgeworfen, jetzt klappts.

Aber nochmal zur Erklärung:

Gesucht sind z.B. e,i,n,s,z,w (reihenfolge kann gerne auch alphabetisch sein).

Für diese müssen folgende Bedingungen erfüllt sein:

e+i+n+s=1
z+w+e+i=2

das "e" in "zwei" ist das selbe "e" wie in "eins" Damit macht es also aus meiner sicht Sinn alle Variablen in abhängigkeit zu testen und an die jeweils letzte der Zahl (bsp. das "s" in "eins") die Bedinung zu hängen, dass nach dem zugehörigen Durchlauf auch jeweils die passende Bedinung erfüllt ist.

Es macht ja schließlich keinen Sinn "e", "i" und "n" zu setzen und nach "s" weiterzumachen obwohl man schon weiß, dass Bedingung "eins" nicht erfüllt ist. Daher die continue-Abfragen in den Schleifen.

Wenn ich dann eine Lösung gefunden habe die für alle Zahlen passt überprüfe ich, ob ich nicht schon eine gefunden habe die vom Betrag her niedriger ist, falls meine aktuelle gefundene besser ist überschreibe ich die alte.
Habe ich alle Möglichkeiten durch (was durch die continue nach dem finden der letzten Möglichkeit schneller geht) wird einfach die optimale ausgegeben.

Für andere Lösungsansätze bin ich natürlich dankbar (ich will hier auch keinen Quellcode).
Aber einfach nur zu schreiben, dass ich das Problem falsch angehe hilft mir leider wenig :)

Gruß Firephoenix
 

XHelp

Top Contributor
Ah... nun macht das ganze etwas mehr Sinn. Ich ging davon aus, dass EINS=1 und ZWEI=2 nichts miteinander zu tun haben.
So könntest du dennoch das ganze parallelisieren, in dem du zuerst alle Lösungen für EINS findest, alle für ZWEI etc und dann gemeinsame Lösungen filterst.
 

Marco13

Top Contributor
Hm. Mich irritiert, dass in diesem Thread so wenige :autsch: - Smileys vorkommen. Also, vielleicht funktioniert das Programm, OK. Vielleicht bist du Anfänger, OK. Das ändert aber alles nichts daran, dass dass Programm in dieser Form überlster Trash ist :autsch: Wenn nun die Aufgabe kommt, statt "eins" mit "drei" zu rechnen, bist du gef*. Ob man da nun mit den "üblichen" Lösungsstrategient für Cryptarithmetic rangeht (z.B. den AC-3 aus Artificial Intelligence: A Modern Approach ) oder wirklich alles durchprobieren will, ist egal: SO sollte man es nicht machen.
 
F

Firephoenix

Gast
Hi Marco,
wenn ich mich nicht verlesen habe sind wir doch im Anfänger-Bereich oder?

Daraus könnte man jetzt schließen, dass ich selbst noch dabei bin Java zu lernen und nach und nach Versuche mir Grundlagen anzueignen.

Und um mich zu verbessern nehme ich mir nunmal gerne kleine Aufgaben und versuche diese nach meinem Kenntnisstand zu lösen und ihn gleichzeitig damit zu erweitern.

Wie genau man Probleme mit dem PC löst und welche Strategien dabei gut sind kommt bei mir sicherlich in den nächsten Jahren noch im Studium (BsC Informatik - seit diesem WS).

Da ich aber nur ein einfaches Programm haben wollte, das mein Problem löst und mir ab und an auch mal gerne Kritik in diesem Forum abhole denke ich, dass das Thema soweit erledigt ist - das Programm löst ja das Problem bis zu einem gewissen Grad.
Die Verbesserung über das Multithreading die XHelp vorgeschlagen hat realisiere ich bei Gelegenheit, ansonsten denke ich ist das hier dann auch erledigt.

Immerhin will ich hier ja keine Rätselfrage über Lösungsstrategien für Mathematikprobleme eröffnen sondern nur simpel nachfragen wie ich meinen Ansatz noch verbessern kann.

Danke für die Antworten und Gruß
Firephoenix
 
G

Gast2

Gast
Ich hab mal auf die schnelle nen bissl was zusammengeschrieben.
Gleich vorneweg: Der code ist nicht besonders schön, nicht sonderlich kommentiert und an manchen stellen vllt nicht sehr effizient, hab aber keine Lust den noch weiter zu optimieren :)

Kurze Erklärung zum Code:
Zuerst werden alle einzelprobleme gelöst (E+I+N+S, Z+W+E+I, etc.). Dies könnte ohne weiteres auf verschiedenen Kernen laufen (keine synchronisation notwendig).
Lässt man diese Probleme sequenziell ablaufen kann man den Code auch noch optimieren indem man dem nächste Problem die bisherige Lösung zuschiebt um schonmal Buchstabenwerte eingrenzen zu können.
Wenn dann alle Einzelprobleme gelöst sind werden diese zu einer Lösung zusammengefügt. Am Ende gibts dann ne Liste mit allen (ohne gewähr ;) ) möglichen Kombinationen um das Rätsel zu lösen.

Ausgabe bei MIN=0, MAX=10 und den Einzelproblemen EINS bis NEUN:
Code:
run:
execute tasks
execution(1) time: 1 ms - solutions found: 4
execution(2) time: 0 ms - solutions found: 10
execution(3) time: 2 ms - solutions found: 20
execution(4) time: 3 ms - solutions found: 35
execution(5) time: 1 ms - solutions found: 12
execution(6) time: 6 ms - solutions found: 50
execution(7) time: 14 ms - solutions found: 200
execution(8) time: 17 ms - solutions found: 165
execution(9) time: 2 ms - solutions found: 30
start merging
merging complete, time: 262ms
Solutions (2466 solutions found):
[f=0, d=0, e=0, b=6, c=0, a=0, n=0, h=4, i=0, w=2, v=1, u=9, ü=5, t=4, s=1, r=3, z=0, ]
[f=0, d=0, e=0, b=6, c=0, a=1, n=0, h=4, i=0, w=2, v=1, u=9, ü=5, t=3, s=1, r=3, z=0, ]
[f=0, d=0, e=0, b=6, c=0, a=2, n=0, h=4, i=0, w=2, v=1, u=9, ü=5, t=2, s=1, r=3, z=0, ]
[f=0, d=0, e=0, b=6, c=0, a=3, n=0, h=4, i=0, w=2, v=1, u=9, ü=5, t=1, s=1, r=3, z=0, ]
[f=0, d=0, e=0, b=6, c=0, a=4, n=0, h=4, i=0, w=2, v=1, u=9, ü=5, t=0, s=1, r=3, z=0, ]
[f=0, d=0, e=0, b=6, c=1, a=0, n=0, h=3, i=0, w=2, v=1, u=9, ü=5, t=4, s=1, r=3, z=0, ]
[f=0, d=0, e=0, b=6, c=1, a=1, n=0, h=3, i=0, w=2, v=1, u=9, ü=5, t=3, s=1, r=3, z=0, ]
[f=0, d=0, e=0, b=6, c=1, a=2, n=0, h=3, i=0, w=2, v=1, u=9, ü=5, t=2, s=1, r=3, z=0, ]
[f=0, d=0, e=0, b=6, c=1, a=3, n=0, h=3, i=0, w=2, v=1, u=9, ü=5, t=1, s=1, r=3, z=0, ]
[f=0, d=0, e=0, b=6, c=1, a=4, n=0, h=3, i=0, w=2, v=1, u=9, ü=5, t=0, s=1, r=3, z=0, ]
[f=0, d=0, e=0, b=6, c=2, a=0, n=0, h=2, i=0, w=2, v=1, u=9, ü=5, t=4, s=1, r=3, z=0, ]
[f=0, d=0, e=0, b=6, c=2, a=1, n=0, h=2, i=0, w=2, v=1, u=9, ü=5, t=3, s=1, r=3, z=0, ]
[f=0, d=0, e=0, b=6, c=2, a=2, n=0, h=2, i=0, w=2, v=1, u=9, ü=5, t=2, s=1, r=3, z=0, ]
[f=0, d=0, e=0, b=6, c=2, a=3, n=0, h=2, i=0, w=2, v=1, u=9, ü=5, t=1, s=1, r=3, z=0, ]
[f=0, d=0, e=0, b=6, c=2, a=4, n=0, h=2, i=0, w=2, v=1, u=9, ü=5, t=0, s=1, r=3, z=0, ]
[f=0, d=0, e=0, b=6, c=3, a=0, n=0, h=1, i=0, w=2, v=1, u=9, ü=5, t=4, s=1, r=3, z=0, ]
[f=0, d=0, e=0, b=6, c=3, a=1, n=0, h=1, i=0, w=2, v=1, u=9, ü=5, t=3, s=1, r=3, z=0, ]
[f=0, d=0, e=0, b=6, c=3, a=2, n=0, h=1, i=0, w=2, v=1, u=9, ü=5, t=2, s=1, r=3, z=0, ]
[f=0, d=0, e=0, b=6, c=3, a=3, n=0, h=1, i=0, w=2, v=1, u=9, ü=5, t=1, s=1, r=3, z=0, ]
[f=0, d=0, e=0, b=6, c=3, a=4, n=0, h=1, i=0, w=2, v=1, u=9, ü=5, t=0, s=1, r=3, z=0, ]
[f=0, d=0, e=0, b=6, c=4, a=0, n=0, h=0, i=0, w=2, v=1, u=9, ü=5, t=4, s=1, r=3, z=0, ]
[f=0, d=0, e=0, b=6, c=4, a=1, n=0, h=0, i=0, w=2, v=1, u=9, ü=5, t=3, s=1, r=3, z=0, ]
[f=0, d=0, e=0, b=6, c=4, a=2, n=0, h=0, i=0, w=2, v=1, u=9, ü=5, t=2, s=1, r=3, z=0, ]
[f=0, d=0, e=0, b=6, c=4, a=3, n=0, h=0, i=0, w=2, v=1, u=9, ü=5, t=1, s=1, r=3, z=0, ]
[f=0, d=0, e=0, b=6, c=4, a=4, n=0, h=0, i=0, w=2, v=1, u=9, ü=5, t=0, s=1, r=3, z=0, ]
[f=1, d=0, e=0, b=6, c=0, a=0, n=0, h=4, i=0, w=2, v=1, u=9, ü=3, t=4, s=1, r=3, z=0, ]
[f=1, d=0, e=0, b=6, c=0, a=1, n=0, h=4, i=0, w=2, v=1, u=9, ü=3, t=3, s=1, r=3, z=0, ]
[f=1, d=0, e=0, b=6, c=0, a=2, n=0, h=4, i=0, w=2, v=1, u=9, ü=3, t=2, s=1, r=3, z=0, ]
[f=1, d=0, e=0, b=6, c=0, a=3, n=0, h=4, i=0, w=2, v=1, u=9, ü=3, t=1, s=1, r=3, z=0, ]
[f=1, d=0, e=0, b=6, c=0, a=4, n=0, h=4, i=0, w=2, v=1, u=9, ü=3, t=0, s=1, r=3, z=0, 
... zuviele Zeichen ...
[f=2, d=2, e=1, b=5, c=5, a=0, n=0, h=0, i=0, w=0, v=3, u=8, ü=1, t=3, s=0, r=0, z=1, ]
[f=2, d=2, e=1, b=5, c=5, a=1, n=0, h=0, i=0, w=0, v=3, u=8, ü=1, t=2, s=0, r=0, z=1, ]
[f=2, d=2, e=1, b=5, c=5, a=2, n=0, h=0, i=0, w=0, v=3, u=8, ü=1, t=1, s=0, r=0, z=1, ]
[f=2, d=2, e=1, b=5, c=5, a=3, n=0, h=0, i=0, w=0, v=3, u=8, ü=1, t=0, s=0, r=0, z=1, ]
ERSTELLEN ERFOLGREICH (Gesamtzeit: 0 Minuten 1 Sekunde)

Main:
Java:
public class Main {
    public static void main(String[] args) {
        RiddleSolver solver = new RiddleSolver();
        solver.solve();
    }
}

Riddle:
Java:
public class Riddle {
    private final int MIN;
    private final int MAX;

    private List<Character> chars = new ArrayList<Character>();
    private List<Character> uniqueChars = new ArrayList<Character>();
    private Map<Character, Integer> digits = new HashMap<Character, Integer>();
    private int sum;

    private Solution solution = new Solution();

    public Riddle(int min, int max, List<Character> chars, int sum) {
        this.MIN = min;
        this.MAX = max;
        this.chars = chars;
        this.sum = sum;

        // create uniqueChar list
        for (char c : chars) {
            if (!uniqueChars.contains(c)) {
                uniqueChars.add(c);
                digits.put(c, MIN);
            }
        }
    }

    public void solve() {
        long start = System.currentTimeMillis();
        calculatePossibleConfigurations(0);

        solution.setExceutionTime(System.currentTimeMillis() - start);
    }

    public Solution getSolution() {
        return solution;
    }

    private void calculatePossibleConfigurations(int index) {
        if (index == uniqueChars.size()) {
            // checkSum
            int digitSum = calcSum();
            if (digitSum == sum) {
                Map<Character, Integer> res = new HashMap<Character, Integer>();
                for (char c : uniqueChars) {
                    res.put(c, digits.get(c));
                }

                solution.add(res);
            }
            return;
        }

        for (int i = MIN; i <= MAX; i++) {
            digits.put(uniqueChars.get(index), i);
            int digitSum = calcSum();
            if (digitSum > sum) {
                break;
            }
            
            calculatePossibleConfigurations(index + 1);
        }

        // next try, reset digit value
        digits.put(uniqueChars.get(index), MIN);
    }

    private int calcSum() {
        int res = 0;

        for (char c : chars) {
            Integer val = digits.get(c);
            if (val != null) {
                res += val;
            }
        }

        return res;
    }

    public List<Character> getUniqueChars() {
        return uniqueChars;
    }
}

Java:
public class RiddleTask implements Callable<Riddle> {

    private Riddle riddle;

    public RiddleTask(Riddle riddle) {
        this.riddle = riddle;
    }

    public Riddle call() throws Exception {
        riddle.solve();
        
        return riddle;
    }
}

RiddleSolver:
Java:
public class RiddleSolver {

    private ExecutorService executor;
    private final int THREAD_COUNT = 5;
    private final int MIN = -5;
    private final int MAX = 10;

    // list containing the temporary resulst
    private List<Riddle> results;
    private List<Map<Character, Integer>> mergedResults;
    private Map<Character, Integer> digits;
    
    public RiddleSolver() {
        executor = Executors.newFixedThreadPool(THREAD_COUNT);
        results = new ArrayList<Riddle>();
        mergedResults = new ArrayList<Map<Character, Integer>>();
        digits = new HashMap<Character, Integer>();
    }

    public void solve() {
        List<Character> chars;
        List<Future<Riddle>> futures = new ArrayList<Future<Riddle>>();

        System.out.println("execute tasks");

        // init lists, eins
        chars = new ArrayList<Character>();
        chars.add('e');
        chars.add('i');
        chars.add('n');
        chars.add('s');
        futures.add(executor.submit(new RiddleTask(new Riddle(MIN, MAX, chars, 1))));

        // zwei
        chars = new ArrayList<Character>();
        chars.add('z');
        chars.add('w');
        chars.add('e');
        chars.add('i');
        futures.add(executor.submit(new RiddleTask(new Riddle(MIN, MAX, chars, 2))));

        // drei
        chars = new ArrayList<Character>();
        chars.add('d');
        chars.add('r');
        chars.add('e');
        chars.add('i');
        futures.add(executor.submit(new RiddleTask(new Riddle(MIN, MAX, chars, 3))));

        // vier
        chars = new ArrayList<Character>();
        chars.add('v');
        chars.add('i');
        chars.add('e');
        chars.add('r');
        futures.add(executor.submit(new RiddleTask(new Riddle(MIN, MAX, chars, 4))));

        // fuenf
        chars = new ArrayList<Character>();
        chars.add('f');
        chars.add('ü');
        chars.add('n');
        chars.add('f');
        futures.add(executor.submit(new RiddleTask(new Riddle(MIN, MAX, chars, 5))));

        // sechs
        chars = new ArrayList<Character>();
        chars.add('s');
        chars.add('e');
        chars.add('c');
        chars.add('h');
        chars.add('s');
        futures.add(executor.submit(new RiddleTask(new Riddle(MIN, MAX, chars, 6))));

        // sieben
        chars = new ArrayList<Character>();
        chars.add('s');
        chars.add('i');
        chars.add('e');
        chars.add('b');
        chars.add('e');
        chars.add('n');
        futures.add(executor.submit(new RiddleTask(new Riddle(MIN, MAX, chars, 7))));

        // acht
        chars = new ArrayList<Character>();
        chars.add('a');
        chars.add('c');
        chars.add('h');
        chars.add('t');
        futures.add(executor.submit(new RiddleTask(new Riddle(MIN, MAX, chars, 8))));

        // neun
        chars = new ArrayList<Character>();
        chars.add('n');
        chars.add('e');
        chars.add('u');
        chars.add('n');
        futures.add(executor.submit(new RiddleTask(new Riddle(MIN, MAX, chars, 9))));

        // get results
        try {
            int i = 0;
            for (Future<Riddle> future : futures) {
                Riddle riddle = future.get();
                results.add(riddle);
                System.out.println("execution(" + ++i + ") time: " + riddle.getSolution().getExceutionTime() + " ms - solutions found: " + riddle.getSolution().getSolutions().size());
            }

            // shutdown executor
            executor.shutdown();
        } catch (ExecutionException ex) {
            ex.printStackTrace();
        } catch (InterruptedException ex) {
            ex.printStackTrace();
        }

        /*
        Riddle r10 = results.get(9);
        System.out.println(Arrays.toString(r10.getUniqueChars().toArray()));
        System.out.println(r10.getSolution().getSolutions().size());
        for (Map<Character, Integer> solution : r10.getSolution().getSolutions()) {
            System.out.print("[");
            for (char c : solution.keySet()) {
                System.out.print(c + "=" + solution.get(c) + ", ");
            }
            System.out.println("]");
        }*/

        // merge results
        System.out.println("start merging");
        long start = System.currentTimeMillis();
        mergeResults(0);
        long duration = System.currentTimeMillis() - start;
        System.out.println("merging complete, time: " + duration + "ms");

        // output results
        System.out.println("Solutions (" + mergedResults.size() + " solutions found):");
        for (Map<Character, Integer> solution : mergedResults) {
            System.out.print("[");
            for (char c : solution.keySet()) {
                System.out.print(c + "=" + solution.get(c) + ", ");
            }
            System.out.println("]");
        }

    }

    /**
     * Rekursive function that merges the results of each riddle.
     * @param index riddle index
     * @return List a list of all possible Solutions for this riddle.
     */
    private void mergeResults(int index) {
        if (index == results.size()) {
            // a new overall solutions has been found, make a copy that will be stored in result list
            Map<Character, Integer> newSolution = new HashMap<Character, Integer>();
            for (char c : digits.keySet()) {
                newSolution.put(c, digits.get(c));
            }

            mergedResults.add(newSolution);
            return;
        }

        Riddle riddle = results.get(index);
        Solution solution = riddle.getSolution();

        // new character
        List<Character> newChars = new ArrayList<Character>();
        for (char c : riddle.getUniqueChars()) {
            if (!digits.containsKey(c)) {
                newChars.add(c);
            }
        }

        for (Map<Character, Integer> currentDigits : solution.getSolutions()) {
            if (canAppend(digits, currentDigits)) {
                mapDigits(currentDigits);
                mergeResults(index + 1);

                // remove char values of current riddle
                for (char c : newChars) {
                    digits.remove(c);
                }
            }
        }
    }

    /**
     * Checks whether a solution can be appended. A new solution can be appended if values of each character are equal.
     * @param solution map of current character values
     * @param digits the new values
     * @return true, if solution is still consistent
     */
    private boolean canAppend(Map<Character, Integer> solution, Map<Character, Integer> digits) {
        for (char c : digits.keySet()) {
            if (solution.containsKey(c)) {
                if (!solution.get(c).equals(digits.get(c))) {
                    return false;
                }
            }
        }
        return true;
    }

    private void mapDigits(Map<Character, Integer> digits) {
        for (Character c : digits.keySet()) {
            this.digits.put(c, digits.get(c));
        }
    }
}

Solution:
Java:
public class Solution {
    private List<Map<Character, Integer>> solutions;
    private long exceutionTime;

    public Solution() {
        solutions = new LinkedList<Map<Character, Integer>>();
    }

    public void add(Map<Character, Integer> solution) {
        solutions.add(solution);
    }

    public List<Map<Character, Integer>> getSolutions() {
        return solutions;
    }

    public void setExceutionTime(long exceutionTime) {
        this.exceutionTime = exceutionTime;
    }

    public long getExceutionTime() {
        return exceutionTime;
    }
}
 
Zuletzt bearbeitet von einem Moderator:

Marco13

Top Contributor
wenn ich mich nicht verlesen habe sind wir doch im Anfänger-Bereich oder?

Das und die anderen genannten Punkte hatte ich ja schon berücksichtigt. Mir leuchtet nur nicht ein warum du viel Zeit inverstieren willst (und andere viel Zeit investieren, um dir zu helfen) einen Ansatz zu verfolgen, der an sich einfach "falsch" ist.

Aber OK: Jetzt, wo es "fertig" ist, und "funktioniert", versuch' mal dir zu überlegen, wie man es "besser" mache könnte ;)

EDIT: Um das nochmal zu betonen: Durch das bisher geschriebene hast du ja nichts gelernt, was du nicht auch mit einer Schleife hättest lernen können....
 
F

Firephoenix

Gast
...
Aber OK: Jetzt, wo es "fertig" ist, und "funktioniert", versuch' mal dir zu überlegen, wie man es "besser" mache könnte ;)

EDIT: Um das nochmal zu betonen: Durch das bisher geschriebene hast du ja nichts gelernt, was du nicht auch mit einer Schleife hättest lernen können....

Das mit dem "besser machen" überlege ich mir jedes mal :)

Und ich denke wenn man sich mit einem Problem beschäftigt (gerade als Anfänger) und es schafft auf irgend eine Art abzubilden und zu lösen hat man schon etwas gewonnen :)
Außerdem wird man Codesicherer wenn man sich nach und nach auch durch Mehrzeiler arbeiten muss die länger sind als

for(int i=1;i<10;i++)

:)

Und von einigen Ansätzen hier (insbesondere der von Eike :eek:) nehme ich immer auch einiges mit.
Auch wenn ich in Eikes Fall noch nicht den ganzen Code verstehe - was ich mir aber noch erarbeiten werde.

Gruß Firephoenix
 

XHelp

Top Contributor
So, EikeB, wie versprochen ohne abzugucken ;)
Gleiche Parameter wie bei dir:
Code:
EINS beendet, Zeit: 0 ms, Anzahl: 4
SECHS beendet, Zeit: 0 ms, Anzahl: 50
ZWEI beendet, Zeit: 0 ms, Anzahl: 10
DREI beendet, Zeit: 0 ms, Anzahl: 20
VIER beendet, Zeit: 0 ms, Anzahl: 35
NEUN beendet, Zeit: 0 ms, Anzahl: 30
FÜNF beendet, Zeit: 0 ms, Anzahl: 12
SIEBEN beendet, Zeit: 3 ms, Anzahl: 200
ACHT beendet, Zeit: 3 ms, Anzahl: 165
Kombiniere...
Vorgang beendet, 2466 Lösungen
Gesamtdauer: 253 ms

Habe jetzt deinen Code immer noch nicht durchgeguckt, deswegen weiß ich nicht, ob die Ansätze sich unterscheiden, aber da bei dir vom Mergen die Rede ist, bezweifle ich das. Auf jeden Fall stimmen die Zahlen überein, also entweder stimmen die Lösungen oder wie haben beide den selben Fehler gemacht :D
Morgen poste ich dann den Code.

Falls ihr das testen wollt: der Aufruf mit -5 7 liefert schon gute 27.000 Lösungen, -5 8 liefert fast 68.000 :)
Bei mir liefert -5..7 für EINS...ZWÖLF ein völlig anderes Ergebnis...
 
Zuletzt bearbeitet:
F

Firephoenix

Gast
Hm, ich kann bei mir aber in der Hinsicht keinen Logikfehler finden.
Ich setze ja nur alle Variablen in abhängigkeit voneinander nach oben und prüfe dann:

Java:
if(checkEins() && checkZwei() && checkDrei() && checkVier() && checkFuenf() && checkSechs() && checkSieben() && checkAcht() && checkNeun() && checkZehn() && checkElf() && checkZwoelf()){
                                                                                    zaehler++;
                                                                                    checkKleineLoesung();
                                                                                    
                                                                                } 
                                                                                else;

zaehler (der am Ende ausgegeben wird) kann also nur erhöht werden, wenn auch eine Lösung gefunden wurde.

Ich komme allerdings bei -5 8 auf die optimierte Lösung mit dem Gesamtbetrag von 33:
a = 0, b = 1, c = 4, d = 0, e = 5, f = -1, h = 3, i = -3, l = 7, n = 2, o = 1, r = 1, s = -3, t = 1, u = 0, v = 1, w = 0, z = 0

Der Aufruf mit -5 7 liefert exakt das gleiche Ergebnis
Mit -5 6 wird eine Lösung mit Betrag 34 ausgegeben
Und -6 5 findet keine Lösung
 

XHelp

Top Contributor
Kannst ja es auf EINS..NEUN kürzen und mit 0-10 starten, um die Ergebnisse zu vergleichen.

P.S. Du hast 5 und 12 als FUENF und ZWOELF ausgeschrieben. Sicher, dass es die Aufgabe so verlangt?
 
Zuletzt bearbeitet:
F

Firephoenix

Gast
Am Ende kopier ich ja noch die Aufgabe, hier einfach zum nachlesen :)

Knobelmix

Auf der Seite gibts noch mehr lustige Rätsel, ich spiele da ganz gerne mal rum.

Gruß Firephoenix
 
F

Firephoenix

Gast
Um das Problem Mathematisch zu berechnen bin ich selbst leider nicht gut genug :)

Dazu kann ich ja mal auf ein anderes Problem eingehen das ich mal mit einem Bekannten durchgegangen bin - dabei ging es darum alle Lösungen zu finden.

Als Aufgabe ging es damals um das give-more-money Rätsel.
In dem schreibt ein Sohn seinem Vater einen Brief, in dem er um mehr Geld bittet.

er schreibt: Give+More=Money.

Money steht für den Geldbetrag den er haben will.

Auch hierfür gibt es mehrere Lösungen - hier mein ähnlicher Code dazu (und mit Sicherheit nicht der schnellste ;) aber er Arbeitet das Problem durch)

Ok ich sehe gerade, dass ist nicht meine Endversion sondern ein zwischenstand - der schöne Code fliegt irgendwo auf einem USB-Stick herum.
Für rein akademisches Anschauungsmaterial stelle ich ihn trotzdem gerne mal rein (immerhin ist das am ersten Java-Lerntag von uns entstanden ;) )
Java:
public class money {
    public static void main (String[] args){
    
    //M aus Money ist bekannt, da der maximale Übertrag einer Addition 1 sein kann und wir von m != 0 ausgehen. Demnach ist m=1
    int m = 1;
    /*Die anderen Variablen sind nicht sofort ersichtlich und demnach alle als unbekannt zu betrachten (wie sich an der Lösung zeigt muss z.B. auch o
     * nicht zwangsläufig 0 sein obwohl es auf den ersten oder zweiten Blick so aussieht.
    */
    int g, i, v, e, o, r, n, y;
    //loesungen ist eine Variable um zu ermitteln wieviele Lösungen wir ermitteln können (siehe If-Anweisung in der innersten Schleife)
    int loesungen = 0;
    /*Die Schleifen durchlaufen jede Variable, die If-Abfragen fangen dabei gleiche Werte mit Vorvariablen ab. Ich bin mir nicht sicher ob dies das beste System ist,
     * es spart aber im Vergleich zu logischen Vergleichen in der IF-Abfrage (z.B. g != i usw.) deutlich an Rechenleistung da weniger Schleifendurchläufe benötigt werden.
     * Da es spät am Abend ist nimmt mir hoffentlich niemand übel wenn ich gerade nicht in der Laune bin die genaue Ersparnis ermitteln zu lassen,
     * mal ganz davon abgesehen, dass die ausformulierte Logikabfrage in der If-Verzweigung hässlich ist...
     * Die von mir genutzte Methode lässt sich aber ohne viel Aufwand nicht viel mehr erweitern, ich muss dringen mal eine Methode schreiben die x Variablen auf Ungleichheit untersucht...
     * */
    
    //Variable g
    for(g=0; g<=9 ; g++){
        
        //Variable i
        for(i=0; i<=9 ; i++){
            //Überspringt gleiche Zahlenwerte bei Vorvariablen
            if (i==g) continue;
            else;
            
            //Variable v
            for(v=0; v<=9 ; v++){
                //Überspringt gleiche Zahlenwerte bei Vorvariablen
                if (v==g) continue;
                else;
                if (v==i) continue;
                else;
                
                //Variable e
                for(e=0; e<=9 ; e++){
                    //Überspringt gleiche Zahlenwerte bei Vorvariablen
                    if (e==g) continue;
                    else;
                    if (e==i) continue;
                    else;
                    if (e==v) continue;
                    else;
                    
                    //Variable o
                    for(o=0; o<=9 ; o++){
                        //Überspringt gleiche Zahlenwerte bei Vorvariablen
                        if (o==g) continue;
                        else;
                        if (o==i) continue;
                        else;
                        if (o==v) continue;
                        else;
                        if (o==e) continue;
                        else;
                        
                        //Variable r
                        for(r=0; r<=9 ; r++){
                            //Überspringt gleiche Zahlenwerte bei Vorvariablen
                            if (r==g) continue;
                            else;
                            if (r==i) continue;
                            else;
                            if (r==v) continue;
                            else;
                            if (r==e) continue;
                            else;
                            if (r==o) continue;
                            else;
                            
                            //Variable n
                            for(n=0; n<=9 ; n++){
                                //Überspringt gleiche Zahlenwerte bei Vorvariablen
                                if (n==g) continue;
                                else;
                                if (n==i) continue;
                                else;
                                if (n==v) continue;
                                else;
                                if (n==e) continue;
                                else;
                                if (n==o) continue;
                                else;
                                if (n==r) continue;
                                else;
                                
                                //Variable y
                                for(y=0; y<=9 ; y++){
                                    //Überspringt gleiche Zahlenwerte bei Vorvariablen
                                    if (y==g) continue;
                                    else;
                                    if (y==i) continue;
                                    else;
                                    if (y==v) continue;
                                    else;
                                    if (y==e) continue;
                                    else;
                                    if (y==o) continue;
                                    else;
                                    if (y==r) continue;
                                    else;
                                    if (y==n) continue;
                                    else;
                                        //Wenn Give+More gleiche Money ist, dann
                                         if( /*give aufgelöst*/((g*1000)+(i*100)+(v*10)+(e)) + /*more aufgelöst*/ ((m*1000)+(o*100)+(r*10)+(e)) == 
                                            /*money aufgelöst*/ ((m*10000)+(o*1000)+(n*100)+(e*10)+(y)) )
                                            {
                                         //Wird jede Variable ausgegeben    
                                        System.out.println("g=" +g+ " i=" +i+ " v=" +v+ " e=" +e+ " o=" +o+ " r=" +r+ " n=" +n+ " y=" +y);
                                        //Und die Lösung für Money wird ausgegeben
                                        System.out.println("MONEY entspricht demnach: " +m+o+n+e+y);
                                        //Außerdem ein Zeilenabstand
                                        System.out.println("--------");
                                        //break auskommentiert um alle Lösungen zu ermitteln - war in der alten Version
                                        //break;
                                        //und dafür einen Zähler eingebaut wieviele Lösungen wir ermitteln können.
                                        //bei richtiger Lösung die nur in dem If auftritt wird Lösungen um eins erhöht
                                        loesungen++;
                                         }                                        
                                        else{
                                        //
                                        }  


    }
        }
            }
                }
                    }
                        }
                            }
                                }
    //Ausgabe von Lösungen
    System.out.println("Es wurden exakt " +loesungen+ " passende Lösungen ermittelt");
    }
}

Gruß Firephoenix
 

Ähnliche Java Themen

Neue Themen


Oben