bei 2 Arrays Anzahl gleicher Elemente vergleichen?

berndoa

Top Contributor
Hallo,
ich habe aktuell folgende Klasse:

Java:
package b;

public class Receiver {
    int[] numbers = new int[6];
    final int L49über6 = 13983816;

    public Receiver(int[] numbers) {
        this.numbers = numbers;
    }

    public int countConnections(Sender b) {
        int count = 0;
        int aindex = 0;
        int bindex = 0;

        while (aindex < numbers.length && bindex < b.numbers.length) {
            if (numbers[aindex] < b.numbers[bindex]) {
                aindex++;
            } else if (numbers[aindex] > b.numbers[bindex]) {
                bindex++;
            } else if (numbers[aindex] == b.numbers[bindex]) {
                aindex++;
                bindex++;
                count++;
            }
        }
        return count;
    }

}


Mich würde interessieren ob ich die countConnections Methode korrekt gebaut habe.
Die in der MEthode vorkommenden variabeln numbers und b.numbers sind beide simple int Arrays der Länge 6.
Kurzum 2 Arrays mit 6 Zahlen drin.
Und die Methode soll die gleichzeitig durchgehen und gucken wie viele Zahlen in beidne Arrays vorhanden sind.
Bspw. bei (1,2,3,4,5,6) und (2,4,6,8,10) kommen die 2,4 und 6 in beiden Arrays vor, dementsprechend würde die Methode die Anzahl 3 ausgeben.

Sinngemäß laufen da 2 indexzähler durhc die Arrays.
Ist die aktuelle Zahl im 1. arrays kleienr als die im 2. array, wird der 2. zähler erhöht.
im umgekehrten fall wird der 1. zähler erhöht.
und sind die aktuell betrachteten Zahlen in den Arrays gleich, dann werden beide indizes erhöht sowie der vorkommenszähler um 1 erhöht.


bin mir nur unsicher ob in der while Shcleife das so passt.
Und ob ich vielleicht nach der While Scheife nochmal separat die Fälle durchgehen muss wo in einem der Arrays derr zähler noch nicht am Ende ist.
 
Es gibt noch eine Möglichkeit, wie du das direkt über Collections lösen kannst.
Java:
var commonNumbers = new ArrayList<>(Arrays.asList(numbers));
commonNumbers.retainAll(Arrays.asList(b.numbers));


Das ist übrigens eine sehr gute Gelegenheit, Junit-Tests zu implementieren.
Erstelle mehre verschiedene Beispiele, gepaart mit Soll-Ergebnissen, eventuell auch fehlerhafte, wo z.B. die Arrays eine verschiedene Länge haben.
Dann lass die Tests durchlaufen und vergleiche mit dem Soll-Ergebnis (bzw. auch, was bei fehlerhaften Quelldaten passieren soll)


ps: Schöner als Arrays und Listen wären natürlich Sets, damit hast du auch gleich sichergestellt, dass Zahlen nicht doppelt vorkommen können. Und ein TreeSet wäre dann auch gleich schon sortiert.
 
[1], [2,3]
1 < 2, also wird aIndex erhöht und die Schleife endet.

[2,3], [1]
2 > 1, also wird bIndex erhöht und die Schleife endet.

[1,2], [1,1,2]
1 == 1, also werden aIndex und bIndex erhöht
2 > 1, also wird bIndex erhöht
2 == 2, also werden aIndex und bIndex erhöht, Schleife endet.
 
Ich hätte gar nicht gewusst wie man es ohne 2 Zähler macht 🙃
Weil die ja nicht wirklich gleich schnell laufen, je anch vorhandenen Elementen 🙂
 
Mich irritiert ja diese Zeile.
final int L49über6 = 13983816;
Wenn das nur ein Relikt aus einem alten Code ist und tatsächlich nichts mehr mit dem in #1 beschrieben Problem zu tun hat, braucht Ihr jetzt gar nicht mehr weiter lesen.
Falls es aber doch um das Auszählen der Richtigen im Lotto 6 aus 49 geht, hätte ich einen Alternativ-Vorschlag, der auf Bitmanipulation aufbaut.
Java:
public class Receiver {
    
    long bettingSlip;

    public Receiver(int[] numbers) {
        bettingSlip = 0;
        for (int shift : numbers) {
            bettingSlip |= 1 << (shift - 1);
        }
    }
    
    public int countCorrectNumbers(long current6of49) {
        long comparison = bettingSlip & current6of49;
        
        int count = 0;
        while (comparison > 0) {
            count += comparison & 1;
            comparison >>= 1;
        }
        
        return count;
    }
}
 
Ja, es geht darum dass ich riesige Lsiten von Lottozahlen miteinander vergleichen will.

Ich habe mittlerweile meinen Code dahingehend abgeändert dass ich keine Separaten Sender/receiver Klassen habe.
Sondern eine Liste mit allen möglichen Lottozahlen und gucke wie Elemente in der Lsite miteinander "verbunden" sind (Verbunden im Sinne von "haben Lottozahl 234 und Lottozahl 164784 3 gleiche Ziffern oder mehr? falls ja verbunden, falls nein, nicht").
Und merke mir in jedem Lottozahlenobjekt mit welchen anderen Elementen es verbunden ist (da es ja dieselbe Liste ist, reichen heir die Indizes) sowie merke mir die Anzahl an Verbindungen mit dieser Nummer.


Irgendwann will ich dann hingehen und gucke wie ich systematishc Lottonummern aus der liste löschen kann (jedes Listenelement hat einfach eine boolean Variable um den verwendet/nicht-verwendet Status zu speichern).


Mein kleines Problem ist beim Finden aller Verbindungen nur die Tatsache dass Millionen Einträge mit Millionen Einträgen verglichen werden.

Habe es zwar shcon dahingehend "optimiert" dass ich bspw. nur Eintrag 1 mit einträgen 2,3,4 vergleiche, also einen Eitnrag nur mit Einträgen mit höherem Index.
Aber das sind halt immer noch sehr große Mengen an Daten.

Hatte eigentlich programmiert dass er mir mal, um den Zwischenstand zu speichern, die Daten in eine Openoffice Calc Tabelle speichert.
Was nun aber shcon scheitert weil ich las dass Tabellen da nur ein paar tausend Spalten haben können -.-
Da passen dann keine Millionen Spalten rein :-/

Bin irgendwie noch überfordert wie ich die Unmengen an Daten irgendwie sinnvoll handhaben kann.

Mein eigentliches Problem liesse sich später vielleicht Mathematisch lösen (wobei ich auch da zumindest die Verbindungen kennen muss), aber auch da müsste ich mit einer Matrix mit zig Milliarden Einträgen und nem Simplex Algorithmus arbeiten. Falls der für das Problem überhaupt passend ist. :-/
 
Na dann schau Dir #12 noch mal an. Der Anatz ist folgender. Der Datentyp long benötigt 8 Byte, also 64 Bit. Jedes Bit kann somit eine von 64 verschiedenen Zahlen repräsentieren. Für Lotto benötig man 49 Zahlen, also 49 Bit. Für jeden Lotto-Tipp werden in einem long-Wert die 6 Stellvertreter-Bits gesetzt. Verschieden Tipps kannst Du mit eine einfachen binären UND(&)-Verknüpfung vergleichen. Es bleiben nur die in beiden Tipps identischen auf 1 gesetzten Bits stehen. Dann musst Du nur noch die verbliebenen Einsen zählen, fertig.
 
Das muss ich jetzt mal sacken lassen.
Ne 6stellige Lottozahl stellst du also dar indem du in einer 49 bit zahl 6 bit auf 1 setzt, die restlichen auf Null.
Und um nun die Anzahl an gleichen Stellen zwischen zwei 6stelligen Zahlen zu bestimmen, verknüpfst du 2 solche zahlen mit &.

Die Idee versteh ich, den Code in #12 noch nicht so wirklich.
Habe aber auch noch nice mitbit Operationen gearbeitet und keinen wirklich Plan was da passiert.

Bspw. bei
Java:
        bettingSlip = 0;
        for (int shift : numbers) {
            bettingSlip |= 1 << (shift - 1);
        }
bin ich mir unsicher was die Zuweisung da genau tut.
Also schlicht, was die einzelnen Operanden wie <<, |=, usw tun.
 
Jaaaa, das ist in Java auch nicht so häufig zu lesen 😁
a |= b bedeutet a = a | b (Du kennst ja bestimmt das logische ODER ||, ein | ist das binäre ODER, also ein bitweiser vergleich. Da werden Bitmuster miteinander verknüpft, was ein neues Bitmuster liefert, also kein TRUE/FALSE)
4 | 1 ergibt 5, weil binär dargestellt 0100 | 0001 = 0101, und 0101 in dezimaler Schreibweise 5 entspricht.

a << b ist ein Bitshift. Alle bits des Bitmusters a wandern b Positionen nach links (pro Position entspricht das einer Wertverdoppelung)
z.B. 1 << 3 = 1 * (2 * 2 * 2) = 8, binär dargestellt 00000001 << 3 = 00001000
 
Ne 6stellige Lottozahl stellst du also dar indem du in einer 49 bit zahl 6 bit auf 1 setzt, die restlichen auf Null.
Nein. Du setzt einfach das x. Bit, wenn Zahl x gezogen wurde. Das funktioniert, weil ja eine Zahl nicht doppelt gezogen werden kann. Bei 6 aus 49 hast Du also eine 49-Bit lange Zahl, in der 6 Bits auf 1 stehen. Und 49 Bit passen locker in 64 Bit.

Du kannst somit zwei Ziehungen mit einer einfachen bitweisen AND-Verknüpfung miteinander vergleichen.
 
Meine ich ja, von 49 bits sind 6 auf 1 gesetzt, der Rest Null.

Klar, so kann ich prima 2 Zahlen vergleichen miteinander.
Muss nur dann noch die 1sen zählen in der Binärzahl, die da als Ergebnis rauskommt.

Gibts dafür auch was Gutes von Ratiopha.. von Java, irgendeine fertige Methode die mir die 1 bits in einer Zahl zusammenzählt? 🙂


Auch mal dumm gefragt, wie konstruiere ich eigentlich so eine Binärzahl?

Also wenn ich bspw. {1,5,23,30,44,47} habe, dann weiß ich ja dass das 0.,4.,22.,29.,42. und 46. bit gleich 1 sein müssen und alle anderen Null.
Aber wie baue ich da ein passendes Long zusammen?
 
Wenn ich so drüber nachdenke, vermutlich so ähnlich, oder?

Java:
long a=0;
int[]b={1,4,7,9,13,25}

for(int i:b){
    a=a|(1<<(b-1));
}

for schleife geht die zahlen durch.

bspw. die 4 wandelt er in eine passende bitzahl um indem er 1 nimmt und es 3 bits nach links schiebt, also 3 nullen rechts anhängt,
also 4=1000.
diese zahl wird mit der bisherigen longzahl geodert damit zusätzlich zu den bisherigen stellen eben nun auch an der 4. stelle eine 1 steht.
rinse and repeat für alle zahlen im array.

und wenn es mir danach ist, kann ich dann mit
Java:
a.bitCount();
die einsen in der bitfolge zählen.
Oder was eigenes bauen um die einsen zu zählen
 
Falls das brauchbar sein könnte ... Ein EnumSet speichert die gesetzten Felder ebenfalls als Bitmaske ab.
Vorteil: Dann hättest du gleich Collection-Methoden. Nachteil: Du musst für jede Zahl einen Wert anlegen. Du kannst dann natürlich Wrappermethoden schreiben, die anstatt Enum-Werten einfach die Zahlen akzeptiert.
Bits zählen sparst du dir, wenn du size() aufrufst.

Ob nun bei einem einzelnen Vergleich 1 oder 5 Befehle ausgeführt werden, ist irrelevant, so lange dies nicht durch eine Schleife passiert. Das dauert beides gleich lang. Also überoptimier das Ganze nicht, das bringt nichts.
 
Oder was eigenes bauen um die einsen zu zählen
Oder du machst gleich eine spezialisierte Klasse "Lottozahl", welche die passenden Methoden implementiert. Dem Konstruktor übergibst du einen int, intern speicherst du den Wert (evtl. zusätzlich) als long ab, welchen die Methode "vergleiche(Lottozahl l)" dann verwenden kann, in dieser Art z. B.

Java:
public class Lottozahl {
    private final int value;
    private final long bits;
   
    public Lottozahl(int value) {
        this.value = value;
        this.bits = convert2Bits(value);
    }
   
    public long vergleiche(Lottozahl lz) {
        // ...
    }
   
    // liefert die Anzahl von Treffern zwischen this und lz.
    public int getHitsCount(Lottozahl lz) {
       
    }
   
    // usw..
   
    private long convert2Bits(int value) {
        // ...
    }
}

Ergänzend dazu: https://www.geeksforgeeks.org/count-set-bits-in-an-integer/
 
Zuletzt bearbeitet:
Mein Problem ist jetzt auch weniger wie ich zwei 6er zahlen vergleiche, sondern eher alle Verbindungen kreuz und quer zwischen denne zu finden.
Weil das wären ja im worst case an die ca. 10^14 Verbindungen.
Und für jede müssen besagte Vergleiche, bit wise oder anders, gemacht werden...

Andere Frage:
In der for schleife, kann man da eigentlich auch ein byte statt int benutzen?
Weil in meinem fall gehen die werte ja von 1 bis 49 und byte ghet ja glaub ich bis 64....
 
Und ich habe mal wieder einen Fehlercode den ich nicht checke:

Java:
Java HotSpot(TM) 64-Bit Server VM warning: INFO: os::commit_memory(0x00000007b5a00000, 499122176, 0) failed; error='Die Auslagerungsdatei ist zu klein, um diesen Vorgang durchzuf�hren' (DOS error/errno=1455)
#
# There is insufficient memory for the Java Runtime Environment to continue.
# Native memory allocation (mmap) failed to map 499122176 bytes for G1 virtual space
# An error report file with more information is saved as:
# C:\Users\d-sch\Desktop\Eclipse mit Java 18\workspace\MinMax Tripel\hs_err_pid30168.log

Mein aktueller Code prüft naiv jede Zahlenkombi mit Jeder, also ziemlich viele Zahlen.
Aktuell war es so eingestellt dass alle Verbindungen in eine .ods Datei gespeichert werden (was nicht passen kann da deren grenzen viel kleiner ist als benötigt).

Aber ich glaube, daran liegt es nicht einmal, hier scheint sich eher Java selbst zu beschweren dass ihm der Platz ausgeht oder so...

Kann mir Jemand erklären asdas hier bedeutet?
 
Die JVM bekommt vom Betriebssystem nicht den Speicher, den es gerne haben möchte.

Du musst natürlich sicher stellen, dass das Betriebssystem der jvm den Speicher geben kann, den du ihr geben willst. Das geht zur not auch über Swap Space - also einer Auslagerungsdatei.

Wenn Du also z.B. die JVM mit einem Parameter startest, dass die JVM bis zu 16GB Heap Space haben soll, dann muss das Betriebssystem diese 16GB auch zur Verfügung stellen können.
 
Die JVM bekommt vom Betriebssystem nicht den Speicher, den es gerne haben möchte.

Du musst natürlich sicher stellen, dass das Betriebssystem der jvm den Speicher geben kann, den du ihr geben willst. Das geht zur not auch über Swap Space - also einer Auslagerungsdatei.

Wenn Du also z.B. die JVM mit einem Parameter startest, dass die JVM bis zu 16GB Heap Space haben soll, dann muss das Betriebssystem diese 16GB auch zur Verfügung stellen können.
Wie kann ich das festlegen wie viel Platz er da benutzen darf?

Hatte das bisher einfahc in Eclipse ausgeführt, kann man das dort irgendwo einstellen?
 
Erst einmal kannst Du schauen, was Dein Rechner für Hauptspeicher hat und was Du da für Settings hast bezüglich Swap. Das wäre erst einmal zu verändern wäre meine Vermutung. Ggf. mehr Programme beenden, damit mehr Speicher frei ist.

Denn die JVM braucht den Speicher. Sonst hätte diese den Speicher ja nicht vom System angefordert. Das also kleiner zu machen per Kommandozeile ist vermutlich eher keine gute Idee und dürfte dann in einer OutOfMemoryException enden, weil halt der JVM dann der Speicher ausgeht.
 
Erst einmal kannst Du schauen, was Dein Rechner für Hauptspeicher hat und was Du da für Settings hast bezüglich Swap. Das wäre erst einmal zu verändern wäre meine Vermutung. Ggf. mehr Programme beenden, damit mehr Speicher frei ist.

Denn die JVM braucht den Speicher. Sonst hätte diese den Speicher ja nicht vom System angefordert. Das also kleiner zu machen per Kommandozeile ist vermutlich eher keine gute Idee und dürfte dann in einer OutOfMemoryException enden, weil halt der JVM dann der Speicher ausgeht.
Ich wills ja auch nicht kleiner machen sondern größer, damit die Java Maschine da genug Ressourcen hat 🙂
 
Wie kann ich das festlegen wie viel Platz er da benutzen darf?
Ach, da gibts auf dem Board so Steckplätze, da kann man Speicherriegel reinstecken 🙂

Alternativ kann man die Größe der Auslagerungsdatei einstellen. Unter Windows 10: Windows-Taste + R dort systempropertiesadvanced aufrufen (alternativ im Suchfeld nach "Erweiterte Systemeinstellungen anzeigen" suchen und auswählen). Im Reiter Erweitert, Abschnitt Leistung auf Einstellungen klicken. Dort wieder in den Reiter "Erweitert" wechseln und schon siehst Du unten die Einstellungen für die Auslagerungsdatei.
 
Ach, da gibts auf dem Board so Steckplätze, da kann man Speicherriegel reinstecken 🙂

Alternativ kann man die Größe der Auslagerungsdatei einstellen. Unter Windows 10: Windows-Taste + R dort systempropertiesadvanced aufrufen (alternativ im Suchfeld nach "Erweiterte Systemeinstellungen anzeigen" suchen und auswählen). Im Reiter Erweitert, Abschnitt Leistung auf Einstellungen klicken. Dort wieder in den Reiter "Erweitert" wechseln und schon siehst Du unten die Einstellungen für die Auslagerungsdatei.
Danke. Die Auzslagerungsdatei war bei mir nur auf läppische 16 gb eingestellt, habe es mal auf 100 gb hochgeschraubt 🙂
 
In der for schleife, kann man da eigentlich auch ein byte statt int benutzen?
Natürlich, du kannst da alles nutzen, was du willst. Eine for-Schleife muss noch nicht mal zwingend einen Zähler haben.
Java:
for (initialisiereVariable ; bedingung ; nachJederSchleife) {
  machWas;
  }
entspricht in etwa
{
 initialisiereVariable;
 while (bedingung) {
   machWas;
   nachJederSchleife;
 }
}
Niemand schreibt dir vor, was du hier verwendest
Es funktioniert sogar
Java:
  for(;;) {
    machWas;
  }
das ist identisch zu
  for(;true;) {
  machWas;
  }
und ist de facto eine Endlosschleife
 
Rein von der Datenstruktur her stoe ich da an die Grenzen des Möglichen.
Hätte bspw. für jede der 13 millionen Zhalen gerne eine 13 millionen lange bitzahl gespeichert.

Wären meine größenordnung kleiner, ginge das Prinzip.
Aber bei millionen von Einträgen wirds shcwer.
Da überschreite ich sogar massiv die Grenzen dessen, was man in eine .txt .ods und So Dateien schreiben kann :-/
 
Dann teil's halt auf mehrere Dateien auf.
Die Festplatte kann ja auch nicht eine Gigabytedatei alles in einen Block schreiben, sondern verteilt die zu schreibenden Daten auf viele Blöcke.
Jetzt musst du dir nur noch überlegen, wie du die 24 Terabyte organisiert kriegst.
 
Mir ist aber auch noch nichts Kluges eingefallen wie ich die Millionen x Milliionen Kombinationen handhaben könnte...
Jetzt mal etwas mehr Details: 1 Million x 1 Million oder wieviele werden das jetzt. Generierst Du die Daten selber (z.B. mit Random), oder liegen die auf Deine Festplatte oder irgendwo in einer Datenbank? Was für Ergebnisse werden erstellt und mit welchen Datenvolumen rechnest Du.
Ich frage nur, weil es mir nicht einleucht, wie Du auf zig GB Datenvolumen kommen willst.
 
Jetzt mal etwas mehr Details: 1 Million x 1 Million oder wieviele werden das jetzt. Generierst Du die Daten selber (z.B. mit Random), oder liegen die auf Deine Festplatte oder irgendwo in einer Datenbank? Was für Ergebnisse werden erstellt und mit welchen Datenvolumen rechnest Du.
Ich frage nur, weil es mir nicht einleucht, wie Du auf zig GB Datenvolumen kommen willst.
Er hat 13.9 Millionen Datensätze und will in einer Bitmaske abspeichern, welcher der Datensätze mit welchem in Beziehung steht ... warum auch immer.
D.h. Der Speicher macht ca. 13.9 * 13.9 / 8 * 10^12 aus.
 
Zuletzt bearbeitet:
Jetzt mal etwas mehr Details: 1 Million x 1 Million oder wieviele werden das jetzt. Generierst Du die Daten selber (z.B. mit Random), oder liegen die auf Deine Festplatte oder irgendwo in einer Datenbank? Was für Ergebnisse werden erstellt und mit welchen Datenvolumen rechnest Du.
Ich frage nur, weil es mir nicht einleucht, wie Du auf zig GB Datenvolumen kommen willst.
ca 13 millionen mal 13 millionen

Sache ist die:
Ich will beim Lotto 6aus49 die kleinstmögliche Mengen an "Tipps", also an 6-zahligen Tupeln ( bspw. {1,2,3,4,5,6] ist solch ein Tupel) finden, mit der man trotzdem 3 Richtige hat, egal was nun bei einer Ziehung gezogen wird.

Sowas geht, irgendwer Schlaues hat da mal eine Liste mit 700 oder so Tipps dazu gefunden.
Und ich will mit Brute Force testen ob ichs besser kann 🙂

Fangen also mit einer Liste aller möglichen Lottozahlen an (die laut Mathematik "49 über 6"=13983816 Elemente hat, also rund 14 Millionen) und gucke nacheinander welche der Tipps ich kicken kann.
In einer Runde wird eiN Tipp, falls möglich, aus der Liste geshcmissen.

Sicherlich gibt es oft mehrere Auswahlmöglichkeiten was ich mir irgendwie merken will.

So auf die Art kommt man dann auf ein Baumdiagramm mit "Löschpfaden".
Interessant ist natürlich ganz am Ende nur bei welchem Pfad die am Ende übrig bleibende Liste am kleinsten ist.

So das vorgehen.
Nur , wenn ich dann vor der Frage stehe "Kann der i'te Tipp in der Liste gelöscht werden?" dann muss ich natürlich wieder klären ob nahc der löschung trotzdem noch genug Tipps da sind damit, egal was gezogen wird, 3 Richtige rauskommen.

Dazu stelle man sich sinnbildlich links die Lsite aller möglichen Tipps untereinander geschrieben vor.
Und rechts noch einmal.
Nun malen wir Verbindungsstriche zwischen alle Tipps links und rechts die mind. 3 Zahlen gemeinsam haben.
Klar hat jeder Tipp 3+ Gleiche mit sich selbst, aber auch mit vielen vielen anderen Tipps.

In meinem java Programm bin ich nun hingegangen und habe nicht mit 2 mal der selben Liste gearbeitet sondern nur einmal die Liste aller Tipps und bei jedem Tipp speichere ich die zugehörigen Verbindungen zu anderen Tipps in der Liste, wie viele es sind und speichere mittels eines boolean werts auch wenn ein Tipp bereits gelöscht wurde.


Shcön und gut so, aber um überall die Verbindungen eintragen zu können, muss ich in etwa 13983816 Listenelementen mit 13983815 Listenelementen "vergleichen".

Wodurch wir auf eine absurde Zahl an nötigen Vergleichen kommen da die Lsite selbst ja shcon eine Länge von 13983816 hat...

Ja, viel zu große Zahlen um da Standardmässig zu programmieren :-/
 
Ich bin mittlerweile am Verzweifeln, hat Irgendjemand eine super innovative Idee, wie man das Ganze machen kann?

Hatte auch drüber nachgedacht, statt direkt bei einem Tipp alle seine verbindungen zu speichern, stattdessen seine Menge an 3Tupel zu speichern (Also welche Kombinationen an 3 Zahlen kommen in den 6 Zahlen vor).
Dann muss jedes der 13 Millionen Listenelemente sich 6über3=20 Sachen merken.
Nur bringt das nix, weil jetzt muss ich ebenso wieder 13 Millionen Elemente mit 13 millionene Elemente vergleichen und gucken ob die beide mindestens in einem der 20 Tripel übereinstimmen....

Einfach viel zu viele Vergleiche und Co. nötig.....
 
Wobei er das ja auch im Speicher halten will. Das könnte eine Herausforderung werden. Selbst so ein XEON Platinum 8380 kann nur 6TB RAM. 🙂
Ich muss es nicht zwingend im Speicher haben.
Aber ich weiß auch nicht wo ich es irgendwie ablegen kann/sollte.

Weil ich meine, selbst wenn ich zu einem Tipp die zugehörigen Verbindungen als 13Millionen Stellen umfassende bitzahl speichern wollte, dann fidnet sich da erst gar kein Datenformat dazu.
txt kann nur ein paar Hundert Stellen.
Und .ods hat nur ein paar Hundert Spalten und Zehntausend Zeilen.
Alles zu wenig, um auch nur die Vebrindungen EINES Tipps zu speichern.
Davon ab dass ich dann 13 Millionen Dateien da hätte.

Und praktisch würde das dann vergleiche ja auch ziemlich langsam machen da ich jedes Mal aus diversen Dateien erst wieder Sachen in den Speicher einlesen muss und so.
 
Hm, aber welche Werte sollen in der 14E6 x 14E6-Matrix jetzt gespeichert werden. Ich sehe das so. Ein Array long[14E6] mit allen gültigen Permutationen in Form von Bitmustern. Das braucht für heutige Maßstäbe nicht viel Platz. Die Ergebnisse von array[a] & array[b] muss man sicher nicht speichern, weil der Rechenaufwand viel zu gering ist. Die ermittelte Zahl der 1-sen vielleicht schon eher und die benötigt nur ein Byte Speicherplatz. Unter Berücksichtigung von bestehenden Symmetrien in der Matrix komme ich aber immer noch auf etliche TB. Dann lieber keine Matrix speichern und immer schön jedesmal array[a] & array[b] oder Long.bitCount(array[a] & array[b] berechnen. Ein moderner 8-Kern-Prozessor könnte einen kompletten Durchgang vermutlich im 6 - 12 Stunden schaffen. Parallelisierbar ist diese Aufgabe ja wunderbar.
Nur fürchte ich, dass es bei einem Durchgang nicht bleiben wird.
 
Mir fiel gerade etwas auf bei dme ich hofentlich nicht falsch liege:
Eigneltich ist die Frage ja nicht mal zwingend welche der (maximal 13 millionen verschiedenen)6-tupel man loswerden kann.

Sondern eher die Frage welche 3-Tupel überflüssig sind! (Denn durch das Entfernen eines 6Tupels wirft man ja einige 3Tupel weg).
Dementsprechend wäre es vermutlich sinnvoller, mit einer vollen Lsite aller 3Tupel zu beginnen, testen welches gekickt werden kann sodass trotzdem in jeder Lottozahl eins der noch vorhandenen 3Tupel drinsteckt.
Dann könnte ich ja, wenn es der Lottoschein zulassen würde, diese zig 3Zahlen Kombis spielen.

Da es aber schließlich um 6uaus 49 geht, kann ich nun hingehen und diese 3tupels versuchen, in so wenige 6Tupels wie nur irgend möglich zu quälen.

Die resultierende Lsite an 6Tupels müsste dann die ideal Lösung sein.

Punkte die Einfluss auf die optimale Lösung haben würden:
1. in welcher reihenfolge entferne ich welche 3tupel.
2. wie stecke ich die 3tupel in 6tupel. Weil je nach "Steckweise" kommt da ja vielleicht eine größere oder kleinere ANzahl raus, wenn mans klug anstellt 🙂

Aber eigneltich, so jhoffe ich, müsste das doch funktionieren, oder?


Klar, muss ich dann immer noch eine Lsite an 3Tupeln mit der vollen 6TupelListe kreuz und quer vergleichen.
Aber statt (49 über6)^2=2*10^14 wären es dnan wenigstens nur noch (49über6)*(49über3)=257637825984, also so 2,5*10^11.
Immer noch krnakhaft viel aber wenigstens mal schon 3 Größenordnungen kleiner 🙂
 

Zurück
Oben