Hallo!
Ich habe mal wieder ein Problem, dass mir arge Schwierigkeiten bereitet. Auch wenn es mehroder weniger nur Just for Fun ist, aber das steht hier nciht zur Debatte
Folgendes:
Ich habe eine MySQL-Datenbank mit einer Tabelle, die folgendermaßen aufgebaut ist:
id, a, b, c, d, e, f
Primary-Key für id
und ein INDEX über (a, b, c, d, e, f)
Mein Ziel ist es, alle Lotto-Kombinationen zu generieren und in die Datenbank einzutragen. Jup, sind viele
Zum generieren der Kombinationen habe ich die untenstehende Klasse verwendet. Funktioniert auch so weit, nur habe ich folgendes Problem:
Die Kombinationen werden so gebildet:
1 1 1 1 1 2
...
1 1 1 1 1 49
1 1 1 1 2 1
...
1) alles keine gültigen Lottozahlen s. Code
1 2 3 4 5 6 erste gültige Kombination
...
1 2 3 4 5 49
...
1 2 3 4 6 1
...
1 2 3 4 6 5
gültige Kombination, sortieren, Problem: es gab sie schon. Deshalb wird vor jedem Einfügen in die Datenbank die Existenz der Kombination überprüft, was, wie ihr euch vorstellen könnt, immmmmmmer länger dauert.
Was ich nun möchte:
Alle Lottozahlen generieren, ohne doppelte Zahlen und Wiederholungen. Wie lässt sich das realisieren?
Nocheinmal: Der Grund/Sinn/etc. ist ja egal. Mir gehts nur um das Problem.
Ich habe mal wieder ein Problem, dass mir arge Schwierigkeiten bereitet. Auch wenn es mehroder weniger nur Just for Fun ist, aber das steht hier nciht zur Debatte
Folgendes:
Ich habe eine MySQL-Datenbank mit einer Tabelle, die folgendermaßen aufgebaut ist:
id, a, b, c, d, e, f
Primary-Key für id
und ein INDEX über (a, b, c, d, e, f)
Mein Ziel ist es, alle Lotto-Kombinationen zu generieren und in die Datenbank einzutragen. Jup, sind viele
Zum generieren der Kombinationen habe ich die untenstehende Klasse verwendet. Funktioniert auch so weit, nur habe ich folgendes Problem:
Die Kombinationen werden so gebildet:
1 1 1 1 1 2
...
1 1 1 1 1 49
1 1 1 1 2 1
...
1) alles keine gültigen Lottozahlen s. Code
1 2 3 4 5 6 erste gültige Kombination
...
1 2 3 4 5 49
...
1 2 3 4 6 1
...
1 2 3 4 6 5
gültige Kombination, sortieren, Problem: es gab sie schon. Deshalb wird vor jedem Einfügen in die Datenbank die Existenz der Kombination überprüft, was, wie ihr euch vorstellen könnt, immmmmmmer länger dauert.
Java:
LottoCombinationsDatabase l = new LottoCombinationsDatabase();
Integer input[] = l.getNumbers();
CombinationIterable<Integer> ci = new CombinationIterable<Integer>(6, input);
for (Integer s[] : ci) {
//Gibt es doppelte Zahlen? 1)
if (l.uniqueIntegerArray(s)) {
//aufsteigend sortieren
l.bubbleSort(s);
//existiert die Kombination in der DB?
if (!l.existsCombination(s)) {
l.insertCombination(s);
}
}
}Was ich nun möchte:
Alle Lottozahlen generieren, ohne doppelte Zahlen und Wiederholungen. Wie lässt sich das realisieren?
Nocheinmal: Der Grund/Sinn/etc. ist ja egal. Mir gehts nur um das Problem.
Java:
package lotto;
import java.util.*;
class CombinationIterable<T> implements Iterable<T[]>
{
private T input[];
private int sampleSize;
private int numElements;
public CombinationIterable(int sampleSize, T... input)
{
this.sampleSize = sampleSize;
this.input = input.clone();
numElements = (int) Math.pow(input.length, sampleSize);
}
public Iterator<T[]> iterator()
{
return new Iterator<T[]>()
{
private int current = 0;
private int chosen[] = new int[sampleSize];
public boolean hasNext()
{
return current < numElements;
}
public T[] next()
{
@SuppressWarnings("unchecked")
T result[] = (T[]) java.lang.reflect.Array.newInstance(
input.getClass().getComponentType(), sampleSize);
for (int i = 0; i < sampleSize; i++)
{
result[i] = input[chosen[i]];
}
increase();
current++;
return result;
}
private void increase()
{
int index = chosen.length - 1;
while (index >= 0)
{
if (chosen[index] < input.length - 1)
{
chosen[index]++;
return;
}
else
{
chosen[index] = 0;
index--;
}
}
}
public void remove()
{
throw new UnsupportedOperationException(
"May not remove elements from a combination");
}
};
}
}
Zuletzt bearbeitet:
