Optimizing the Skip Systems in Lottery, Lotto, Gambling, Horse Racing
By Ion Saliu,
Founder of: Lottery Programming Science, Lotto Mathematics
Published on August 4, 2020.
Skip Aficionados:
The skips, especially in lottery, are at the foundation of powerful systems and strategies.
The lottery skip systems have a serious drawback, however. They can generate too many numbers to play, therefore too many combinations to play.
The good news is the skip lotto systems can be optimized a great deal. That is, it is possible to generate far fewer lotto combinations to play. The optimization is not present even in my software. But I give hic et nunc a chance to the Doollows of the world to come up with their own software.
It is the least I can do for them, as I still presented my idea publicly just now. The Doollows of the world once complained in several lotto communities that I monopolized the lottery strategizing badly. So badly, that other lottery minds have no chance anymore to discover their own strategies. Well, truth be told, I have come up with quite a few lottery discoveries ever since!
Look again at the report on another page dedicated to the skip concept:
Only the lowest skips have more than 3 represented in a combination (for systems based on skip under the FFG median). My skip software generates every combination ignoring how many equal skips they contain. There is a lot of waste, as I said on the main lottery skips strategy page.
Let's exemplify how SkipSystem works in the Any Position systems. Basically, the software generates strings of numbers representing the qualifying skip values for the respective parameters (e.g. less than or equal to FFG median). Here is a sample of a skip string:
0 4 0 0 0 5 1 1 4 2 5 4 2 4 1 2 1 2 3 3 1 4 = 22 skips
The corresponding 6/49 lotto numbers are:
1 2 5 8 11 12 13 14 15 22 24 25 30 31 32 34 36 42 46 47 48 49 = 22 numbers.
The skip string above does not consist of numbers, though. It would be impossible to generate combinations, as many values are the same (e.g. 0, 1, 4). The set of numbers known as combinations has only distinct numbers in ascending order. Instead, the software creates a string of skip variables:
SK(1), SK(2), SK(5), SK(8), ... SK(47), SK(48), SK(49)
Currently, the SkipSystem grand application will generate combinations from the 22 lotto numbers, ignoring the situations with 4 or more skips of equal value.
To optimize, the program should generate first combinations of skips from the SK(i) string. Then, convert the SK(i) variables to the actual skip values (e.g. 0, 4 0 0... etc.) Next: Ignore combinations with 4 or more equal skips. Ignore even more situations, such as 0, 1, 2, 3, 4 or 1, 2, 3, 4, 5, etc. There will be a significantly lower number of combinations of skips at the end of the day.
In the example above, the 22-digit string of skips translates into 74613 total combinations. The first combination in the set does not qualify. It has 4 zeroes. A skip of 0 in this case represents a lotto number that did not miss any drawings. In other words, the number repeated from the last draw. In this situation, we would be faced with the extremely rare event of 4 lotto numbers repeating from the very last drawing. 0 4 0 0 0 5
The next 16 combinations have the same fate; the last in this predicament is
0 4 0 0 0 4 (the last digit in the string).
The next group of combinations will start with the 5 digits
0 0 0 0 5
followed by one of the next 16 digits (i.e. 1 1 4 2 ... 3 1 4). None of the combos qualifies; therefore all of them will be eliminated.
As you can see, the first 33 combinations would have been discarded of. The most common combinations — and accepted in the field of play — look like
0 4 0 5 2 1
0 4 0 5 3 3 etc.
In a 6-number lotto game, the reduction will be drastic.
Again, a qualified combination in the program will look like:
SK(1), SK(2), SK(11), SK(12), SK(22), SK(32)
In the final step, the software should convert the skip combinations to combinations of the corresponding lottery numbers. In the output file, the set appears as:
1 2 11 12 22 32
Right now, my software PermuteCombine is able to generate all possible combinations from a string of digits (or numbers). Functions: C = Combinations, then 3 = Words - Sequentially. The digit string is saved to a text file, one digit/number per line. You specify the filename and numbers per combination (e.g. 6). The software takes care of the rest. The program, however, does not eliminate anything from the set. Can you do the elimination manually?
If impatient, you could write your own software. You have the main idea clearly expressed here. And I won't blame anybody for copyright infringement!
Home | Search | New Writings | Odds, Generator | Contents | Forums | Sitemap