Ich stelle mich vor - Auriga_Systembau für die Toto-Ergebniswette

 

Themen-Übersicht

Begrüßung
Was ist neu ?
Meine wichtigsten Bestandteile
Was kann ich ?
Filtern
Vollsystem aus dem Nichts zaubern
System über Reihenanzahl erzeugen und optimieren
System aus Textdatei bauen und optimieren
Meine Optimierung
Mein Auswertungs-Protokoll
Formatierung meiner Ausgabe

2 Beispiele - fertigen Tipp für aktuellen Spielplan erstellen
1. aus neuem System
2. aus fertigem System

Zu guter Letzt

<>


Meine lieben Totofreunde

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.

zur Übersicht

<>


Was ist neu ?


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

zur Übersicht

<>


Meine wichtigsten Bestandteile


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.


zur Übersicht

<>


Was kann ich ?


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.


zur Übersicht

<>


Filtern


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.

zur Übersicht

<>


Ein Vollsystem aus dem Nichts zaubern



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.


zur Übersicht

<>


System über Reihenanzahl erzeugen und optimieren



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 aus Textdatei bauen und optimieren



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
      

Mit dem so zusammengebastelten System geht es dann in meine Optimierung.


zur Übersicht

<>


Meine Optimierung



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


zur Übersicht

<>


Mein Auswertungs-Protokoll



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.


zur Übersicht

<>


Formatierung meiner Ausgabe



======================================================================
=====  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.


zur Übersicht

<>


2 Beispiele - fertigen Tipp für aktuellen Spielplan erstellen


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
      

Beispiel 1 - ganz neues System gezielt nur für diesen Spieltag erstellen:


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
      


zur Übersicht

Beispiel 2 - vorhandenes System für diesen Spieltag nutzen:


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
      



Zu guter Letzt


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.


zur Übersicht

<>