Bruno Cintra

March 2

Em 29/02/2024 em 08:25, iziplay disse:

Matriz por zona abreviada.
21 números em 7 zonas com 3 números cada;
garantia: 3 se 3 (100%) ou 4 se 5 (90,67%) x 1 de 3; Matriz com 6 números por linha
Autor: Alessandro Jurcovich

Zonas:

Zona #1 números: 01 02 03 Min= 0 | Max= 1
Zona #2 números: 04 05 06 Min= 0 | Max= 1
Zona #3 números: 07 08 09 Min= 0 | Max= 1
Zona #4 números: 10 11 12 Min= 0 | Max= 1
Zona #5 números: 13 14 15 Min= 0 | Max= 1
Zona #6 números: 16 17 18 Min= 0 | Max= 1
Zona #7 números: 19 20 21 Min= 0 | Max= 1

Matriz com 66 linhas
1 2 4 12 14 16
1 3 5 10 14 20
1 4 6 9 12 21
1 4 7 10 18 20
1 4 8 11 17 19
1 4 8 13 15 20
1 4 9 12 13 16
1 5 6 10 13 17
1 5 7 15 17 21
1 5 8 12 15 18
1 5 9 10 15 19
1 5 11 15 16 20
1 6 7 10 15 16
1 6 7 11 14 20
1 6 8 14 18 19
1 6 9 10 17 21
1 7 12 13 16 19
1 8 10 14 16 21
1 9 11 13 18 21
1 9 12 14 17 20
2 3 4 5 13 15
2 4 7 12 15 20
2 4 8 15 16 19
2 4 9 11 15 17
2 4 10 15 18 21
2 5 6 8 10 14
2 5 6 8 17 20
2 5 7 11 16 21
2 5 9 12 18 19
2 6 7 13 18 21
2 6 9 11 13 19
2 6 9 14 16 21
2 6 12 15 17 19
2 7 10 14 17 19
2 8 11 14 18 20
2 8 12 13 17 21
2 9 10 13 16 20
3 4 6 11 13 16
3 4 7 14 16 20
3 4 8 12 14 19
3 4 9 10 14 18
3 4 11 14 17 21
3 5 7 10 13 21
3 5 8 9 18 21
3 5 8 11 13 16
3 5 9 13 17 19
3 5 12 13 18 20
3 6 7 10 16 19
3 6 7 12 14 17
3 6 8 11 15 21
3 6 9 11 18 20
3 7 11 15 18 19
3 8 10 15 17 20
3 9 12 15 16 21
4 5 7 9 19 20
4 5 10 11 12 18
4 5 10 12 16 17
4 7 8 13 16 21
4 7 11 13 17 20
4 8 10 13 18 19
5 6 8 11 14 17
5 6 8 12 18 19
5 7 12 14 18 21
5 9 11 14 16 19
6 8 12 13 16 20
6 9 10 15 18 20

não entendi se cada zona esta com maximo 1,porque que aparece em algumas linhas dois numeros da zona

January 26

sim,creio que a chance aumenta bastante,é claro que se fizer um fechamento com elas os trevos vai ter ser meio aleatorio ou jogar com todos trevos com as apostas de seis numeros a 90,00 reais ,ai seria bom para bolão.

January 26

01 02 03 04 05 06 07 08 09 10 11 12 15 16 17 18 19 20 27 28 31 32 33 34 35 36 37 38 43 44
01 02 03 04 05 06 07 08 09 10 11 12 15 16 19 20 21 22 27 28 29 30 37 38 39 40 41 42 45 46
01 02 03 04 05 06 07 08 09 10 11 12 17 18 19 20 25 26 29 30 35 36 39 40 41 42 43 44 47 48
01 02 03 04 05 06 07 08 09 10 11 12 23 24 25 26 29 30 31 32 35 36 39 40 41 42 45 46 49 50
01 02 03 04 05 06 07 08 09 10 13 14 15 16 21 22 25 26 27 28 29 30 33 34 35 36 37 38 39 40
01 02 03 04 05 06 07 08 09 10 13 14 17 18 19 20 21 22 23 24 25 26 41 42 43 44 45 46 49 50
01 02 03 04 05 06 07 08 09 10 13 14 17 18 25 26 27 28 31 32 37 38 41 42 43 44 45 46 47 48
01 02 03 04 05 06 07 08 09 10 15 16 19 20 21 22 25 26 31 32 33 34 35 36 41 42 45 46 47 48
01 02 03 04 05 06 07 08 09 10 15 16 23 24 27 28 33 34 35 36 37 38 41 42 45 46 47 48 49 50
01 02 03 04 05 06 07 08 11 12 13 14 15 16 17 18 25 26 27 28 29 30 35 36 39 40 47 48 49 50
01 02 03 04 05 06 07 08 11 12 13 14 15 16 23 24 25 26 27 28 31 32 35 36 37 38 43 44 47 48
01 02 03 04 05 06 07 08 11 12 13 14 23 24 27 28 29 30 31 32 33 34 35 36 39 40 41 42 43 44
01 02 03 04 05 06 07 08 13 14 17 18 19 20 27 28 29 30 33 34 39 40 41 42 45 46 47 48 49 50
01 02 03 04 05 06 07 08 15 16 17 18 25 26 31 32 33 34 37 38 39 40 41 42 43 44 47 48 49 50
01 02 03 04 05 06 09 10 11 12 13 14 15 16 17 18 21 22 23 24 27 28 35 36 41 42 45 46 49 50
01 02 03 04 05 06 09 10 11 12 13 14 19 20 21 22 25 26 29 30 33 34 37 38 39 40 43 44 49 50
01 02 03 04 05 06 09 10 11 12 21 22 25 26 27 28 31 32 33 34 41 42 43 44 45 46 47 48 49 50
01 02 03 04 05 06 11 12 13 14 17 18 19 20 21 22 23 24 25 26 27 28 33 34 43 44 47 48 49 50
01 02 03 04 05 06 11 12 15 16 17 18 19 20 21 22 23 24 29 30 31 32 35 36 37 38 39 40 47 48
01 02 03 04 05 06 13 14 15 16 19 20 21 22 27 28 31 32 33 34 35 36 37 38 43 44 47 48 49 50
01 02 03 04 05 06 15 16 21 22 23 24 25 26 29 30 35 36 37 38 39 40 41 42 43 44 45 46 49 50
01 02 03 04 07 08 09 10 11 12 13 14 15 16 17 18 29 30 33 34 35 36 39 40 41 42 45 46 47 48
01 02 03 04 07 08 09 10 11 12 13 14 19 20 25 26 33 34 35 36 39 40 41 42 43 44 45 46 49 50
01 02 03 04 07 08 11 12 13 14 15 16 17 18 25 26 29 30 31 32 35 36 37 38 39 40 43 44 49 50
01 02 03 04 07 08 11 12 13 14 15 16 19 20 21 22 25 26 33 34 35 36 37 38 41 42 45 46 49 50
01 02 03 04 07 08 11 12 13 14 17 18 19 20 21 22 23 24 25 26 31 32 33 34 37 38 43 44 47 48
01 02 03 04 07 08 11 12 15 16 17 18 19 20 25 26 27 28 35 36 41 42 43 44 45 46 47 48 49 50
01 02 03 04 07 08 11 12 17 18 19 20 29 30 31 32 33 34 37 38 39 40 41 42 43 44 45 46 49 50
01 02 03 04 07 08 13 14 15 16 17 18 19 20 21 22 23 24 27 28 29 30 35 36 39 40 43 44 49 50
01 02 03 04 07 08 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 37 38 39 40 47 48 49 50
01 02 03 04 09 10 11 12 13 14 15 16 19 20 23 24 31 32 33 34 35 36 41 42 43 44 45 46 49 50
01 02 03 04 09 10 11 12 15 16 21 22 25 26 29 30 31 32 33 34 35 36 39 40 43 44 47 48 49 50
01 02 03 04 09 10 11 12 17 18 19 20 21 22 23 24 27 28 31 32 37 38 41 42 45 46 47 48 49 50
01 02 03 04 09 10 13 14 15 16 17 18 19 20 21 22 33 34 35 36 37 38 39 40 43 44 45 46 47 48
01 02 03 04 09 10 13 14 15 16 19 20 21 22 23 24 25 26 27 28 29 30 35 36 41 42 47 48 49 50
01 02 03 04 09 10 13 14 19 20 21 22 25 26 29 30 31 32 39 40 41 42 43 44 45 46 47 48 49 50
01 02 03 04 09 10 13 14 23 24 25 26 27 28 29 30 37 38 39 40 41 42 43 44 45 46 47 48 49 50
01 02 03 04 09 10 15 16 17 18 19 20 21 22 23 24 25 26 29 30 33 34 35 36 39 40 41 42 45 46
01 02 03 04 09 10 15 16 17 18 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 45 46 49 50
01 02 05 06 07 08 09 10 11 12 13 14 15 16 17 18 29 30 33 34 35 36 41 42 43 44 45 46 47 48
01 02 05 06 07 08 09 10 11 12 13 14 15 16 17 18 33 34 35 36 39 40 41 42 43 44 45 46 47 48
01 02 05 06 07 08 09 10 11 12 13 14 19 20 21 22 23 24 25 26 27 28 31 32 37 38 47 48 49 50
01 02 05 06 07 08 09 10 11 12 15 16 17 18 21 22 23 24 25 26 31 32 33 34 35 36 43 44 49 50
01 02 05 06 07 08 09 10 13 14 15 16 17 18 19 20 23 24 29 30 31 32 33 34 35 36 39 40 49 50
01 02 05 06 07 08 09 10 17 18 21 22 23 24 27 28 29 30 31 32 37 38 39 40 43 44 47 48 49 50
01 02 05 06 07 08 11 12 13 14 19 20 23 24 27 28 31 32 33 34 37 38 41 42 43 44 45 46 47 48
01 02 05 06 09 10 11 12 13 14 15 16 17 18 19 20 25 26 31 32 35 36 37 38 41 42 45 46 49 50
01 02 05 06 13 14 17 18 21 22 23 24 25 26 29 30 31 32 33 34 37 38 39 40 41 42 45 46 47 48
01 02 05 06 15 16 19 20 23 24 25 26 27 28 29 30 31 32 35 36 39 40 41 42 43 44 45 46 49 50
01 02 07 08 09 10 11 12 13 14 17 18 23 24 25 26 31 32 33 34 35 36 39 40 45 46 47 48 49 50
01 02 07 08 11 12 13 14 15 16 19 20 23 24 25 26 29 30 35 36 37 38 39 40 41 42 45 46 47 48
01 02 07 08 11 12 13 14 15 16 21 22 27 28 29 30 31 32 35 36 39 40 41 42 45 46 47 48 49 50
01 02 07 08 11 12 17 18 21 22 23 24 25 26 27 28 29 30 33 34 39 40 41 42 43 44 45 46 49 50
01 02 07 08 13 14 15 16 17 18 21 22 23 24 31 32 35 36 37 38 41 42 43 44 45 46 47 48 49 50
01 02 09 10 11 12 13 14 15 16 19 20 21 22 25 26 27 28 33 34 35 36 37 38 41 42 43 44 45 46
01 02 09 10 11 12 13 14 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 37 38 39 40 49 50
01 02 09 10 11 12 15 16 19 20 23 24 27 28 29 30 33 34 35 36 37 38 39 40 43 44 47 48 49 50
01 02 09 10 13 14 15 16 17 18 21 22 23 24 25 26 27 28 31 32 33 34 35 36 37 38 47 48 49 50
03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 19 20 23 24 27 28 37 38 39 40 41 42 43 44
03 04 05 06 07 08 09 10 11 12 13 14 15 16 21 22 23 24 25 26 29 30 41 42 43 44 47 48 49 50
03 04 05 06 07 08 09 10 11 12 17 18 21 22 23 24 29 30 31 32 33 34 35 36 39 40 41 42 47 48
03 04 05 06 07 08 09 10 13 14 15 16 19 20 25 26 27 28 29 30 33 34 37 38 43 44 45 46 49 50
03 04 05 06 07 08 09 10 13 14 17 18 23 24 25 26 27 28 33 34 35 36 37 38 39 40 43 44 45 46
03 04 05 06 07 08 11 12 13 14 15 16 17 18 21 22 25 26 27 28 31 32 33 34 39 40 41 42 45 46
03 04 05 06 07 08 11 12 13 14 19 20 29 30 31 32 35 36 37 38 39 40 41 42 43 44 45 46 47 48
03 04 05 06 07 08 11 12 13 14 21 22 23 24 25 26 27 28 35 36 39 40 43 44 45 46 47 48 49 50
03 04 05 06 07 08 11 12 15 16 17 18 19 20 21 22 23 24 25 26 33 34 37 38 39 40 45 46 49 50
03 04 05 06 07 08 11 12 19 20 21 22 23 24 25 26 29 30 31 32 35 36 37 38 41 42 43 44 49 50
03 04 05 06 07 08 13 14 15 16 17 18 21 22 23 24 29 30 31 32 33 34 37 38 43 44 45 46 49 50
03 04 05 06 07 08 15 16 19 20 21 22 23 24 27 28 29 30 33 34 39 40 41 42 43 44 47 48 49 50
03 04 05 06 07 08 17 18 19 20 23 24 27 28 29 30 31 32 33 34 35 36 39 40 45 46 47 48 49 50
03 04 05 06 07 08 17 18 21 22 23 24 25 26 29 30 31 32 33 34 35 36 37 38 39 40 45 46 47 48
03 04 05 06 09 10 11 12 13 14 15 16 17 18 21 22 25 26 29 30 31 32 39 40 41 42 43 44 49 50
03 04 05 06 09 10 11 12 13 14 15 16 17 18 23 24 29 30 31 32 33 34 39 40 43 44 45 46 47 48
03 04 05 06 09 10 11 12 13 14 19 20 21 22 23 24 27 28 29 30 31 32 33 34 35 36 37 38 45 46
03 04 05 06 09 10 11 12 19 20 25 26 27 28 31 32 33 34 35 36 37 38 39 40 41 42 47 48 49 50
03 04 05 06 09 10 13 14 17 18 19 20 23 24 25 26 29 30 31 32 33 34 35 36 41 42 43 44 47 48
03 04 05 06 09 10 13 14 17 18 21 22 27 28 29 30 33 34 35 36 37 38 41 42 43 44 47 48 49 50
03 04 05 06 09 10 15 16 17 18 21 22 23 24 25 26 27 28 29 30 31 32 33 34 37 38 41 42 43 44
03 04 05 06 11 12 13 14 17 18 19 20 23 24 25 26 29 30 33 34 35 36 37 38 43 44 45 46 49 50
03 04 07 08 09 10 11 12 13 14 15 16 19 20 27 28 29 30 31 32 37 38 41 42 43 44 47 48 49 50
03 04 07 08 09 10 11 12 15 16 17 18 19 20 23 24 31 32 39 40 41 42 43 44 45 46 47 48 49 50
03 04 07 08 09 10 11 12 15 16 19 20 21 22 23 24 25 26 27 28 31 32 37 38 39 40 43 44 45 46
03 04 07 08 09 10 11 12 17 18 19 20 23 24 25 26 27 28 29 30 33 34 35 36 37 38 41 42 49 50
03 04 07 08 09 10 11 12 25 26 27 28 29 30 31 32 33 34 35 36 37 38 43 44 45 46 47 48 49 50
03 04 07 08 09 10 13 14 21 22 23 24 27 28 31 32 33 34 35 36 37 38 39 40 41 42 43 44 49 50
03 04 07 08 09 10 15 16 17 18 21 22 25 26 27 28 33 34 37 38 39 40 41 42 43 44 47 48 49 50
03 04 09 10 11 12 13 14 17 18 21 22 25 26 27 28 29 30 31 32 33 34 35 36 43 44 45 46 49 50
03 04 11 12 15 16 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 37 38 45 46 47 48 49 50
03 04 13 14 15 16 17 18 19 20 23 24 25 26 27 28 31 32 33 34 39 40 43 44 45 46 47 48 49 50
05 06 07 08 11 12 13 14 15 16 17 18 19 20 21 22 27 28 29 30 31 32 33 34 37 38 41 42 47 48
05 06 07 08 11 12 13 14 15 16 17 18 23 24 25 26 27 28 29 30 31 32 33 34 41 42 47 48 49 50
05 06 07 08 13 14 17 18 19 20 21 22 23 24 25 26 27 28 31 32 35 36 37 38 39 40 41 42 49 50
05 06 09 10 11 12 15 16 17 18 19 20 21 22 25 26 27 28 29 30 37 38 43 44 45 46 47 48 49 50
05 06 09 10 13 14 15 16 19 20 21 22 23 24 25 26 27 28 31 32 37 38 39 40 45 46 47 48 49 50
05 06 09 10 17 18 19 20 21 22 27 28 29 30 31 32 33 34 35 36 39 40 41 42 43 44 45 46 49 50
07 08 09 10 11 12 13 14 17 18 19 20 21 22 27 28 33 34 35 36 37 38 39 40 45 46 47 48 49 50
07 08 09 10 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 37 38 45 46 49 50
07 08 09 10 13 14 15 16 19 20 21 22 23 24 29 30 33 34 35 36 39 40 43 44 45 46 47 48 49 50
11 12 13 14 15 16 17 18 19 20 21 22 23 24 29 30 31 32 33 34 37 38 39 40 41 42 43 44 49 50
11 12 17 18 19 20 21 22 23 24 25 26 27 28 31 32 35 36 37 38 39 40 41 42 43 44 47 48 49 50

e apenas uma delas que não ainda não saiu 6 pontos

03 04 05 06 07 08 09 10 13 14 17 18 23 24 25 26 27 28 33 34 35 36 37 38 39 40 43 44 45 46

January 18

21 minutos atrás, Sphgf disse:

Voltei, estava pesquisando no fórum e há uma matriz bem interessante postada a very time ago pelo Wolfram em:

a matriz 80-50-16-20 =30 no spoiler:

Ocultar conteúdo

01 02 03 04 05 06 07 08 09 10 11 12 14 17 18 20 24 25 27 28 30 32 33 34 35 36 38 39 41 42 44 46 49 50 53 54 56 57 58 59 60 61 63 64 66 67 68 78 79 80
01 02 03 04 05 06 07 09 10 11 14 15 16 18 19 20 21 22 23 27 28 30 32 33 36 39 41 42 43 49 50 51 53 56 57 59 60 62 63 64 67 71 72 73 74 75 76 77 79 80
01 02 03 04 06 08 09 11 12 13 14 16 18 20 22 23 24 26 28 30 31 32 35 36 38 40 41 42 44 47 48 50 53 55 58 60 61 62 63 65 66 67 70 72 73 75 76 78 79 80
01 02 03 04 08 09 10 11 13 14 16 17 19 21 22 23 25 26 30 31 33 35 36 37 38 39 40 42 44 46 52 56 57 58 59 60 61 63 64 65 66 68 69 70 71 72 73 74 75 76
01 02 03 05 06 09 11 14 15 16 17 18 20 21 22 23 26 29 30 31 33 34 36 37 40 41 44 45 46 47 48 49 50 52 53 54 56 57 58 60 62 63 65 66 67 69 74 76 78 79
01 02 05 06 07 08 09 10 11 12 14 15 18 19 20 21 22 23 24 26 27 29 31 33 34 42 43 45 46 47 51 52 53 55 56 57 58 59 60 61 62 64 65 66 67 72 75 76 78 79
01 02 05 07 08 13 14 15 17 18 21 22 24 25 26 27 29 30 34 35 36 37 38 39 40 41 42 43 44 45 49 50 51 54 55 57 60 64 65 66 67 68 70 72 74 75 76 77 78 80
01 02 06 07 08 12 13 14 15 16 17 18 19 21 24 25 27 30 32 33 34 35 39 40 41 43 45 46 47 48 51 52 53 55 56 58 60 61 63 64 67 68 69 70 71 72 74 75 76 77
01 03 04 05 06 07 08 10 11 13 14 15 16 17 20 21 22 23 25 28 30 31 33 34 35 37 41 42 43 44 46 47 48 50 53 57 61 62 63 65 66 67 70 72 73 75 76 77 78 80
01 03 04 05 07 08 09 10 12 14 16 17 21 24 26 28 31 33 35 36 37 38 39 40 41 42 51 52 53 55 56 57 58 60 61 63 64 65 66 67 68 69 70 71 73 74 75 78 79 80
01 03 04 05 07 08 10 12 13 14 16 17 18 22 28 29 30 33 34 35 36 39 40 41 43 44 45 46 48 50 51 52 53 54 56 57 58 59 60 61 62 63 65 67 69 70 71 74 79 80
01 03 04 06 08 11 13 14 15 16 17 19 20 21 23 25 26 27 29 30 32 33 34 38 40 41 45 46 47 50 51 52 53 54 57 59 60 63 64 65 66 67 70 72 73 74 76 77 78 80
01 03 05 06 07 08 09 10 11 13 14 15 17 18 21 22 24 26 28 29 30 32 33 36 37 38 39 40 45 49 50 51 52 56 57 59 61 62 63 68 69 71 72 73 75 76 77 78 79 80
01 03 05 06 07 09 10 13 14 18 19 20 22 23 24 25 27 28 30 31 32 34 35 36 37 38 41 42 43 44 45 46 47 48 49 50 52 53 55 60 62 65 70 71 74 75 76 77 78 80
01 04 06 09 11 12 14 16 17 18 21 22 24 25 26 29 33 34 35 38 39 40 42 43 44 45 46 47 49 50 52 53 54 56 57 58 60 64 65 67 68 69 70 71 72 73 74 75 76 80
01 06 07 08 09 10 12 13 16 19 21 23 24 25 26 27 28 31 33 37 38 39 40 41 43 44 45 47 50 51 52 53 54 56 58 60 61 62 63 64 66 68 69 72 74 75 76 77 78 79
02 03 04 05 06 07 09 10 13 15 16 17 18 19 20 21 23 26 27 29 30 31 32 35 37 38 39 41 43 45 46 49 51 52 54 57 58 60 62 63 64 66 67 68 70 71 74 77 79 80
02 03 05 06 07 08 12 15 16 17 18 19 20 21 22 23 26 28 30 31 35 37 41 42 43 45 46 47 49 50 52 53 54 56 58 60 63 64 66 68 69 70 71 72 74 75 76 78 79 80
02 03 05 06 09 10 11 12 13 14 15 18 22 23 26 27 32 33 34 37 39 41 42 48 50 51 52 53 55 56 58 59 60 61 62 63 64 65 66 67 69 70 71 72 73 74 75 77 79 80
02 03 05 08 09 10 11 12 13 14 16 17 18 21 22 24 26 27 30 31 32 33 34 36 39 44 45 47 48 49 50 52 53 55 57 59 62 63 66 67 68 69 70 71 74 75 76 78 79 80
02 03 06 07 08 09 11 12 13 14 15 16 20 21 24 27 29 30 31 32 34 35 36 37 38 41 42 43 45 46 49 51 53 55 56 59 60 61 62 64 65 66 67 68 70 71 75 76 77 78
02 04 05 06 07 08 09 10 11 12 14 15 16 18 19 20 21 22 23 25 27 28 29 30 32 33 34 35 36 37 39 41 45 48 49 54 55 56 57 58 59 61 65 66 68 69 71 73 76 80
02 04 05 06 10 11 14 15 17 18 23 25 26 28 30 34 35 37 38 42 43 44 45 46 48 50 52 54 55 56 57 58 59 60 61 63 64 65 66 67 68 69 70 71 72 73 74 76 77 78
02 04 06 09 11 13 14 17 18 20 21 23 24 25 28 29 31 32 34 35 36 37 38 39 40 41 42 43 45 48 49 53 54 55 56 58 59 61 62 64 66 67 69 71 72 74 75 76 77 78
02 06 07 10 12 14 15 18 20 21 23 25 26 27 28 29 30 32 33 34 35 37 38 40 41 42 43 46 47 48 49 50 51 55 56 58 60 61 62 63 64 65 67 72 73 74 76 77 78 80
03 04 05 08 09 10 11 12 13 14 15 16 17 18 19 20 21 22 25 26 27 30 31 32 34 37 40 44 49 50 53 54 55 56 58 59 60 61 62 63 66 67 68 69 72 75 76 77 78 79
03 04 06 07 08 09 12 14 15 16 17 18 20 21 22 23 24 27 28 29 30 32 34 35 36 37 38 41 45 46 47 50 52 53 54 56 57 58 61 62 63 64 65 67 68 71 72 73 74 79
03 05 06 07 08 10 12 13 15 16 17 18 19 20 22 23 25 26 27 28 36 37 39 40 42 44 48 50 51 52 53 54 55 58 59 60 61 62 63 65 66 67 68 69 70 72 75 76 78 80
03 05 08 15 16 17 21 22 24 26 27 29 30 31 32 33 34 35 36 37 40 41 43 45 47 49 50 51 53 54 55 56 57 58 60 61 63 64 65 66 68 70 71 72 73 74 75 77 78 80
06 07 08 09 10 11 12 13 16 17 19 20 21 22 23 24 26 29 30 31 33 34 35 36 38 39 41 42 46 47 48 49 50 52 53 58 59 61 62 65 66 67 69 70 72 73 74 77 78 79

Estou testando ela aqui, por enquanto passou 100% em testes conferido em 5 milhões de combinações diferentes de 20 dezenas, mantendo acerto mínimo de 16, se passar em 11 milhões de testes considero suficiente...

Sds,

Sphgf

esta com 80% fechado esta matriz

December 19, 2023

Agora, Shurato disse:

@Bruno Cintra Amigo,você trabalha com programação em C, ou delphi?

inclusive tenho Lottodesigner em C++ builder com interface grafica e o lottotricks que ja até passei para alguns aqui no site que o é codigo cover32 do nurmela em vb6

mais uma boa parte desses um amigo que converteu o programa,mais tenho bastante noção,eu estou tentando passar um de python para delphi ou c que gera reduzido que da quase a quantia que tem do site la jolla

December 19, 2023

Agora, Shurato disse:

@Bruno Cintra Amigo,você trabalha com programação em C, ou delphi?

eu entendo pouco de cada,mais não de começar do zero e fazer um programa completo,rsrsrs

mais sei um pouco de vba ou vb6,c,delphi,python,c++ builder que é praticamente o c com interface grafica.mais é só por hobby

November 2, 2023

5 minutos atrás, HIFIMOBIL disse:

Olá Bruno, parabéns pelo código!! Há muito tempo venho buscando algo que faça isso, mas nunca obtive êxito. Eu acredito que essas condições devam restringir bastante o universo de combinações pouco prováveis de ocorrerem

Olá Bruno, parabéns pelo código!! Há muito tempo venho buscando algo que faça isso, mas nunca obtive êxito. Eu acredito que essas condições devam restringir bastante o universo de combinações pouco prováveis. Testei o código no site mencionado e percebi que o filtro para as linhas roda perfeitamente, traz exatamente 5 de cada linha. Já na filtragem das colunas essa trava de elementos é mais flexíivel, ora traz 3 elementos da coluna, ora 5, ora 6. Essa é uma prerrogativa necessária para gerar/atingir os 50 elementos da linha ou há um pequeno erro no código? De qualquer forma ta valendo! Muito obrigado!

vou dar uma olhada,valeu

October 30, 2023

27 minutos atrás, Shurato disse:

@Bruno Cintra Poucos compreendem isso,se eu chegar a uma linha quase perfeita onde 10 números eu fique com percentual em zero,exemplo 0,009812% o que isso significa? O mesmo pode valer se você chegar uma linha de 10 em 10 que tenha exemplo seus 99,994126 ou seja você vai ter 15 pontos,compreende?

entendi

October 30, 2023

1 hora atrás, Shurato disse:

Amigo @Julio Cezar a participação de todos é importante,todos, fico feliz e já mencionei no tópico nas páginas anteriores, que tivemos POSSÍVEIS AVANÇOS em algumas loterias, exemplo LOTOMANIA, OU LOTOFÁCIL, mas, infelizmente não podemos postar aqui esses novso avanços e pontos de vista, alguns dos participantes do tópico notamos que muitos aparecem e não deixam um apoio, apoio falo de opinião de melhoria, isso é desmotivante, mas aproveito o vosso comentário para deixar a MINHA CRIAÇÃO, compartilhada com poucos foristas a exemplo os amigos @W.jhon @Friaça @Jmil21 NUNCA VI NADA DO TIPO AQUI NO FÓRUM, até porque foi procedimento feito em papel e caneta por mim e passado para um bloco de notas, teorias, e apenas uma das portas para diversas loterias, no caso LOTOFÁCIL, peço a todos os participantes e inclusive os não participantes que não mudem a TEORIA, mas sim, caso queiram ajudem com IDÉIAS de AJUSTES, mas sem mudar a teoria, SEGUE MINHAS LINHAS QUE TEM ESSAS PONTUAÇÕES NO MÍNIMO ESTRANHAS, QUEM SOUBER APROVEITAR TEM GARANTIDO OS 15 PONTOS, peço mais uma vez, que tentem entender o funcionamento:

As linhas de 5 :

20 21 22 23 24
01 21 22 23 25
01 02 22 24 25
01 02 03 24 25
01 02 03 04 25

E as linhas de 10:

15 16 17 18 19 20 21 22 23 24
01 16 17 18 19 20 21 22 23 25
01 02 17 18 19 20 21 22 24 25
01 02 03 18 19 20 21 23 24 25
01 02 03 04 19 20 22 23 24 25
01 02 03 04 05 21 22 23 24 25
01 02 03 04 05 06 22 23 24 25
01 02 03 04 05 06 07 23 24 25
01 02 03 04 05 06 07 08 24 25
01 02 03 04 05 06 07 08 09 25

Consigo em 10 linhas de 10 dezenas na lotofácil,peço desculpas por citar essa modalidade neste tópico, PERGUNTO: VOCÊS ACHAM POSSÍVEL EM 10 LINHAS DE 10 DEZENAS CADA. NA MODALIDADE LOTOFÁCIL, TER ESSE RESULTADO: 99,168982% para 4 acertos, 100% 3 acertos e para 5 acertos = 84,549279%.

Em uma segunda etapa: COM 5 LINHAS DE 5 DEZENAS CADA = 0 ACERTO 100% 1 ACERTO = 94,347826% . 2 ACERTOS = 56,666667. 3 ACERTOS = 12,981366%. 4 ACERTOS = 0,839450% E PARA 5 ACERTOS = 0,009411%

SORTE A TODOS.

no programa que eu tenho com 10 linhas de 10 dezenas,eu consigo

2=100%

3=100%

4=100%

5=99,994126

05 09 11 15 17 18 21 22 23 24
03 10 11 12 14 16 17 18 21 25
01 02 06 07 13 15 18 19 20 25
04 06 10 15 16 17 19 20 21 22
01 08 10 11 12 13 19 20 23 25
03 05 06 08 09 12 14 16 23 24
01 02 03 08 12 13 15 17 21 22
02 04 06 07 08 11 12 14 18 23
05 07 08 09 16 19 20 22 24 25
01 02 03 04 05 07 09 13 14 24

October 21, 2023

#import numpy as np 
import random  as rd


lista_quant_numeros_linha = []
lista_index_numeros_linha =[]
lista_auxiliar_sequencia_coluna = []
lista_verif_colunas = []
bilhete_premiado = []
sequencia_coluna=[]

i = 0
acumulador = 0
linha = 0 
coluna = 0

def geradorIndices(quant_numeros_linha):
	flag = True
	while(flag):
		index_numeros_linha = rd.sample(range(0, 10), quant_numeros_linha)
		index_numeros_linha.sort()
		for i in range(len(index_numeros_linha) - 3):
			if index_numeros_linha[i] + 1 == index_numeros_linha[i + 1] == index_numeros_linha[i + 2] - 1 == index_numeros_linha[i + 3] - 2:
				break
		else:
			return index_numeros_linha

def geradoraleatorio():
	lista = []
	ac = 0
	for x in range(10):
		aux = rd.randint(5, 5)
		ac += aux
		lista.append(aux)
	return lista, ac


def gerarListaIndices(lista_quant_numeros_linha):
	lista_index_numeros_linha = []
	for i in range(len(lista_quant_numeros_linha)):
		index_numeros_linha = geradorIndices(lista_quant_numeros_linha[i])
		index_numeros_linha.sort()
		lista_index_numeros_linha.append(index_numeros_linha)		
	return lista_index_numeros_linha


def verificacaoColunaQuant(lista_index_numeros_linha):
	for i in range(10):
		quant_sum = sum(x.count(i) for x in lista_index_numeros_linha)
		if(quant_sum > 6):		
			return True		
	return False

def gerarListaVerificadas(lista_quant_numeros_linha):
	flag = True
	while(flag):
		lista_index_numeros_linha = gerarListaIndices(lista_quant_numeros_linha)
		flag = verificacaoColunaQuant(lista_index_numeros_linha)
	return lista_index_numeros_linha


def verificarSeqColuna(sequencia_coluna, lista_quant_numeros_linha):
	numero = 0
	lista_final = []
	lista_final = gerarListaVerificadas(lista_quant_numeros_linha)
	while(testadorSimples(lista_final)):
		lista_final = gerarListaVerificadas(lista_quant_numeros_linha)
	return lista_final

def testadorSimples(lista):
	cont = 0
	for numero in range(1,10):
		for x in lista:
			if numero in x:
				cont += 1
			else:
				cont = 0
			if cont > 3:
				return True
	return False


def geradorDeDinheiro():
	lista_quant_numeros_linha = []
	lista_index_numeros_linha =[]
	lista_auxiliar_sequencia_coluna = []
	lista_verif_colunas = []
	bilhete_premiado = []
	sequencia_coluna=[]
	i = 0
	acumulador = 0
	linha = 0 
	coluna = 0

	lista_quant_numeros_linha, acumulador = geradoraleatorio()
	
	while(acumulador > 50):
		lista_quant_numeros_linha, acumulador = geradoraleatorio()	


	quant_numeros_totais_faltando = 50 - acumulador;

	while(quant_numeros_totais_faltando > 0):
		i = rd.randint(0, (len(lista_quant_numeros_linha)-1))
		if(lista_quant_numeros_linha[i] < 5 and quant_numeros_totais_faltando > 0):
			lista_quant_numeros_linha[i] = lista_quant_numeros_linha[i] + 1
			quant_numeros_totais_faltando = quant_numeros_totais_faltando - 1

	lista_verif_colunas = []
	lista_index_numeros_linha = gerarListaVerificadas(lista_quant_numeros_linha)
	

	quant = 0
	for i in range(10):
		quant = sum(x.count(i) for x in lista_index_numeros_linha)
		lista_verif_colunas.append(quant)

	for x in range(10):
		for y in range(10):
			try:
				sequencia_coluna.append(lista_index_numeros_linha[y][x])
			except Exception as e:
				pass
	
	lista_index_numeros_linha = verificarSeqColuna(sequencia_coluna, lista_quant_numeros_linha)
	for i in lista_index_numeros_linha:
		for x in i:
			if(linha > 0):
				aux = 1 + x + (linha * 10)
				bilhete_premiado.append(aux)
			else:
				aux = x + linha + 1
				bilhete_premiado.append(aux)
		
		linha += 1

	try:
		with open(nome_arquivo + ".txt") as file:
			for line in file:
				if(((str(bilhete_premiado)) + "\n") == line):
					lista_index_numeros_linha = geradorDeDinheiro()
	except Exception as e:
		pass			
	return lista_index_numeros_linha

quant_bilhetes = input("Digite a quantidade de bilhetes: ")
nome_arquivo = input("Digite o nome do arquivo: ")

for quant_bilhe in range(int(quant_bilhetes)):
	lista_quant_numeros_linha = []
	lista_index_numeros_linha =[]
	lista_auxiliar_sequencia_coluna = []
	lista_verif_colunas = []
	bilhete_premiado = []
	sequencia_coluna=[]
	i = 0
	acumulador = 0
	linha = 0 
	coluna = 0

	lista_index_numeros_linha = geradorDeDinheiro()

	for i in lista_index_numeros_linha:
		for x in i:
			if(linha > 0):
				aux = 1 + x + (linha * 10)
				bilhete_premiado.append(aux)
			else:
				aux = x + linha + 1
				bilhete_premiado.append(aux)
		
		linha += 1

	bilhete_premiado.sort()
	arquivo = open(nome_arquivo + ".txt", "a")
	print(quant_bilhe+1,end="\r")
	#arquivo.write("BILHETE " + str(quant_bilhe+1) + "\n")
	arquivo.write(' '.join([str(f"{item:02}") for item in bilhete_premiado]) + "\n")
arquivo.close()
print("BILHETE GERADO COM SUCESSO!!!")
print("BOA SORTE")

esta ai um codigo em python para lotomania

Gera um bilhete de 50 numeros com base nos seguintes filtros:
- Na linha de 5 a 5 numeros, com no maximo 3 seguidos.
- Na coluna de 5 a 5 numeros, com no maximo 3 seguidos.
- 50 numeros de 100.
e um site online para rodar

Online Python Compiler - online editor (onlinegdb.com)

October 15, 2023

3 minutos atrás, Shurato disse:

@Bruno Cintra Amigo, vi que você visita o tópico desde a criação, vi no seu perfil agora mesmo, que você já trabalhou ou tentou modificar sistemas em C+, então isso aqui é igual um jogo de xadrez, os jogadores conseguem ver o jogo de uma maneira, os que estão de fora de outra maneira, caso queira se manifestar a respeito de alguma possível opinião sinta-se a vontade,o tópico além de livre, também tem opiniões livres, desde que voltadas a não perder o foco,sei que você entende do que estou falando, bem vindo.

sim,eu estou mexendo em dois codigo de fonte um pra lotomania e outro que faz fechamneto v,k,t,m ja reduzido em python, tentando converter para C que acho vai ficar mais rapido,e sempre dou uma olhada para ver.

August 23, 2023

10 horas atrás, PS_(Soares) disse:

Se não puder deixar rodando me avise aqui, que tenho condições de deixar rodando por anos, mas eu não tenho sw para matrizes, por isso postei aqui, mas se pude poste, por favor.

eu postei aqui no forum ve se consegue rodar

August 22, 2023

6 horas atrás, PS_(Soares) disse:

Se não puder deixar rodando me avise aqui, que tenho condições de deixar rodando por anos, mas eu não tenho sw para matrizes, por isso postei aqui, mas se pude poste, por favor.

estou fazendo uns ajustes aqui,eu vou colocar o arquivo aqui,por enquanto esta rodando em msdos console,estou tentando passar para interface grafica.

August 20, 2023

21 horas atrás, PS_(Soares) disse:

Quem puder por favor poste!

vou colocar aqui parar rodar e ver a quantidade que vai dar.

August 4, 2023

11 horas atrás, PS_(Soares) disse:

#include <stdio.h>

#define TOTAL_CONJUNTOS 20
#define DEZENAS_POR_CONJUNTO 3
#define TOTAL_DEZENAS (TOTAL_CONJUNTOS * DEZENAS_POR_CONJUNTO)

// Função para imprimir uma combinação de 60 números
void imprimir_combinacao(int combinacao[TOTAL_DEZENAS]) {
for (int i = 0; i < TOTAL_DEZENAS; i++) {
printf("%2d ", combinacao[i]);
if ((i + 1) % DEZENAS_POR_CONJUNTO == 0) {
printf("| ");
}
}
printf("\n");
}

// Função para gerar as combinações passo a passo
void gerar_combinacoes(int conjunto[TOTAL_CONJUNTOS][DEZENAS_POR_CONJUNTO], int posicao) {
if (posicao == TOTAL_DEZENAS) {
imprimir_combinacao(conjunto[0]);
return;
}

int conj, dez;

for (conj = 0; conj < TOTAL_CONJUNTOS; conj++) {
if (posicao < DEZENAS_POR_CONJUNTO) {
conjunto[conj][posicao] = posicao + 1;
gerar_combinacoes(conjunto, posicao + 1);
} else {
for (dez = conjunto[conj][posicao - DEZENAS_POR_CONJUNTO] + 1; dez <= TOTAL_DEZENAS; dez++) {
conjunto[conj][posicao] = dez;
gerar_combinacoes(conjunto, posicao + 1);
}
}
}
}

int main() {
int conjunto[TOTAL_CONJUNTOS][DEZENAS_POR_CONJUNTO];

printf("As combinacoes possiveis sao:\n");
gerar_combinacoes(conjunto, 0);

return 0;
}

fala blz,vc manja bem de codigo c,c++ eu estou tentando modificar um codigo que não consegui fazer ,de gerar combinações C(N,K) mais não sequencial eu precisava que seja aleatorio,o codigo que tenho aqui até faz aleatorio mais com loop infinito,qualquer coisa te envio o codigo inteiro que faz combinações v,k,t,m=b igual o cologa.

February 21, 2023

Kkkk

February 20, 2023

um codigo em assembler do programa oscover que gerar v,k,t,m=b

.386
.model flat, stdcall
option casemap :none ; case sensitive

; #########################################################################

include \masm32\include\windows.inc
include \masm32\include\user32.inc
include \masm32\include\kernel32.inc

includelib \masm32\lib\user32.lib
includelib \masm32\lib\kernel32.lib

combinations PROTO :DWORD,:DWORD

; #########################################################################

szText MACRO Name, Text:VARARG
LOCAL lbl
jmp lbl
Name db Text,0
lbl:
ENDM

m2m MACRO M1, M2
push M2
pop M1
ENDM

return MACRO arg
mov eax, arg
ret
ENDM

.code

; ##########################################################################

LibMain proc hInstDLL:DWORD, reason:DWORD, unused:DWORD

szText LmTitle,"Cover Functions"

.if reason == DLL_PROCESS_ATTACH
szText ATTACHPROCESS,"PROCESS_ATTACH"

return TRUE
; -----------------------------
; If error at startup, return 0
; System will abort loading DLL
; -----------------------------

.elseif reason == DLL_PROCESS_DETACH
szText DETACHPROCESS,"PROCESS_DETACH"

.elseif reason == DLL_THREAD_ATTACH
szText ATTACHTHREAD,"THREAD_ATTACH"

.elseif reason == DLL_THREAD_DETACH
szText DETACHTHREAD,"THREAD_DETACH"

.endif

ret

LibMain Endp

; ##########################################################################

; *** Count the number of bits in DWORD
bitCount proc STDCALL number:DWORD

   sub   eax,eax
   mov   ecx,number
   cmp   eax,ecx
   je   noBits
bitLp:
   inc   eax
   mov   ebx,ecx
   dec   ebx
   and   ecx,ebx
   jne   bitLp
noBits:
   ret

bitCount endp

; *** Count combinations of subsets in full set n!/k!(n-k)!
combinations proc STDCALL subSet:DWORD,fullSet:DWORD

   sub   edx,edx
   push   edx
   mov   eax,subSet
   bts   edx,eax
   dec   edx
nextLp:
   sub   ecx,ecx
   mov   ebx,edx
bitLp:
   inc   ecx
   mov   eax,ebx
   dec   eax
   and   ebx,eax
   jnz   bitLp
   cmp   ecx,subSet
   jne   badCount
   inc   DWORD PTR [esp]
   mov   eax,edx
   dec   eax
   or   edx,eax
badCount:
   inc   edx
   mov   eax,fullSet
   bt   edx,eax
   jnc   nextLp
   pop   eax

ret

combinations endp

; *** Count how many cover sets are contained within a list of source sets
; *** ignore sets with MSb on
checkCover proc STDCALL cover:DWORD,subSet:DWORD,fullSet:DWORD,setList:DWORD

   push   edi
   push   esi
   sub   edx,edx
   push   edx
   mov   eax,subSet
   bts   edx,eax
   dec   edx

   mov   esi,setList
   lea   edi,subSet
nextTestSet:
   sub   ebx,ebx
   add   ebx,edx
   jz   badCount
   sub   ecx,ecx
bitLp:
   inc   cx
   mov   eax,ebx
   dec   eax
   and   ebx,eax
   jnz   bitLp
   cmp   cx,[edi]
   jge   isGoodCnt
badCount:
   bt   ecx,16
   jc   isBadCover
nextComb:
   inc   edx
   mov   ebx,fullSet
   bt   edx,ebx
   jnc   nextTestSet
   jmp   finished
isGoodCnt:
   bts   ecx,16
   jc   isCoverTest
   jne   nextComb
isBadCover:
   lea   edi,cover
testSetLp:
   add   ebx,[esi]
   jz   endTestSet
   add   esi,4
   bt   ebx,31
   jnc   notFlagged
   sub   ebx,ebx
notFlagged:
   and   ebx,edx
   jz   testSetLp
   sub   cx,cx
   jmp   bitLp
isCoverTest:
   inc   DWORD PTR [esp]
   mov   eax,edx
   dec   eax
   or   edx,eax
endTestSet:
   mov   esi,setList
   sub   ecx,ecx
   lea   edi,subSet
   jmp   nextComb
finished:
   pop   eax
   pop   esi
   pop   edi

ret

checkCover endp

; *** calculate how many unique combinations are covered by each set in list
rankSets proc STDCALL cover:DWORD,subSet:DWORD,fullSet:DWORD,setList:DWORD

LOCAL setAddr:DWORD

   push   edi
   push   esi
   mov   esi,setList
   sub   eax,eax
notZero:
   add   eax,4
   cmp   DWORD PTR [esi+eax],0
   jne   notZero
   invoke   GlobalAlloc,GMEM_FIXED or GMEM_ZEROINIT, eax
   push   eax

   mov   eax,subSet
   sub   edx,edx
   bts   edx,eax
   dec   edx
nextCheck:
   lea   edi,subSet
   mov   ebx,edx
   sub   ecx,ecx
   mov   setAddr,ecx
bitLp:
   inc   cx
   mov   eax,ebx
   dec   eax
   and   ebx,eax
   jnz   bitLp
   cmp   cx,[edi]
   bts   ecx,16
   jge   goodCount
   jc   nextSet
   jmp   nextComb
goodCount:
   jnc   isCover
   cmp   ebx,setAddr
   jne   notUnique
   mov   setAddr,esi
   jmp   nextSet
isCover:
   jne   nextComb
   lea   edi,cover
   mov   esi,setList
nextSet:
   add   ebx,[esi]
   je   endList
   add   esi,4
   and   ebx,edx
   je   nextSet
   sub   cx,cx
   jmp   bitLp
endList:
   add   ebx,setAddr
   je   notUnique
   sub   ebx,setList
   add   ebx,[esp]
   mov   esi,ebx
   inc   DWORD PTR [esi-4]
notUnique:
   mov   eax,edx
   dec   eax
   or   edx,eax
nextComb:
   inc   edx
   mov   eax,fullSet
   bt   edx,eax
   jnc   nextCheck

   pop   eax
   pop   esi
   pop   edi
   ret

rankSets endp

; *** search for the best set to add to a set list
bestSet proc STDCALL cover:DWORD,subSet:DWORD,fullSet:DWORD,setList:DWORD

LOCAL   condition:DWORD
LOCAL   workList:DWORD
LOCAL   coverCntr:DWORD
LOCAL   bestCover:DWORD
LOCAL   newBestSet:DWORD

   push   edi
   push   esi
   mov   condition,6
   sub   eax,eax
   mov   bestCover,eax
   invoke   combinations,subSet,fullSet
   shl   eax,4
   invoke   GlobalAlloc,GMEM_FIXED or GMEM_ZEROINIT, eax
   push   eax
   mov   eax,setList
   mov   workList,eax
   mov   eax,cover
stageLp:
   push   DWORD PTR [esp]
   sub   edx,edx
   bts   edx,eax
   dec   edx
nextCheck:
   mov   ebx,edx
   lea   edi,condition
   and   ecx,20000H
   jnz   bitLp
   lea   edi,subSet
bitLp:
   inc   cx
   mov   eax,ebx
   dec   eax
   and   ebx,eax
   jnz   bitLp
   cmp   cx,[edi]
   bts   ecx,16
   jge   goodCount
   jc   noBits
   jmp   nextComb

goodCount:
   jnc   isComb
   bt   ecx,17
   jnc   isCover
; *** stage two - count a cover for this draw set
   inc   DWORD PTR coverCntr
   jmp   noBits
isComb:
   jne   nextComb
   mov   esi,workList
noBits:
   add   ebx,[esi]
   je   endSetList
   add   esi,4
   sub   cx,cx
   and   ebx,edx
   lea   edi,cover
   jne   bitLp
   jmp   noBits
endSetList:
   bt   ecx,17
   jnc   incListAddr
   mov   eax,coverCntr
   mov   coverCntr,ebx
   cmp   eax,bestCover
   jle   isCover
   mov   bestCover,eax
   mov   newBestSet,edx
   jmp   isCover
incListAddr:
   mov   esi,[esp]
   mov   [esi],edx
   add   DWORD PTR [esp],4
isCover:
   mov   eax,edx
   dec   eax
   or   edx,eax
nextComb:
   inc   edx
   mov   eax,fullSet
   bt   edx,eax
   jnc   nextCheck

; *** move to stage two - find best set of six numbers to cover all uncovered combinations
   pop   eax
   mov   eax,[esp]
   mov   workList,eax
   sub   ebx,ebx
   mov   coverCntr,ebx
   mov   eax,condition
   bts   ecx,17
   jnc   stageLp
   pop   eax
   invoke   GlobalFree,eax
   mov   eax,newBestSet

pop esi
pop edi

ret

bestSet endp

; ##########################################################################

End LibMain

March 31, 2022

Eu conheço bem de vba

March 31, 2022

4 horas atrás, Pedepano disse:

Olhando um velho pendrive aqui achei uma planilha para fazer redução que eu nem lembrava mais.

A mesma gerou aqui também 22 linhas com 88,09% de cobertura.

Mais se já tenho a planilha porque estou aqui debatendo esse assunto ?

Simples, o objetivo e entender o melhor processo para redução de uma matriz.

Onde eu mesmo posso criar ou adaptada esse processo de acordo com minha necessidade.

Tentei entender o código usado na planilha, mais confesso que meu conhecimento em vba não chega ao ponto de entende o código usado na criação dessa planilha.

Fiquei bem curioso pois pelo visto todo o processo de otimização e feito via código sem qualquer tipo de fórmula para auxiliar em algum processo.

Já perdi muito tempo tentando entender o conceito dessa planilha, porém pra mim foi tempo perdido.

Poderia me enviar

March 28, 2022

o cologa tem muitas opções mais ainda acho lento ,em questão de reduções acho programa lento

March 28, 2022

8 minutos atrás, Pedepano disse:

@DixieJoe busco encontrar uma forma de fazer essa redução ou gerar essas matrizes apenas por curiosidade mesmo.

queria entender o conceito envolvido por trás dessas reduções que alguns programas fazem, uma vez que vão contra minha linha de raciocínio sobre a questão de redução. Uma vez que estamos falando de matemática.

Sinceramente creio que nem deveria responder, pois creio que meu nível de sabedoria sobre essa questão está muito abaixo do seu, rsrs

Sei que conseguir reduzir uma matriz ou gerar uma matriz com a menor quantidade de jogos possível, precisa de um grande poder de processamento, principalmente quando usamos muitas dezenas.

Porém não creio que seja algo tão complexo assim, estamos falando de matemática, pelo menos penso assim.

o mesmo conceito usando para gerar ou reduzir uma pequena matriz será usado para uma grande, a diferença será o tempo de processo.

já vi alguns programas gerar exatamente a quantidade de jogos gerados pelas minas análises.

Inclusive já vi um suposto matemático no youtube citar por exemplo que para garantir 14 acertos jogando com 18 dezenas seria preciso de 38 apostas.

Quantidade exata de jogos gerados, se vc aplicar o conceito que uso.

analisando a logica, realmente essa deveria ser a quantidade de jogos para um desdobramento 18-15-14-15 = 38

Porém quando vc adiciona digamos uma nova variável junto a esse processo, percebe que essa quantidade de 38 linhas será reduzida mantendo a garantia de 14 acertos.

Hoje posso te dizer que com o conceito que uso para gerar uma matriz seria possível criar um programa simples capaz de gerar matrizes menores que o cologa gera por exemplo. Porém acredito que limitado para a lotofácil, ou no máximo 25 números.

Infelizmente fazer essa análise no Excel e praticamente impossível. Me limito a pequenas matrizes.

Um exemplo, o cologa, não estou falando mau, apenas usando ele como exemplo.

se pedi para gerar 12-6-5-6 ele vai gerar entre 66 linhas. Se ativar a opção de usar matriz, onde ele vai usar como base uma matriz menor caso exista.

Nesse caso a menor matriz que ele encontrou e gerou aqui para mim foi 12-6-5-6 = 56

usei meu conceito para gerar 12-6-5-6 gerando 59 linhas, então creio que estou em meio termo, existe algum detalhe que ainda não descobrir que esta fazendo gerar algumas linhas a mais..

qual linguagem vc conhece,vc ja deve ter usado programa cover de nurmela,eu tenho ele convertido para vb6 em funcionameto que gera reduzido mais tem que ser colocado a quantia de bilhetes,não como o cologa gera e depois reduz,em c tenho o que faz o mesmo que o cologa de gerar e depos ir reduzindo,inclusive eu passei para c++ builder com interface grafica.

January 30, 2022

Em 23/01/2022 em 10:12, Rany disse:

A ideia é a mesma do que falei na 3ª postagem desse tópico, o AnalisadorLF do nosso amigo DixieJoe faz o que você precisa.

Como mostrado no exemplo do amigo Silva - GGS https://www.comoganharnaloteria.com.br/forum/topico/35644-lotofácil-matriz 25-17-15-151364-100-somente-até-o-concurso-2423/#comment-469292

No exemplo ele utilizou os 2 mil sorteios da lotofácil como base de dados para conferência, no seu caso, você utiliza as linhas que você gerou, no exemplo que coloquei acima utilizei as 6098 linhas.

Observação: Utilizei um sisteminha próprio, mas o AnalisadorLF é muitoooo mais rápido, esse sistema que fiz possui uma parte do código que foi gentilmente cedido por DixieJoe.

Saudações!!!

vc tem o codigo desse sistema poderia passar para mim?

December 20, 2021

1 minuto atrás, Omesmo disse:

achei o video, parece mais pega otario mesmo

,po mas pedir 27 mil

e para pessoa cai ele cria um perfil falso ou alguem conhecido dizendo que comprou e vai postando e as pessoas vai vendo e ficando curioso ate que cai no golpe

December 20, 2021

1 minuto atrás, Omesmo disse:

talvez tenha dz fixas

só se for com filtros mesmo,fixa,pares,impares,etc......

se for só no fechamento direto esquece

December 20, 2021

Em 22/10/2021 em 03:45, Hidan disse:

Pedido- Em um vídeo no YouTube vi uma planilha de 97 dezenas em 4978 jogos com garantia de 19 pontos se as 20 estiverem dentre as 97, gostaria de saber se é possível fazer essa planilha e com filtros.

não seja inocente no calculo teorico ja é 184.482

Sign In

Bruno Cintra

Posts

Joined

Last visited

Content Type

Profiles

Forums

Downloads

Posts posted by Bruno Cintra

Matrizes Reduzidas ou Abreviadas

101 Matriz de 30 dezenas que garante 6

101 Matriz de 30 dezenas que garante 6

Como Criar Matrizes Na Lotomania

Como Ganhar na Mega da Virada? É possível ganharmos com o verdadeiramente e oculto mínimo teórico 99% de chances!

Como Ganhar na Mega da Virada? É possível ganharmos com o verdadeiramente e oculto mínimo teórico 99% de chances!

Pedido de ajuda CRIAR E REDUZIR MATRIZES

Pedido de ajuda CRIAR E REDUZIR MATRIZES

Pedido de ajuda CRIAR E REDUZIR MATRIZES

Pedido de ajuda CRIAR E REDUZIR MATRIZES

Pedido de ajuda CRIAR E REDUZIR MATRIZES

31-8-7-7 (100%)

31-8-7-7 (100%)

31-8-7-7 (100%)

[AJUDA] Combinação de elementos

bitcount em C, já implementaram, vale a pena?

bitcount em C, já implementaram, vale a pena?

O segredo de criação de desdobramentos dos programas

O segredo de criação de desdobramentos dos programas

O segredo de criação de desdobramentos dos programas

O segredo de criação de desdobramentos dos programas

[AJUDA] Programa para decompor um grupo em linhas de mais dezenas. Existe isso?

Lotomania 97 dezenas em 4978 jogos

Lotomania 97 dezenas em 4978 jogos

Lotomania 97 dezenas em 4978 jogos

Forums

Loterias

Activity