Ich werde nicht in Konkurrenz zu den bekannten All-Inclusive Totoprogrammen treten. Niemand, der sich damit ein wenig Geld verdient, soll durch mich zu Schaden kommen. Eher verstehe ich mich als Vorstufe für solche Werkzeuge. Besonders gern erledige ich folgende Aufgaben für euch:
Mein Nachteil ist allerdings, dass ich nur eine Konsolanwendung bin, die in C geschrieben ist. Also nix mit
Klicki-Bunti.
Auriga hat mir für den Kontakt mit euch das Konsolprogramm und Textdateien für Ein- und Ausgabe verschrieben. Aber echte
Systembastler wird das nicht schrecken, im Gegenteil, die Bedienung und Änderung der Vorgaben ist mit einem Texteditor
deutlich schneller.
Wer sich da neu mit beschäftigt und noch keinen Lieblings-Texteditor hat sollte sich einmal den Geany
ansehen. Den gibt es kostenlos, somit ist das hier auch keine verbotene Werbung.
Auriga ist seit Jahrzehnten in der IT beschäftigt und hat mit ihm endlich den passenden Editor gefunden. Er ist nicht so
überfrachtet wie eine IDE, hat aber viele sehr gute Funktionen, die besonders so faule Leute wie Auriga liebgewonnen hat.
Als Beispiel, die SUCHEN-Funktion, die nicht nur von einem Treffer zum nächsten springt, sondern auch eine Liste aller Treffer
zeigt, in der man dann durch draufklicken direkt irgendeinen Treffer aufsucht.
Ob ich unter Linux laufe kann ich nicht sagen. Da warte ich auf Antwort aus dem Forum. Verapplen
lasse ich mich aber wohl nicht.
|
Version vom 23. Apr. 2017
|
Fehler entfernt, der beim Einlesen eigener Systeme auftrat
|
|
Version vom 07. Mrz. 2017
|
deutlich verbesserte Spielplan-Anpassung
|
|
Version vom 30. Jan. 2017
|
stabiler und etwas schneller
|
|
Version vom 15. Nov. 2015
|
Optmierung auf Rang 3 oder 4 vorgesehen
|
|
Programm auri.exe
|
Das bin ich, in der Programmiersprache C geschrieben und garantiert virenfrei, auch wenn Virenscanner
Alarm schlagen. Die reagieren einfach allergisch auf .exe-Dateien
|
|
Programm nv.bat
|
Kopiert die Datei neusys.txt nach vorsys.txt , gut um eine unterbrochene Optimierung fortzusetzen.
|
|
Fenster_blau oder weiss
|
Windows-Konsolanwendungen, um mich abzufahren.
|
|
Datei vorgaben.txt
|
Mit dieser Textdatei steuert ihr meine gesamten Tätigkeiten.
|
|
Datei vorsys.txt
|
Aus dieser Textdatei lese ich eure Systeme und Bausteine ein.
|
|
Datei neusys.txt
|
In diese Textdatei schreibe ich meine Ausgabe-Systeme.
|
|
Auriga_Systembau_Hilfe.htm
|
Diese Anleitung.
|
Die Namen der Textdateien sind fest vergeben und können nicht geändert werden. Außerdem müssen sie im selben Datei-Verzeichnis wie ich liegen. Groß- oder Kleinschreibung ist in den Textdateien nicht relevant.
Jede meiner Aufgaben wird über die Textdatei vorgaben.txt gesteuert, daher wird der jeweilige Teil dieser Datei bei der
betreffenden Aufgabe mit erläutert. Damit diese Datei übersichtlich bleibt ist der Tabulator unbedingt
auf 8 zu stellen.
Die Worte, die hier auf Spalte 1 beginnen sind Schlüsselworte. Werden sie verschoben oder verändert,
ist die betreffende Steuerung nicht mehr wirksam.
*********************************************************
***** Bitte die Tabulatorweite auf 8 stellen !! *****
*********************************************************
=============== Wege- und Filter-Einstellungen =======================
----------------|....+....0....+|-----------------------|---------------.
WEGE |22233333.......| | |
----------------|---------------| | |
|
In jedem Fall müssen mir die Grundeigenschaften des ganzen gewünschten Systems bei WEGE als 1,2 oder 3 für Bank, Zweiweg oder Dreiweg
lückenlos mitgeteilt werden. Ohne das läuft gar nichts.
Bis zu 15 Spiele kann ich verdauen. Als Zählhilfe ist über dem Eingabeplatz eine Art Lineal angebracht. Diese WEGE sind für mich bindend. Sollten über die Eingabe Systemblöcke mit Dreiwegen kommen, wo in WEGE nur eine Bank, oder ein Zweiweg steht, fallen alle nicht passenden Tipps weg. Somit wird hier also ein System auf 8 Spiele mit 3 Zwei- und 5 Dreiwegen angefordert.
Zusätzlich kann die Systemauswahl noch gefiltert werden. Das teilt ihr mir wie folgt mit:
----------------|....+....0....+|-----------------------|---------------.
WEGE |1333333........| min/max | wo weiter |
----------------|---------------| | wenn |
|Name | bis 15 Spiele |Gru(1) |Aus(0) |Ueb(2) | ok |falsch |
----------------|....+....0....+|-------|-------|-------|---------------|
Filter | |x..............|11 | | | | |
Filter | |.xxxx..........|33 |11 | |sp2 |sp1 |
Filter |sp1 |.xxxx..........|22 | |22 | | |
Filter |sp2 |.....xx........|12 | | | | |
|
Meine Filtersystematik ist schon etwas tricky. Daher müsst ihr euch schon ein wenig einarbeiten. Dann könnt ihr damit aber
auch wirklich alle Möglichkeiten abfangen. Das Beispiel oben, eine Bank und 6 Dreiwege. Von den ersten 4 Dreiwegen sollen nur die
Tippbilder 3-1-0 und 2-0-2 gespielt werden. Bei den restlichen beiden muss mindestens ein Grundtipp dabei sein. Das Ergebnis kann dann
maximal dieses System mit 50 Reihen sein.
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 2 2 2 2 2 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2
1 1 1 1 1 0 0 0 0 0 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 1 1 1 1 1
0 0 0 0 0 1 1 1 1 1 2 2 2 2 2 1 1 1 1 1 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1
1 1 1 0 2 1 1 1 0 2 1 1 1 0 2 1 1 1 0 2 1 1 1 0 2 1 1 1 0 2 1 1 1 0 2 1 1 1 0 2 1 1 1 0 2 1 1 1 0 2
1 0 2 1 1 1 0 2 1 1 1 0 2 1 1 1 0 2 1 1 1 0 2 1 1 1 0 2 1 1 1 0 2 1 1 1 0 2 1 1 1 0 2 1 1 1 0 2 1 1
(In welcher Form ich Systeme sonst noch ausgebe - siehe hier)
|
Nun versuche ich die Filter mal Feld für Feld zu erklären.
Jede Filterzeile hat 8 Spalten mit folgender Bedeutung:
|
1. Filter
|
Dieses Schlüsselwort zeigt mir eine Filterzeile an
|
|
2. Name
|
Ein Eintrag hier kann als Sprungmarke aus den Feldern 'ok' und 'falsch' einer vorherigen Zeile dienen.
- ein '-' hier macht genau diese Filterzeile ungültig. - ein 'n' hier in der ersten Filterzeile macht alle Filter ungültig. Das erspart oft mühsames Löschen |
|
3. Spielauswahl
|
Dieser Filter gilt für jedes Spiel, für das ein 'x' gesetzt wird. Lücken sind möglich.
|
|
4. Filter auf Grundtipp
hier gilt immer die 1 |
Minimal und maximal erlaubte Anzahl Spiele dieses Filters
z. B. (22 = genau 2 Spiele), (03 = Null bis 3 Spiele), (810 = 8 bis 10 Spiele), (1012 = 10 bis 12 Spiele) |
|
5. Filter auf Ausweichtipp
hier gilt immer 0 oder x |
dito
|
|
6. Filter auf Überraschung
hier gilt immer die 2 |
dito
|
|
7. ok
|
Finde ich hier nichts, gehe ich zum nächsten Filter,
finde ich hier 'ok' ist das Filtern für mich komplett beendet und der Tipp wird genommen, sonst mache ich beim Filter mit diesem Namen weiter. |
|
8. falsch
|
Finde ich hier nichts, ist das Filtern für mich komplett beendet und der Tipp fliegt raus,
sonst mache ich beim Filter mit diesem Namen weiter. |
Zu den Filtern ist noch zu sagen, dass ich nicht rückwärts springen kann. Aber da ihr mir bis zu 200 solcher
Filterzeilen mitgeben könnt dürfte es nie eng werden. Durch die Sprungtechnik in den Filtern könnt ihr mir Gruppen von Filtern
mitgeben, die nur bei Bedarf aktiviert werden. Sonst lasst ihr mich einfach drüberweg springen. Das erspart euch viel
lästiges eintippen und wieder löschen.
Filtern kann ich nur per Textdatei eingegebene oder selbst gebaute Systeme und Blöcke. Für die Ausgabe nach Anpassung
der Tippzeichen an den Spielplan gibt es keine Filterung mehr. Das überlasse ich dann den professionellen Totoprogrammen.
System_bauen v Anzahl gewünschter Reihen - oder
- V = Vollsystem ausgeben
- S oder W = System aus Datei vorsys.txt lesen
S = senkrecht, W = waagerecht orientiert
|
Das ist meine leichteste Aufgabe. Das vorgegebene V gibt mir den Auftrag aus den Eingaben in WEGE, sowie den
Filtern alle zutreffenden Tippreihen zu erzeugen und als Vollsystem auszugeben. Damit kann ich alle erdenklichen Tippbilder
für die kompletten 15 Spiele zaubern. Aber Vorsicht, 15 Dreiwege schmieren schon mal 300 MB oder mehr auf die Platte.
System_bauen 24 Anzahl gewünschter Reihen - oder
- V = Vollsystem ausgeben
- S oder W = System aus Datei vorsys.txt lesen
S = senkrecht, W = waagerecht orientiert
|
Eine vorgegebene Anzahl gewünschter Reihen gibt mir den Auftrag aus den Eingaben in WEGE, sowie den
Filtern die besten der zutreffenden Tippreihen zu suchen und als System auszugeben. Ist die Anzahl größer als das
Vollsystem, gebe ich das aus und bin fertig. Sonst baue ich aus den möglichen Reihen ein Startsystem auf und starte
meine Optimierung. dort gehts weiter
System_bauen s Anzahl gewünschter Reihen - oder
- V = Vollsystem ausgeben
- S oder W = System aus Datei vorsys.txt lesen
S = senkrecht, W = waagerecht orientiert
|
Ein S oder W in Anzahl gewünschter Reihen gibt mir den Auftrag das System aus der Textdatei vorsys.txt einzulesen. Das S oder
das W steht für die Orientierung, waagerecht oder senkrecht, (wird hier genauer erklärt) der Eingabe.
Wenn ich also weiß, wie rum ich gucken muss, zeige ich meine Nehmerqualitäten. Ich bin nämlich ein ALLESFRESSER.
Sämtliche Formate der Systemeingabe schlucke ich. Beachtet werden nur die Zeichen 1,0,2 und X, der Rest wird vergessen.
Daher muss sichergestellt sein, dass die erwähnten Tippzeichen auch nur in den Tippreihen vorkommen. Sonst könnte ich
mich doch noch verschlucken.
Zusätzlich habe ich noch zwei Leckerlis, die ihr selten finden werdet.
Dafür gebt ihr mir in der Textdatei jeweils das passende Schlüsselwort ab Spalte 1 mit. SYSTEM
steht für anhängen der folgenden Tipps an das bisherige System. MULTI steht für Multiplikation
des bisherigen Systems mit den folgenden Spielen. Das ist zwar schon etwas tricky aber wer sich da richtig eingefuchst hat,
kann diese Optionen sogar mehrfach nacheinander, auch gemischt, anwenden.
Hier mal ein paar Beispiele, vorausgesetzt wird immer, dass WEGE und Filter richtig gesetzt sind. Die Ausgabe in den Beispielen
ist der Einfachheit halber immer im waagerechten Format. Nicht wundern, das Ausgabesystem sortiere ich jeweils neu,
daher ist die Reihenfolge der Tipps abweichend von den Original-Blöcken.
Drei Blöcke mit jeweils 4 Spielen verkette ich zu einem System mit allen 16 Tippreihen,
Eingabe-Orientierung waagerecht.
vorsys.txt neusys.txt
_1110 1111111110000222
_1101 1111000221110112
_1011 1002110121101121
_0111 0102101211011211
system
_111000
_100110
_010101
_001011
system
1 1 1 2 2 2
1 2 2 1 1 2
2 1 2 1 2 1
2 2 1 2 1 1
|
Zwei Blöcke mit Garantie -1 mit jeweils 3 Spielen multipliziere ich zu einem Block mit Garantie -2 in 6 Spielen,
Eingabe-Orientierung waagerecht.
vorsys.txt neusys.txt
1x 1111100000
x1 0000011111
x1 0000011111
multi 1100211002
_11002 0202102021
_02021 2002120021
_20021
|
Die gleichen Blöcke, diesmal mit senkrechter Eingabe-Orientierung.
vorsys.txt neusys.txt
100 1111100000
011 0000011111
multi 0000011111
1,0,2 1100211002
1,2,0 0202102021
0,0,x 2002120021
x,2,2
2 1 1
|
wie_oft u Anzahl der Optimierungs-Versuche (U = unbegrenzt ~ 2 Mrd.)
Anlauf-Zeit 30 erfolglose Sekunden bis ein neuer Anlauf gestartet wird
Ziel-Rang 2 bevorzugt auf diesen Rang optimieren
|
Hier versuche ich durch verschiedene Methoden das gespeicherte System auf möglichst gute Rangtreffer zu optimieren. Das ist
sehr rechenintensiv und läuft nicht auf jedem Computer gleich schnell. Ihr müss ausprobieren, was euer Rechner hergibt.
Theoretisch kann ich bis 20000 Tippreihen und bis zu 15 Dreiwege berechnen, aber selbst Auriga, mit I7-Prozessor kommt
früher an seine Grenzen. So 1000 Tipps mit gut gefilterten 13 Dreiwegen sind bei ihm noch bequem machbar.
Die Qualität ist auch recht gut,
aber er ist noch nicht ganz zufrieden und tunt mich ab und zu noch etwas.
Die Systeme baue ich über die Anzahl Reihen auf, nicht nach irgendwelchen Rang-Garantien. Trotzdem sind die Reihen
schon nach kurzer Zeit sehr optimal verteilt.
Nun zum Ablauf meiner Optimierung. Durch zufällige und andere Berechnungen verändere ich mein System und überprüfe jedesmal
ob es besser geworden ist. Wenn ja wird das komplette System in die Datei neusys.txt geschrieben. Anderenfalls wird
dieser Versuch verworfen und ein neuer gestartet. Dadurch enthält neusys.txt immer den besten Zustand und steht im Falle
eines Absturzes noch zur Verfügung.
Über wie_oft kann ich nach einer bestimmten Anzahl Versuche
gestoppt werden. Eine 0 hier sagt mir, dass ich das aktuelle gebaute System unverändert ausgeben soll. Damit, und über die
Ausgabesteuerung, lässt sich jedes System blitzschnell nach Wunsch umformatieren.
Die Anlauf-Zeit hat Auriga eingeführt, weil ich mich mit manchen Optimierungs-Methoden festfresse
und immer zu den gleichen Ergebnissen komme. Dann gehe ich nach Ablauf der hier hinterlegten Sekunden auf das zweitbeste Ergebnis
zurück und kann somit auf Umwegen zu besseren Ergebnissen kommen. Je nach Größe des Systems oder der Tippanzahl, ist hier
manchmal ein längerer Zeitraum angebracht. Kleine Systeme kommen auch mit 5 Sekunden aus, bei ganz großen ist es besser,
ohne Unterbrechung zu arbeiten. Dann hier 99999 eingeben - einfach ausprobieren.
Mit einer 3 oder 4 bei Ziel-Rang bekomme ich die Anweisung, von meiner normalen Optimierung abzuweichen.
Ich versuche dann möglichst viele Treffer auf diesen gewünschten Rang zu bringen. Dabei werden aber die höheren Ränge
nicht immer optimal belegt.
Diese 3 Vorgaben sind auch während die Optimierung läuft
änderbar. Ich lese nämlich alle 5 Sekunden die Datei vorgaben.txt neu ein und setze diese drei Parameter neu
14:19:27 Auriga Systembau - Version vom 12.4.2015 um 14:19 optimiert 6 Spiele mit 73 von 729 moeglichen Reihen
- Optimum Rang 2 = 656 (nur wenn ungefiltert)
Uhrzeit | Bester Rang | Proz. incl. hoeherer Raenge | T-Wert Rest Versuche Sek |
---------|----------------------------|-------------------------------|---------------------------------|
14:19:27 | 73 500 156 0 | 10.01 78.60 100.00 100.00 | 65248 0 0 0 |
14:19:27 | 73 503 153 0 | 10.01 79.01 100.00 100.00 | 65608 0 3 0 |
14:19:27 | 73 505 151 0 | 10.01 79.29 100.00 100.00 | 65848 0 9 0 |
14:19:27 | 73 507 149 0 | 10.01 79.56 100.00 100.00 | 66088 0 11 0 |
14:19:27 | 73 508 148 0 | 10.01 79.70 100.00 100.00 | 66208 0 17 0 |
14:19:27 | 73 510 146 0 | 10.01 79.97 100.00 100.00 | 66448 0 20 0 |
|
So etwa sieht mein Start aus. Im Kopf zeige ich welche Version von mir läuft und was ich tue,
In diesem Beispiel versuche ich das legendäre 73-Reihen-System für 6 Dreiwege auf Garantie -1 aus dem Nichts zu erstellen.
Zusätzlich zeige ich das Optimum für den 2. Rang an, was aber nur ohne Filter richtig ist.
Dann protokolliere ich ab Startsystem jede Verbesserung.
neuer Anlauf nach 5 Sekunden ohne Verbesserung - V/sek = 38007
Uhrzeit | Bester Rang | Proz. incl. hoeherer Raenge | T-Wert Rest Versuche Sek |
---------|----------------------------|-------------------------------|---------------------------------|
14:20:40 | 73 639 17 0 | 10.01 97.67 100.00 100.00 | 81928 0 2774515 73 |
14:20:40 | 73 636 20 0 | 10.01 97.26 100.00 100.00 | 81568 0 2774515 73 |
14:20:40 | 73 637 19 0 | 10.01 97.39 100.00 100.00 | 81688 0 2775687 73 |
14:20:40 | 73 638 18 0 | 10.01 97.53 100.00 100.00 | 81808 0 2780294 73 |
14:20:40 | 73 639 17 0 | 10.01 97.67 100.00 100.00 | 81928 0 2781076 73 |
14:20:41 | 73 640 16 0 | 10.01 97.81 100.00 100.00 | 82048 0 2843263 74 |
|
Und so sieht es etwas später aus. Ich habe mich festgefressen und nehme einen neuen Anlauf. Daneben zeige ich meine Geschwindigkeit in Versuchen je Sekunde an. Und wie man an den Rangwerten sieht, ist die Optimierung schon deutlich fortgeschritten.
======================================================================
===== ab hier N U R noch zur AUSGABE-Steuerung des Systems =====
======================================================================
Orientierung w W oder S für waagerecht oder senkrecht
Vorspann _ N = nichts, T = TAB, L = Leerstelle, sonst beliebiges Zeichen
Trenn-Zeichen l N = nichts, T = TAB, L = Leerstelle, sonst beliebiges Trenn-Zeichen
Trenn-Abstand 0 wenn nicht Null - nach sovielen Spielen kommt ein Trenn-Zeichen
System_zeigen n J oder N (System-Ausgabe am Monitor nach jeder Verbesserung ja oder nein)
--------------------------------------------------------------------------------------------
- Spielplan-Anpassung je Spiel (GAU) 1. Grundtipp, 2. Ausweichtipp, 3. Überraschung
--------------------------------------------------------------------------------------------
Spielplan-Nr. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
aus_Systemspiel 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
102_wird_zu 102 102 102 102 102 102 102 102 102 102 102 102 102 102 102
--------------------------------------------------------------------------------------------
|
Die Orientierung legt fest, wie das System angeordnet ist. Hier folgt ein Beispiel des selben
Systems mit 4 Dreiwegen zu 8 Tippreihen in senkrechter und waagerechter Darstellung.
senkrechte
Darstellung
1121
1002
1201
0112
0020
0210
2110
2001
|
waagerechte
Darstellung
11100022
10210210
20012110
12120001
|
Vorspann, Trenn-Zeichen und Trenn-Abstand sind in der Vorgabe-Datei eigentlich ausreichend erklärt.
Der Vorspann ist ganz gut beim Import nach Excel, damit bei 0 am Anfang nicht eine Exponential-Zahl erzeugt wird.
Bei Trenn-Abstand 0 trenne ich gar nicht, egal was als Trennzeichen steht. Hier heißt es einfach: probiert mal ein wenig rum.
Und zum Rumprobieren ist auch System_zeigen vorgesehen. Bei J zeige ich das System, getreu zur Ausgabe am
Monitor, so dass ihr nicht jedesmal in der Datei neusys.txt nachsehen müsst.
Der Block Spielplan-Anpassung ist nur für die Herstellung eines fertigen Tipps mit dem aktuellen Spielplan gedacht.
Bei der eigentlichen Systementwicklung solltet ihr hier höchstens 0 und x tauschen, denn sonst
könnt ihr nach Unterbrechung oder Absturz das Ergebnis nicht mehr als neue Eingabe nutzen, da ich den Grundtipp nicht mehr als solchen
erkenne. Bei der Eingabe gilt nämlich immer Grundtipp=1, Ausweichtipp=0/x und Überraschung=2.
Für meine Beispiele nehme ich folgenden Spielplan. 5 Bankspiele, 4 Zwei- und 4 Dreiwege für die Paarungen sind schon bestimmt.
Gespielt werden 24 Reihen und bei den Dreiwegen dürfen maximal 2 Überraschungen eintreffen.
----------------------------------------------------------
01 Bayern München - Eintracht Frankfurt 1
02 Hertha BSC Berlin - Borussia Dortmund 0 2
03 SV Darmstadt 98 - 1. FSV Mainz 05 2
04 SC Freiburg - 1899 Hoffenheim 0 2
05 RB Leipzig - VfL Wolfsburg 1 0
06 FC Ingolstadt 04 - 1. FC Köln 1 0 2
07 FC Schalke 04 - FC Augsburg 1
08 Hamburger SV - Bor. Mönchengladbach 1 0 2
09 1. FC Nürnberg - Arminia Bielefeld 1
10 1. FC Kaiserslautern - 1. FC Heidenheim 1 0 2
11 SV Sandhausen - SpVgg Greuther Fürth 1 2
12 Inter Mailand - Atalanta Bergamo 1
13 Sassuolo Calcio - FC Bologna 2 1 0 *
----------------------------------------------------------
* im Spiel 13 gilt die Null als Überraschung
|
In den Vorgaben für die WEGE gebt ihr mir schon gleich die Bankspiele, Zwei- und Dreiwege jeweils an der richtigen Position laut Spielplan mit.
Dann setzt ihr den Filter auf die Dreiwege für maximal 0 bis 2 Überraschungen, dazu dann noch die Reihenanzahl. Für unser Beispiel
sieht das dann so aus:
=============== Wege- und Filter-Einstellungen =======================
----------------|....+....0....+|-----------------------|---------------.
WEGE |1212231313213..| min/max | wo weiter |
----------------|---------------| | wenn |
|Name | bis 15 Spiele |Gru(1) |Aus(0) |Ueb(2) | ok |falsch |
----------------|....+....0....+|-------|-------|-------|---------------|
Filter | |.....x.x.x..x..| | |02 | | |
----------------|....+....0....+|---------------------------------------'
System_bauen 24 Anzahl gewuenschter Reihen - oder
|
Nun zur Ausgabe. Die Reihen sollen auf Totoscheinen angekreuzt werden. Dafür ist die waagerechte Ausgabe bestens geeignet und damit das
Abschreiben nicht zur Qual wird empfehle ich, eine Leerstelle alle 4 Ziffern einzuschieben.
Das kann mir in der Ausgabesteuerung so mitgeteilt werden:
======================================================================
===== ab hier N U R noch zur AUSGABE-Steuerung des Systems =====
======================================================================
Orientierung w W oder S für waagerecht oder senkrecht
Vorspann n N = nichts, T = TAB, L = Leerstelle, sonst beliebiges Zeichen
Trenn-Zeichen l N = nichts, T = TAB, L = Leerstelle, sonst beliebiges Zeichen
Trenn-Abstand 4 wenn nicht Null - nach sovielen Spielen kommt ein Trenner
|
Fehlt noch die Zuordnung der richtigen Tippzeichen auf die Spiele. Hierzu bekomme ich je Spiel die Tippzeichen in der Reihenfolge 'GAU'
mitgeteilt. Hier ist es VW (völlig Wurscht) ob mir nur ein, oder immer alle 3 Tippzeichen mitgeteilt werden.
Ich nehme immer das erste für eine Bank und die ersten beiden für einen Zweiweg. Wers übersichtlicher mag,
lässt immer 3 Ziffern stehen.
Für dieses Beispiel zeige ich es jetzt mal so:
--------------------------------------------------------------------------------------------
- Spielplan-Anpassung je Spiel (GAU) 1. Grundtipp, 2. Ausweichtipp, 3. Überraschung
--------------------------------------------------------------------------------------------
Spielplan-Nr. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
aus_Systemspiel 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
102_wird_zu 1 02 2 02 10 102 1 102 1 102 12 1 210 102 102
--------------------------------------------------------------------------------------------
|
... und nun brauche ich noch etwas Zeit, um über die Optimierung einen guten Tipp zu generieren. Der wird
dann so oder ähnlich aussehen:
1111 1111 1111 1111 1111 1111
0000 0000 0002 2222 2222 2222
2222 2222 2222 2222 2222 2222
0000 0222 2220 0000 0022 2222
1100 0111 0001 1100 0011 1000
1211 0100 1020 0211 0211 2102
1111 1111 1111 1111 1111 1111
1002 2210 0110 2010 1102 1120
1111 1111 1111 1111 1111 1111
0021 1021 1202 0121 1021 1000
1122 1222 1121 2221 2111 1212
1111 1111 1111 1111 1111 1111
0121 2210 0221 2212 0121 2011
|
Nicht wenige Totospieler haben aber fertige Systeme, die sie nur noch für den aktuellen Spielplan umstellen müssen.
Das kann ich ihnen sehr erleichtern. Mir ist es egal, ob im gespeicherten System die Null oder das 'x' für Remis steht.
Das System wird mir über die Datei vorsys.txt bekannt gemacht. Solche Systeme sind aber nach
Zwei- und Dreiwegen sortiert und meistens
ohne die Bankspiele abgespeichert. Der Einfachheit halber soll hier mal derselbe Spielplan
wie für Beispiel 1 gelten.
Wie das mit mir zu lösen ist, beschreibe ich hier.
Dazu wird mir in den Vorgaben unter "System_bauen" statt der Reihenanzahl
'w' oder 's' für die Orientierung mitgegeben. Ich weiß dann, dass ich mir das System aus vorsys.txt holen muss.
Jetzt muss ich natürlich noch wissen, wie die WEGE der Systemzeilen verteilt sind. Wenn die Bankspiele noch fehlen kann man sie
mit multi vor oder hinter den anderen Systemzeilen platzieren. Für unser Beispiel hänge ich sie
einfach hinten an.
Bei waagerechter Orientierung sieht vorsys.txt dann beispielsweise so aus: Erst das gespeicherte System
mit den 4 Zweiwegen und
4 Dreiwegen und dann die 5 Bankspiele.
111111111111000000000000
111111000000111111000000
111000111000111000111000
110110100100100100110110
121100010102102211102020
101202220010201110010012
112021011200100012021110
210111012020021001210210
multi
1
1
1
1
1
|
Ist das System senkrecht abgespeichert, sieht meine benötigte vorsys.txt zum Anhängen der 5 Bankspiele so aus:
11111112
11112011
11101120
11011201
11010021
11000211
10110200
10101211
10100012
10011020
10000102
10002000
01111210
01100002
01102101
01012100
01001110
01001021
00111002
00110121
00102010
00010012
00012111
00000200
multi
11111
|
Die WEGE brauche ich trotzdem in den Vorgaben für die Tippzeichen-Zuordnung aber keine Filter mehr. Da ja keine Optimierung mehr laufen soll,
ist unter 'wie oft' eine Null einzusetzen. Die relevanten oberen Zeilen der Datei vorgaben.txt sehen für unser Beispiel also so aus:
=============== Wege- und Filter-Einstellungen =======================
----------------|....+....0....+|-----------------------|---------------.
WEGE |2222333311111..| min/max | wo weiter |
----------------|---------------| | wenn |
|Name | bis 15 Spiele |Gru(1) |Aus(0) |Ueb(2) | ok |falsch |
----------------|....+....0....+|-------|-------|-------|---------------|
----------------|....+....0....+|---------------------------------------'
System_bauen w oder s je nach Orienierung des Systems aus vorsys.txt
wie_oft 0 Anzahl der Optimierungs-Versuche (U = unbegrenzt ~ 2 Mrd.)
|
Etwas anspruchsvoller wird aber jetzt die Ausgabesteuerung. Da das System und der Spielplan ja nicht dieselbe Reihenfolge haben können,
ist hier jedes Spiel des Spielplans mit einem Systemspiel zu 'verheiraten'. Ich bin mal ganz frech und gehe 83 Jahre in die Zukunft.
Dann wird Lotto wohl endlich in der Lage sein, Textdateien statt Tippzettel anzunehmen. Die Ausgabesteuerung unseres Beispiels sähe im Jahre 2200
dann so aus, wie heute schon bei Supertoto üblich:
======================================================================
===== ab hier N U R noch zur AUSGABE-Steuerung des Systems =====
======================================================================
Orientierung s W oder S für waagerecht oder senkrecht
Vorspann n N = nichts, T = TAB, L = Leerstelle, sonst beliebiges Zeichen
Trenn-Zeichen , N = nichts, T = TAB, L = Leerstelle, sonst beliebiges Zeichen
Trenn-Abstand 1 wenn nicht Null - nach sovielen Spielen kommt ein Trenner
--------------------------------------------------------------------------------------------
- Spielplan-Anpassung je Spiel (GAU) 1. Grundtipp, 2. Ausweichtipp, 3. Überraschung
--------------------------------------------------------------------------------------------
Spielplan-Nr. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
aus_Systemspiel 9 1 10 2 3 5 11 6 12 7 4 13 8 14 15
102_wird_zu 1 x2 2 x2 1x 1x2 1 1x2 1 1x2 12 1 21x 102 102
--------------------------------------------------------------------------------------------
|
... und schon zaubere ich nach neusys.txt eine 'Supertoto-fähige' Datei.
1,X,2,X,1,1,1,1,1,1,1,1,X
1,X,2,X,1,2,1,X,1,1,1,1,2
1,X,2,X,1,1,1,1,1,2,2,1,1
1,X,2,X,X,1,1,2,1,X,1,1,2
1,X,2,X,X,X,1,X,1,2,1,1,2
1,X,2,X,X,X,1,2,1,1,2,1,2
1,X,2,2,1,X,1,2,1,X,1,1,1
1,X,2,2,1,1,1,2,1,1,2,1,2
1,X,2,2,1,X,1,X,1,1,2,1,X
1,X,2,2,X,1,1,X,1,2,1,1,1
1,X,2,2,X,X,1,1,1,X,2,1,X
1,X,2,2,X,2,1,X,1,X,2,1,1
1,2,2,X,1,1,1,2,1,1,1,1,1
1,2,2,X,1,X,1,X,1,X,2,1,X
1,2,2,X,1,2,1,1,1,X,2,1,2
1,2,2,X,X,2,1,1,1,X,1,1,1
1,2,2,X,X,1,1,1,1,1,2,1,1
1,2,2,X,X,1,1,X,1,2,2,1,2
1,2,2,2,1,1,1,X,1,X,1,1,X
1,2,2,2,1,X,1,1,1,2,1,1,2
1,2,2,2,1,2,1,X,1,1,2,1,1
1,2,2,2,X,X,1,X,1,1,1,1,X
1,2,2,2,X,2,1,1,1,1,1,1,2
1,2,2,2,X,X,1,2,1,X,2,1,1
|
So nun aber ran an die Tasten. Übt fleißig mit mir, auch erstmal mit kleinen bekannten Systemen. Auriga erwartet sehnsüchtig eure
Rückmeldungen und neue Anregungen wie er mich verbessern kann.
Und außerdem wünscht er allen Totofreunden viel Spaß und natürich viel Erfolg mit mir.