Hallo, ich hoffe ich darf das in dem Unterforum posten. Ich habe was programmiert.
Hintergründe des Ganzen sind lottosysteme und die Suche nach dem "perfekten(sprich:minimalen) System" mit dem man garantiert 3 Richtige hat.
Hierzu will ich hingehen, habe ein System vorgegeben von dem ich weiß dass es 3 Richtige bringt. und werfe es in eine Funktion die versucht nacheinander immer wieder eine überflüssige Tippreihe rauszuwerfen (sodass das neue verkürzte System aber immer noch 3 Richtige garantiert).
Was dann übrig bleibt, sollte ein System sein, das immer noch 3 Richtige garantiert wenn man alle Tippreihen gleichzeitig spielt.
Bei dem man aber auch keine der Tippreihen weglassen kann ohne dass die 3 Richtige Garantie verletzt wird.
Ein "System" in dem Sinne ist im Übrigen einfach eine Liste von je 6 Lottozahlen.
Programmiertechnisch habe ich dies umgesetzt als Arraylist, die als Elemente wieder eine Arraylist mit long elementen hat.
Ist so der Hintergrund, mir geht aber primär um die Umsetzung des optimierungsalgorithmus.
ich habe also einen initialen input, ein vorgegebenes system dass es zu optimieren gilt.
dann lasse ich von einer methode eine liste aller möglichen 6-tuples erstellen, also liste aller denkbaren 6 gewinnzahlen die beim lotto gezogen werden könnten.
dann teste ich der reihe nahc die zeilen in input dahingehend durch ob man sie weglassen könnte.
falls ja, wird unsere inputliste durch eine neue lsite ohne jene zeile ersetzt.
wann ist eine zeile ersetzbar?
hierzu bilde ich eine kopie der inputliste, in der die j-te zeile fehlt.
mit dieser liste machen ich nun folgendes:
ich gehe der reihe nahc alle lottozahlen durch und vergleiche jede lottozahl mit jeder der zahlen unserer liste.
sagen wir ich habe eine lottozahl, dann vergleiche ich die mit jeder der listenzahlen und merke mir bei jedem mal wie viele richtige die 2 zahlen gemeinsam hatten.
ich gucke, wenn ich die lottozahl mit allen listenzahlen abgeglichen haben, was die höchste menge an richtigen war, die vorkam.
Denn wenn in einer ziehung jene lottozahl gezogen wird und ich hatte alle unserer lsitenzahlen gespielt, dann ist dieses maximum ja gerade die höchste erreichte gewinnklasse.
wir speichern uns also für jede der getesteten lottozahlen jene ermittelte maximal erreichte gewinnklasse.
machen wir für jede lottozahl und speichern es in nem array.
nun gucken wir uns das array an und suchen, dieses mal, das minimum der werte.
denn wir wissen ja nun für jede der lottozahlen was wir für eine gewinnklasse maximal haben wenn wir unser system gespielt hätten.
wenn wir nun das minimum dieser maximalzahlen nehmen, dann wissen wir welche gewinnklasse wir in jedem fall mind. erreicht haben, ganz unabhängig davon welche lottozahlen gezogen werden.
ein paar gedankenschritte zurück:
jene vergleichsliste war ja die ursprüngliche inoputliste abzüglich dem j-ten element (oder element mit index j, genau genommen).
wenn wir nun also als ergebnis finden dass wir mit dieser verkürzten liste mind. 3 richtige haben, können wir happy sein.
denn das heißt wir können in der ursprungslösite die j-te reihe wegfallen lassen ohne dass es unserer 3+richtige garantie schadet.
so gehen wir für unsere initiale input liste der reihe nach alle zeilen durch und sobald wir eine zeile gefunden haben, die wir rauswerfen können und trotzdem unsere qualitätsansprüche erhalten bleiben, sind wir fertig und brauchen auch die restlichen reihen überprüfen.
pro iteration wollen wir ja nur eine reihe finden, die wir rauswerfen können.
sobald also eine passende reihe gefunden ist, sind wir fertig.
dass eine erfolgreiche reihe gefunden und rausgeworfen wurde, gibt uns die optimizefunktion durch einen rückgabewert von 1 an. hat sie hingegen alles durchsucht und ncihts zum optimieren gefunden, gitb sie 0 zurück.
nun optimieren wir immer wieder so lange wie jedes mal eine 1 zurückgegeben wird. wird irgendwann hingegen eine 0 zurückgegeben, wissen wir dass usnere lsite nicht mehr verbessert werden kann und sind fertig.
wir geben die länge der liste und seine elemente just for fun mal nocg auf der konsole aus.
Falls überhaupt jemand bis hierhin gelesen hat:
Meint ihr dass mein unten beigefügter Code das gewünschte erreicht?
Mir ist klar dass er performance mässig vermutlich eine katastrophe ist.
Habt ihr eine gute idee wie man es verbessern könnte?
Habe auch shcopn über andere datentypen nachgedacht, aber ich habe , gerade bei den vielen verschatelungen und was hier so nötig ist, nicht genug ahnung von diesen um da was sinnvolles zu produzieren.
Ob es perfomancemässig besser wäre, weiß ich auch nicht. was meint ihr?
Hintergründe des Ganzen sind lottosysteme und die Suche nach dem "perfekten(sprich:minimalen) System" mit dem man garantiert 3 Richtige hat.
Hierzu will ich hingehen, habe ein System vorgegeben von dem ich weiß dass es 3 Richtige bringt. und werfe es in eine Funktion die versucht nacheinander immer wieder eine überflüssige Tippreihe rauszuwerfen (sodass das neue verkürzte System aber immer noch 3 Richtige garantiert).
Was dann übrig bleibt, sollte ein System sein, das immer noch 3 Richtige garantiert wenn man alle Tippreihen gleichzeitig spielt.
Bei dem man aber auch keine der Tippreihen weglassen kann ohne dass die 3 Richtige Garantie verletzt wird.
Ein "System" in dem Sinne ist im Übrigen einfach eine Liste von je 6 Lottozahlen.
Programmiertechnisch habe ich dies umgesetzt als Arraylist, die als Elemente wieder eine Arraylist mit long elementen hat.
Ist so der Hintergrund, mir geht aber primär um die Umsetzung des optimierungsalgorithmus.
ich habe also einen initialen input, ein vorgegebenes system dass es zu optimieren gilt.
dann lasse ich von einer methode eine liste aller möglichen 6-tuples erstellen, also liste aller denkbaren 6 gewinnzahlen die beim lotto gezogen werden könnten.
dann teste ich der reihe nahc die zeilen in input dahingehend durch ob man sie weglassen könnte.
falls ja, wird unsere inputliste durch eine neue lsite ohne jene zeile ersetzt.
wann ist eine zeile ersetzbar?
hierzu bilde ich eine kopie der inputliste, in der die j-te zeile fehlt.
mit dieser liste machen ich nun folgendes:
ich gehe der reihe nahc alle lottozahlen durch und vergleiche jede lottozahl mit jeder der zahlen unserer liste.
sagen wir ich habe eine lottozahl, dann vergleiche ich die mit jeder der listenzahlen und merke mir bei jedem mal wie viele richtige die 2 zahlen gemeinsam hatten.
ich gucke, wenn ich die lottozahl mit allen listenzahlen abgeglichen haben, was die höchste menge an richtigen war, die vorkam.
Denn wenn in einer ziehung jene lottozahl gezogen wird und ich hatte alle unserer lsitenzahlen gespielt, dann ist dieses maximum ja gerade die höchste erreichte gewinnklasse.
wir speichern uns also für jede der getesteten lottozahlen jene ermittelte maximal erreichte gewinnklasse.
machen wir für jede lottozahl und speichern es in nem array.
nun gucken wir uns das array an und suchen, dieses mal, das minimum der werte.
denn wir wissen ja nun für jede der lottozahlen was wir für eine gewinnklasse maximal haben wenn wir unser system gespielt hätten.
wenn wir nun das minimum dieser maximalzahlen nehmen, dann wissen wir welche gewinnklasse wir in jedem fall mind. erreicht haben, ganz unabhängig davon welche lottozahlen gezogen werden.
ein paar gedankenschritte zurück:
jene vergleichsliste war ja die ursprüngliche inoputliste abzüglich dem j-ten element (oder element mit index j, genau genommen).
wenn wir nun also als ergebnis finden dass wir mit dieser verkürzten liste mind. 3 richtige haben, können wir happy sein.
denn das heißt wir können in der ursprungslösite die j-te reihe wegfallen lassen ohne dass es unserer 3+richtige garantie schadet.
so gehen wir für unsere initiale input liste der reihe nach alle zeilen durch und sobald wir eine zeile gefunden haben, die wir rauswerfen können und trotzdem unsere qualitätsansprüche erhalten bleiben, sind wir fertig und brauchen auch die restlichen reihen überprüfen.
pro iteration wollen wir ja nur eine reihe finden, die wir rauswerfen können.
sobald also eine passende reihe gefunden ist, sind wir fertig.
dass eine erfolgreiche reihe gefunden und rausgeworfen wurde, gibt uns die optimizefunktion durch einen rückgabewert von 1 an. hat sie hingegen alles durchsucht und ncihts zum optimieren gefunden, gitb sie 0 zurück.
nun optimieren wir immer wieder so lange wie jedes mal eine 1 zurückgegeben wird. wird irgendwann hingegen eine 0 zurückgegeben, wissen wir dass usnere lsite nicht mehr verbessert werden kann und sind fertig.
wir geben die länge der liste und seine elemente just for fun mal nocg auf der konsole aus.
Falls überhaupt jemand bis hierhin gelesen hat:
Meint ihr dass mein unten beigefügter Code das gewünschte erreicht?
Mir ist klar dass er performance mässig vermutlich eine katastrophe ist.
Habt ihr eine gute idee wie man es verbessern könnte?
Habe auch shcopn über andere datentypen nachgedacht, aber ich habe , gerade bei den vielen verschatelungen und was hier so nötig ist, nicht genug ahnung von diesen um da was sinnvolles zu produzieren.
Ob es perfomancemässig besser wäre, weiß ich auch nicht. was meint ihr?
Java:
import java.util.*;
public class Test9{
public static void main(String[] args){
ArrayList<ArrayList<Long>> sixtuples=sixtuples();
ArrayList<ArrayList<Long>> input=args[0];
System.out.println("Mit dem System werden mindestens einmal "+calculate(sixtuples,input)+" Richtige erreicht!!!");
while(optimize(sixtuples,input)>0){
System.out.println("Optimiert! Das neue System hat noch "+input.size()+" Tippreihen!");
}
System.out.println("Fertig! Das perfekte System hat "+input.size()+" Tippreihen!!");
System.out.println("Das perfekte System lautet :");
System.out.println();
for(ArrayList<Long> stuple: input){
for(Long a: stuple){
System.out.print(a+" ");
}
System.out.println();
}
}
public static long optimize(ArrayList<ArrayList<Long>> sixtuples,ArrayList<ArrayList<Long>> input){
for(int j=0;j<input.size();j++){
ArrayList<ArrayList<Long>> copy=copywithoutj(input,j);
long n=calculate(sixtuples,copy);
if(n>=3){
input=copy;
return 1;
}
}
return 0;
}
public static ArrayList<ArrayList<Long>> copywithoutj (ArrayList<ArrayList<Long>> Array, int j){
//Sei Array das alte arraylistgebilde
ArrayList<ArrayList<Long>> copy = new ArrayList<ArrayList<Long>>();
for (int i=0;i<copy.size();i++) {
if(i!=j){
ArrayList<Long> copyi = new ArrayList<Long>();
for (long Arrayii : Array.get(i)) {
Long a=new Long(Arrayii);
copyi.add(a);
}
copy.add(copyi);
}
}
//copy hat nun die selben inhalte wie array und das ohne referenzen
return copy;
}
public static ArrayList<ArrayList<ArrayList<Long>>> copy3 (ArrayList<ArrayList<ArrayList<Long>>> Array){
//Sei Array das alte arraylistgebilde
ArrayList<ArrayList<ArrayList<Long>>> copy = new ArrayList<ArrayList<ArrayList<Long>>>();
for (ArrayList<ArrayList<Long>> Arrayi : Array) {
ArrayList<ArrayList<Long>> copyi = new ArrayList<ArrayList<Long>>();
for (ArrayList<Long> Arrayii : Arrayi) {
ArrayList<Long> copyii = new ArrayList<Long>();
for (long Arrayiii : Arrayii) {
Long a=new Long(Arrayiii);
copyii.add(a);
}
copyi.add(copyii);
}
copy.add(copyi);
}
//copy hat nun die selben inhalte wie array und das ohne referenzen
return copy;
}
public static ArrayList<ArrayList<Long>> copy2 (ArrayList<ArrayList<Long>> Array){
//Sei Array das alte arraylistgebilde
ArrayList<ArrayList<Long>> copy = new ArrayList<ArrayList<Long>>();
for (ArrayList<Long> Arrayi : Array) {
ArrayList<Long> copyi = new ArrayList<Long>();
for (long Arrayii : Arrayi) {
Long a=new Long(Arrayii);
copyi.add(a);
}
copy.add(copyi);
}
//copy hat nun die selben inhalte wie array und das ohne referenzen
return copy;
}
public static ArrayList<Long> copy1 (ArrayList<Long> Array){
//Sei Array das alte arraylistgebilde
ArrayList<Long> copy = new ArrayList<Long>();
for (long Arrayi : Array) {
Long a=new Long(Arrayi);
copy.add(a);
}
//copy hat nun die selben inhalte wie array und das ohne referenzen
return copy;
}
public static long calculate(ArrayList<ArrayList<Long>> sixtuples, ArrayList<ArrayList<Long>> input){
//
//anzahl richtige für jedes tupel in input finden
ArrayList<Long> wins=new ArrayList<Long>();
for(ArrayList<Long> sixtuple:sixtuples){
long wintemp=0;
//setze wintemp gleich dem maximum, also den größtmöglichen richtigen die mit irgendeiner inputreihe getroffen werden
for(ArrayList<Long> indinp: input){
long inttemp=equalnum(sixtuple,indinp);
if(inttemp>wintemp){
wintemp=inttemp;
}
}
wins.add(wintemp);
}
//bestimmen was die kleinste vorkommende zahl an Richtigen ist
long minrichtige=getmin(wins);
return minrichtige;
}
public static long getmin(ArrayList<Long> array){
long n=array.get(0);;
for (long zahl:array){
if(zahl<n){
n=zahl;
}
}
return n;
}
public static int equalnum(ArrayList<Long> a, ArrayList<Long> b){
int indexa=0;
int indexb=0;
int count=0;
while((indexa<a.size())&(indexb<b.size())){
if(a.get(indexa)==b.get(indexb)){count++;indexa++;indexb++;}
if(a.get(indexa)<b.get(indexb)){indexa++;}
if(a.get(indexa)>b.get(indexb)){indexb++;}
}
return count;
}
public static ArrayList<ArrayList<Long>> sixtuples(){
ArrayList<ArrayList<Long>> sixtuples=new ArrayList<ArrayList<Long>>();
for(long a=1;a<=49;a++){
for(long b=1;b<=49;b++){
for(long c=1;c<=49;c++){
for(long d=1;d<=49;d++){
for(long e=1;e<=49;e++){
for(long f=1;f<=49;f++){
if((a<b)&(b<c)&(c<d)&(d<e)){
ArrayList<Long> temp=new ArrayList<Long>();
temp.add(a);
temp.add(b);
temp.add(c);
temp.add(d);
temp.add(e);
temp.add(f);
sixtuples.add(temp);
}
}
}
}
}
}
}
return sixtuples;
}
}