**Processing Logic For Minimum Appearances**

Track all spins until 616 spins are accumulated and perform a rolling 616 history.

Search spin history for each instance of x numbers in y spins, until y spins exceeds the number of recorded spins (if applicable):

EXAMPLE: x is 10 numbers. First iteration is appearances of 0 + 1 + 2 + 3 + 4 + 5 + 6 +7 +8 +9 must be less than y spin requirement. Second iteration is 0 + 1 + 3 + 4 + 5 + 6 +7 +8 +9 +10...

**Full Iteration Sample**

0 1 2 3 4 5 6 7 8 9

0 1 3 4 5 6 7 8 9 10

0 1 4 5 6 7 8 9 10 11

0 1 5 6 7 8 9 10 11 12

0 1 6 7 8 9 10 11 12 13

0 1 7 8 9 10 11 12 13 14

0 1 8 9 10 11 12 13 14 15

0 1 9 10 11 12 13 14 15 16

0 1 10 11 12 13 14 15 16 17

0 1 11 12 13 14 15 16 17 18

0 1 12 13 14 15 16 17 18 19

0 1 13 14 15 16 17 18 19 20

0 1 14 15 16 17 18 19 20 21

0 1 15 16 17 18 19 20 21 22

0 1 16 17 18 19 20 21 22 23

0 1 17 18 19 20 21 22 23 24

0 1 18 19 20 21 22 23 24 25

0 1 19 20 21 22 23 24 25 26

0 1 20 21 22 23 24 25 26 27

0 1 21 22 23 24 25 26 27 28

0 1 22 23 24 25 26 27 28 29

0 1 23 24 25 26 27 28 29 30

0 1 24 25 26 27 28 29 30 31

0 1 25 26 27 28 29 30 31 32

0 1 26 27 28 29 30 31 32 33

0 1 27 28 29 30 31 32 33 34

0 1 28 29 30 31 32 33 34 35

0 1 29 30 31 32 33 34 35 36

0 2 3 4 5 6 7 8 9 10

0 3 4 5 6 7 8 9 10 11

0 4 5 6 7 8 9 10 11 12

0 5 6 7 8 9 10 11 12 13

0 6 7 8 9 10 11 12 13 14

0 7 8 9 10 11 12 13 14 15

0 8 9 10 11 12 13 14 15 16

0 9 10 11 12 13 14 15 16 17

0 10 11 12 13 14 15 16 17 18

0 11 12 13 14 15 16 17 18 19

0 12 13 14 15 16 17 18 19 20

0 13 14 15 16 17 18 19 20 21

0 14 15 16 17 18 19 20 21 22

0 15 16 17 18 19 20 21 22 23

0 16 17 18 19 20 21 22 23 24

0 17 18 19 20 21 22 23 24 25

0 18 19 20 21 22 23 24 25 26

0 19 20 21 22 23 24 25 26 27

0 20 21 22 23 24 25 26 27 28

0 21 22 23 24 25 26 27 28 29

0 22 23 24 25 26 27 28 29 30

0 23 24 25 26 27 28 29 30 31

0 24 25 26 27 28 29 30 31 32

0 25 26 27 28 29 30 31 32 33

0 26 27 28 29 30 31 32 33 34

0 27 28 29 30 31 32 33 34 35

0 28 29 30 31 32 33 34 35 36

It is apparent that to cover all possible combinations of numbers for analysis, each element in the list must be cycled through sequentially until the second to last digit is reached; so 10 numbers will cycle 0-35 sequentially to cover all combinations. This creates a problem when say 30 or even 36 numbers must be cycled through sequentially because it is a massive 36 element loop network which is so cumbersome that it is not useful due to the time it takes to cycle through the elements. If it were only possible to create a virtual loop network...

One logical angle of approach is that only the numbers that are less than the minimum requirement need be considered; so all numbers that have equal or greater appearances than the requirement are not examined.

Maybe an array that contains everything can solve this:

(x,y)

Where x is the numbers 0-36 that tallies each appearance in y spins; +1 for each appearance. y is the number of spins 1-616. Only specific results in y need to be sampled around the static minimum requirements; such as, say, a possible 65 appearances in 200 spins of 18 numbers -- if 200 spins is genuinely the demarcation line for 65 appearances, this means that y need not be sampled again until the actual demarcation line for 66 appearances (which may be, say, 225 spins) and need not be sampled previously until the actual demarcation line for 64 appearances (which may be, say, 175 spins).

The minimum requirement for an active number combination is the number itself; e.g. using our previous 18 numbers, 18 numbers must be identified that are lower than the minimum appearance level for the number of spins that are being examined and each number adds to the tally which must also remain lower than the minimum appearance level, or the level is skipped.

Active number combinations are output in the form of each number that is less than the minimum requirement, for visual inspection as: NUMBER,APPEARANCES to contain all eligible numbers.

Maybe the solution is to only work with the maximum number of spins accrued. So that if we have 100 spins, we only check the numbers 0-36 for the single minimum appearance figure for 100 spins; ultimately all checks this way would eventually end up being for 616 spins.

The combination of only eligible sets of numbers and using only the maximum number of spins accrued should solve this processing issue.

Output highest percentage of "hits" for each number instance for visual tracking.

If instance meets minimum requirement, output:

SET -- [numbers a,b,c etc] [x total appearances] in [y total spins]

Output for each found instance.

**NEW IDEA: Instead of processing every possible combination of numbers, why not just sort the list of 37 numbers from lowest appearances to highest and only analyze the lowest numbers? If the lowest numbers will not work then neither can any other combination of numbers!**

Analyze X [lowest] numbers of appearances in Y number of spins.

1 [lowest] in 1 appearance in 616 (skip if not 616- target spins accrued)

2 in 2-11 appearances/target spins (skip if not minimum target spins accrued)

...

1) Sort all numbers from lowest appearances to highest appearances

2) Analyze numbers from 1 to 35, using lowest appearances, against spins

2a)