Joh2010

February 21

(Cuidado) Fórmula muito pesada, se arrastar todas as colunas de uma vez pode travar o Excel e perder seus arquivos abertos (Eu arrasto de uma em uma coluna pra baixo).

Observe que não é aquela fómula conhecida que só traz o atraso da mesma coluna, essa procura em qualquer coluna do intervalo.

Na célula em questão está:

=$A9-ÍNDICE($A$1:$A8;MÁXIMO(SE($B$1:$P8=B9;CORRESP(LIN($B$1:$P8);LIN($B$1:$P8));"")))-1

Use Ctrl+Shift+Enter

February 17

A IA infelizmente ela passa uma ilusão parcial assim como todas as outras tentativas de ganhar na loteria. No caso da INTELIGÊNCIA ARTIFICIAL por exemplo, ela não poderia ter dado a resposta abaixo sem antes ter verificado a veracidade (por exemplo, criando a programação necessária para essa verificação).
A resposta da IA como um mapa de linha de trem que mostra os caminhos todos retos em 2d mas que tem subidas, descidas, zique-zague tudo em 3d.

Extendendo um pouco mais: como ela sabe que os "Números que saíram nos últimos 2 a 5 sorteios podem ter maior chance de repetir"???? É obvio que ela não sabe disso simplesmente pq ela não testou isso. Então ela dá uma mapa para se criar programa, o que é uma tarefa que ainda continua complexa para se fazer as correções.

E outra, além de criar o programa que ela mostra na dica (por exemplo, um programa para verificar números que saíram nos últimos 2 a 5 sorteio), ainda se terá que se criar a programação que avalie se essa quantidade de números tem a maior quantidade de se repetir em relação à outros padrões).

Todos nós estamos à Anos-luz de se aproximar de ganhar algum premio máximo com Excel, programação, matemática, IA e etc. Não temos sequer a capacidade de dizer com certeza se uma dezena vai vir no próximo jogo ou não, então o que nos resta é avançar com humildade.

Padrões que podem influenciar o próximo sorteio da LotoFácil (com base no último sorteio):

1. Números Repetidos:

Aumento de chance: Números que saíram nos últimos 2 a 5 sorteios podem ter maior chance de repetir.
Diminuição de chance: Números que saíram nos últimos 8 a 12 sorteios podem ter menor chance de repetir.

2. Sequências:

Aumento de chance: Sequências de 2 a 3 números que saíram nos últimos sorteios podem ter maior chance de aparecer.
Diminuição de chance: Sequências de 4 ou mais números que saíram nos últimos sorteios podem ter menor chance de aparecer.

3. Pares e Ímpares:

Equilíbrio: Procure por um equilíbrio entre pares e ímpares, geralmente entre 7 e 9 de cada.
Evite extremos: Evitar combinações com muitos pares (mais de 10) ou muitas ímpares (mais de 10).

4. Distribuição por Dezenas:

Distribuição uniforme: Distribua os números por todas as dezenas (1 a 25).
Evite concentrações: Evitar concentrar muitos números em poucas dezenas (ex: 5 números entre 1 e 10).

5. Números "atrasados":

Considere números que não saem há 5 a 8 sorteios.
Evite números "frios" que não saem há mais de 15 sorteios.

6. Estatísticas:

Utilize ferramentas online para analisar estatísticas de frequências, atrasos, pares/ímpares, etc.
Lembre-se: Estatísticas não garantem acertos, mas podem auxiliar na escolha dos números.

February 12

O Programa 2 já é mais completo pq busca ter uma análise com todos as estrategias e filtros. Eu não fiz manutenção nenhuma simplesmente fui pedindo pra ele construir as estratégias e filtros um após o outro enquanto ia embutido no programa. Ou seja teria que consertar tudo. Mas como tá aqui desde o começo da semana passada e ainda não tive tempo de mexer, vou deixar aí pra quem quiser ver.

import tkinter as tk
from tkinter import filedialog, messagebox
import random

class MegaSenaGenerator:
def __init__(self, master):
self.master = master
self.master.title("Mega Sena Generator")

# Widgets de entrada
self.label_population = tk.Label(master, text="Tamanho da População:")
self.label_population.grid(row=0, column=0, sticky="w")

self.entry_population = tk.Entry(master)
self.entry_population.grid(row=0, column=1, sticky="w")
self.entry_population.insert(tk.END, "1000") # Configurar o valor padrão para 1000

self.label_generations = tk.Label(master, text="Número de Gerações:")
self.label_generations.grid(row=1, column=0, sticky="w")

self.entry_generations = tk.Entry(master)
self.entry_generations.grid(row=1, column=1, sticky="w")
self.entry_generations.insert(tk.END, "100") # Configurar o valor padrão para 100

self.label = tk.Label(master, text="Quantidade de Jogos:")
self.label.grid(row=2, column=0, sticky="w")

self.entry = tk.Entry(master)
self.entry.grid(row=2, column=1, sticky="w")
self.entry.insert(tk.END, "10") # Configurar o valor padrão para 10

# Botões
self.button_generate = tk.Button(master, text="Gerar Jogos", command=self.generate)
self.button_generate.grid(row=3, column=0, columnspan=2, sticky="we")

self.button_load = tk.Button(master, text="Carregar Sorteios", command=self.load_draws)
self.button_load.grid(row=4, column=0, columnspan=2, sticky="we")

# Botões para ativar/desativar estratégias e filtros
self.strategy_button = tk.Button(master, text="Usar Estratégias", command=self.toggle_strategies)
self.strategy_button.grid(row=5, column=0, sticky="we")

self.filter_button = tk.Button(master, text="Usar Filtros", command=self.toggle_filters)
self.filter_button.grid(row=5, column=1, sticky="we")

# Widget de texto para exibir relatório em tempo real
self.text_report = tk.Text(master, height=10, width=50)
self.text_report.grid(row=6, column=0, columnspan=2, sticky="we")

# Variáveis para rastrear se as estratégias e filtros estão ativados
self.strategies_enabled = False
self.filters_enabled = False

# Dados históricos da Mega Sena
self.historical_data = []

# Parâmetros do algoritmo genético
self.population_size = 1000
self.num_generations = 100
self.mutation_rate = 0.05
self.stagnation_limit = 10 # Limite de gerações sem melhoria

def generate(self):
try:
num_games = int(self.entry.get())
if num_games <= 0:
raise ValueError

# Atualizar tamanho da população e número de gerações
self.population_size = int(self.entry_population.get())
self.num_generations = int(self.entry_generations.get())

# Limpar o widget de texto antes de gerar novos jogos
self.text_report.delete("1.0", tk.END)

# Executar algoritmo genético para gerar jogos
best_games = self.run_genetic_algorithm(num_games)

# Exibir jogos gerados no widget de texto
self.text_report.insert(tk.END, "Jogos Gerados:\n")
for game in best_games:
self.text_report.insert(tk.END, f"{game}\n")
except ValueError:
messagebox.showerror("Erro", "Por favor, insira valores numéricos válidos.")

def load_draws(self):
try:
file_path = filedialog.askopenfilename(filetypes=[("Arquivos de Texto", "*.txt")])
if file_path:
with open(file_path, "r") as file:
self.historical_data = [list(map(int, line.split())) for line in file.readlines()]
messagebox.showinfo("Sorteios Carregados", "Sorteios carregados com sucesso.")
except Exception as e:
messagebox.showerror("Erro", f"Ocorreu um erro ao carregar os sorteios: {str(e)}")

def toggle_strategies(self):
# Função para ativar/desativar as estratégias
self.strategies_enabled = not self.strategies_enabled
if self.strategies_enabled:
self.strategy_button.config(text="Desativar Estratégias")
else:
self.strategy_button.config(text="Usar Estratégias")

def toggle_filters(self):
# Função para ativar/desativar os filtros
self.filters_enabled = not self.filters_enabled
if self.filters_enabled:
self.filter_button.config(text="Desativar Filtros")
else:
self.filter_button.config(text="Usar Filtros")

def fitness_function(self, game):
# Função de aptidão - pontuação com base na proximidade aos números sorteados historicamente
score = 0
for draw in self.historical_data:
common_numbers = len(set(game) & set(draw))
score += common_numbers
return score

def generate_random_game(self):
# Gerar um jogo aleatório
return sorted(random.sample(range(1, 61), 6))

def crossover(self, game1, game2):
# Cruzamento - misturar genes de dois jogos
crossover_point = random.randint(1, 5)
new_game = game1[:crossover_point] + game2[crossover_point:]
return new_game

def mutate(self, game):
# Mutação - alterar um gene de um jogo
if random.random() < self.mutation_rate:
mutated_gene = random.randint(1, 60)
while mutated_gene in game:
mutated_gene = random.randint(1, 60)
gene_to_mutate = random.randint(0, 5)
game[gene_to_mutate] = mutated_gene
return game

def apply_strategies(self, population):
# Aplicar estratégias
# Estratégia de combinação de dígitos
if self.strategies_enabled:
population = [self.combine_digits(game) for game in population]
# Estratégia de pares e ímpares
if self.strategies_enabled:
population = [self.balance_even_and_odd_numbers(game) for game in population]
return population

def combine_digits(self, game):
# Combinação de dígitos - combinar dígitos mais frequentes em diferentes posições
# Primeiro dígito
most_common_first_digit = max(set([draw[0] for draw in self.historical_data]), key=[draw[0] for draw in self.historical_data].count)
game[0] = most_common_first_digit
# Último dígito
most_common_last_digit = max(set([draw[-1] for draw in self.historical_data]), key=[draw[-1] for draw in self.historical_data].count)
game[-1] = most_common_last_digit
return game

def apply_filters(self, population):
# Aplicar filtros
# Filtro de números quentes e frios
if self.filters_enabled:
for i, game in enumerate(population):
population[i] = self.avoid_number_sequences(game)
population[i] = self.include_hot_and_cold_numbers(game)
population[i] = self.balance_sum_of_numbers(game)
return population

def balance_sum_of_numbers(self, game):
# Calcular a soma atual dos números no jogo
current_sum = sum(game)
# Calcular a soma ideal (média dos números possíveis)
ideal_sum = (1 + 60) * 6 / 2
# Calcular o ajuste necessário para equilibrar a soma
adjustment = ideal_sum - current_sum
# Se a soma atual estiver abaixo da soma ideal, adicionar números adicionais para equilibrar
if adjustment > 0:
# Gerar uma lista de números disponíveis para adição
available_numbers = [num for num in range(1, 61) if num not in game]
# Adicionar números até alcançar o ajuste necessário
while adjustment > 0:
# Escolher aleatoriamente um número disponível para adição
new_number = random.choice(available_numbers)
# Adicionar o novo número ao jogo
game.append(new_number)
# Atualizar o ajuste necessário
adjustment -= new_number
# Remover o número escolhido da lista de números disponíveis
available_numbers.remove(new_number)
# Se a soma atual estiver acima da soma ideal, remover números para equilibrar
elif adjustment < 0:
# Remover números até alcançar o ajuste necessário
while adjustment < 0:
# Escolher aleatoriamente um número do jogo para remoção
number_to_remove = random.choice(game)
# Remover o número do jogo
game.remove(number_to_remove)
# Atualizar o ajuste necessário
adjustment += number_to_remove
return game

def run_genetic_algorithm(self, num_games):
# Algoritmo Genético
population = [self.generate_random_game() for _ in range(self.population_size)]

# Aplicar estratégias e filtros
population = self.apply_strategies(population)
population = self.apply_filters(population)

best_score = 0 # Variável para rastrear a melhor pontuação
stagnation_count = 0 # Variável para rastrear o número de gerações sem melhoria

for generation in range(self.num_generations):
# Avaliar a aptidão de cada jogo na população
fitness_scores = [(game, self.fitness_function(game)) for game in population]
fitness_scores.sort(key=lambda x: x[1], reverse=True)

# Selecionar os melhores jogos para reprodução
selected_parents = [game for game, _ in fitness_scores[:10]]

# Verificar se houve melhoria na pontuação
if fitness_scores[0][1] > best_score:
best_score = fitness_scores[0][1]
stagnation_count = 0
else:
stagnation_count += 1

# Condição de parada: interromper se não houver melhoria por um número específico de gerações
if stagnation_count >= self.stagnation_limit:
break

# Cruzamento e mutação para gerar nova população
new_population = []
while len(new_population) < self.population_size:
parent1, parent2 = random.choices(selected_parents, k=2)
child = self.crossover(parent1, parent2)
child = self.mutate(child)
new_population.append(child)

population = new_population

# Retornar os melhores jogos da última geração
best_games = [", ".join(map(str, game)) for game in population[:num_games]]
return best_games

def main():
root = tk.Tk()
app = MegaSenaGenerator(root)
root.mainloop()

if __name__ == "__main__":
main()

A explicação do gemini ficou horrível. Mas tá aí:

Explicação passo a passo do programa MegaSenaGenerator:

Importações:

O programa começa importando bibliotecas necessárias:
- tkinter: usada para criar a interface gráfica.
- filedialog: usada para selecionar arquivos.
- messagebox: usada para exibir mensagens ao usuário.
- ttk: usada para elementos da interface avançados.
- random: usada para gerar números aleatórios.

Classe MegaSenaGenerator:

A classe MegaSenaGenerator é definida para gerenciar a aplicação:
- Construtor (__init__
  - Inicializa a janela principal (master).
  - Define o título da janela ("Mega Sena Generator").
  - Cria widgets de entrada para:
    - Tamanho da população (padrão: 1000).
    - Número de gerações (padrão: 100).
    - Quantidade de jogos (padrão: 10).
  - Cria botões para:
    - Gerar jogos.
    - Carregar sorteios de um arquivo.
    - Ativar/desativar estratégias.
    - Ativar/desativar filtros.
  - Inicializa variáveis para controle de estratégias, filtros, dados históricos e parâmetros do algoritmo genético.
  - Cria uma caixa de texto para exibição de relatório em tempo real.
- Função generate
  - Valida a quantidade de jogos informada pelo usuário.
  - Limpa a caixa de texto de relatório.
  - Atualiza os parâmetros do algoritmo genético.
  - Executa o algoritmo genético para gerar jogos.
  - Exibe os jogos gerados no relatório em tempo real.
- Função load_draws
  - Permite selecionar um arquivo de texto com sorteios da Mega Sena.
  - Carrega os sorteios do arquivo e exibe mensagem de sucesso ao usuário.
- Funções toggle_strategies e toggle_filters
  - Ativam/desativam o uso de estratégias e filtros, respectivamente, e alteram o texto do botão correspondente.
- Função fitness_function
  - Calcula a aptidão de um jogo (pontuação) baseado na proximidade aos números sorteados historicamente.
- Função generate_random_game
  - Gera um jogo aleatório com 6 números únicos entre 1 e 60.
- Funções crossover e mutate
  - Implementam os operadores do algoritmo genético:
    - crossover: combina genes de dois jogos pais para criar um novo filho.
    - mutate: realiza uma pequena alteração em um gene do jogo filho.
- Funções apply_strategies e apply_filters
  - Aplicam as estratégias e filtros selecionados, respectivamente, modificando a população de jogos.
- Função balance_sum_of_numbers
  - Ajusta a soma dos números em um jogo para se aproximar de um valor ideal, considerando números quentes e frios.
- Função run_genetic_algorithm
  - Implementa o algoritmo genético:
    - Inicializa a população com jogos aleatórios únicos.
    - Aplica estratégias e filtros.
    - Realiza um loop de gerações:
      - Avalia a aptidão de cada jogo.
      - Seleciona os melhores jogos para reprodução.
      - Aplica crossover e mutação para gerar a nova população.
      - Exibe informações de progresso em tempo real.
    - Retorna os melhores jogos da última geração.

Função principal:

A função main cria a janela principal (root) e inicializa a aplicação com a classe MegaSenaGenerator.

Execução:

Executando o script, a interface gráfica é exibida permitindo ao usuário:
- Definir parâmetros do algoritmo genético.
- Carregar sorteios históricos.
- Ativar/desativar estratégias e filtros.
- Gerar jogos da Mega Sena.
- Visualizar resultados de forma interativa.

Espero que esta explicação passo a passo seja útil!

February 12

Pedi pro chatGPT gerar o primeiro programa que vc pediu, eu ia fazer por partes. Mas como desconheço totalmente de programação e de algoritmo genético acabei desanimando simplesmente pq nem sei o que o programa faz.

Mas vou deixar aqui, os dois está incompleto.

O PROGRAMA 1 (feito no ChatGPT-3.5 e explicado pelo Gemini) :

Explicação Detalhada do Algoritmo Genético para Mega Sena

Passo a Passo:

1. Gerando a População Inicial:

A função gerar_populacao cria uma população de tamanho_populacao indivíduos, onde cada indivíduo representa um jogo da Mega Sena com 6 números.
A função utiliza a biblioteca random para gerar números aleatórios entre 1 e 60, sem repetições, para cada indivíduo.
A função verifica se a combinação de números é válida (6 números distintos) antes de adicionar à população.

2. Lendo os Números Sorteados:

A função ler_numeros_sorteados recebe como parâmetro o número do sorteio mais recente (2686 no código).
A função itera sobre os sorteios anteriores (até o número informado) e lê os números sorteados de cada um.
Os números sorteados de cada sorteio são armazenados em uma lista.
A função retorna a lista completa com todos os números sorteados até o momento.

3. Validando Combinações:

A função validar_combinacao recebe um indivíduo (uma lista de 6 números) como parâmetro.
A função verifica se todos os números do indivíduo são distintos (sem repetições).
A função retorna True se a combinação for válida e False se não for.

4. Avaliando Indivíduos:

A função avaliar recebe um indivíduo e a lista de números sorteados como parâmetros.
A função conta quantos números do indivíduo estão presentes na lista de números sorteados.
A função retorna o número de acertos como medida de "fitness" do indivíduo.

5. Selecionando os Melhores:

A função selecionar recebe a população, o tamanho da elite e a lista de números sorteados como parâmetros.
A função ordena a população pela função avaliar (fitness), com os melhores indivíduos no topo.
A função retorna os tamanho_elite melhores indivíduos da população.

6. Cruzamento e Mutação:

A função cruzar recebe dois indivíduos como parâmetros.
A função define um ponto de corte aleatório e combina os genes (números) dos pais para formar dois novos filhos.
A função mutar recebe um indivíduo e a taxa de mutação como parâmetros.
A função percorre os genes do indivíduo e, com probabilidade taxa_mutacao, altera o valor do gene para um número aleatório.

7. Gerando a Próxima Geração:

A função proxima_geracao recebe a população, o tamanho da elite, a taxa de mutação e a lista de números sorteados como parâmetros.
A função seleciona os tamanho_elite melhores indivíduos da população (elite).
A função cria novos indivíduos através do cruzamento e mutação dos indivíduos da elite.
A função retorna a nova população com os novos indivíduos.

8. Evolução Contínua:

A função evoluir é chamada quando o usuário clica no botão "Selecionar Arquivo".
A função lê os números sorteados do próximo sorteio (2686).
A função gera a próxima geração da população.
A função atualiza o texto da label "Melhor indivíduo" com o melhor indivíduo da nova geração e seu fitness.

9. Interface Gráfica:

A biblioteca tkinter é utilizada para criar a interface gráfica.
A interface possui um título, instruções, um botão para selecionar o arquivo com os números sorteados e uma label para mostrar o melhor indivíduo da geração atual.

Observações:

Este código é um exemplo simplificado de um algoritmo genético para a Mega Sena.
Vários parâmetros do algoritmo podem ser ajustados para otimizar o desempenho, como tamanho da população, taxa de mutação, etc.
O código não garante a premiação na Mega Sena, mas pode auxiliar na escolha de combinações com maior probabilidade de acerto.

Recursos Adicionais:

Para mais informações sobre algoritmos genéticos, consulte a documentação da biblioteca deap (https://deap.readthedocs.io/en/latest/).
Para mais informações sobre a Mega Sena, consulte o site da Caixa Econômica Federal (<URL inválido removido>).

import tkinter as tk
from tkinter import filedialog
import random

def gerar_populacao(tamanho_populacao):
populacao = []
while len(populacao) < tamanho_populacao:
individuo = random.sample(range(1, 61), 6)
if validar_combinacao(individuo):
populacao.append(individuo)
return populacao

def ler_numeros_sorteados(numero_sorteio):
numeros_sorteados = []
for i in range(1, numero_sorteio):
nome_arquivo = f"sorteio_{i}.txt"
with open(nome_arquivo, 'r') as f:
numeros_sorteio_atual = f.readline().strip().split()
numeros_sorteio_atual = [int(num) for num in numeros_sorteio_atual]
numeros_sorteados.extend(numeros_sorteio_atual)
return numeros_sorteados

def validar_combinacao(individuo):
return len(set(individuo)) == 6

def avaliar(individuo, numeros_sorteados):
if not validar_combinacao(individuo):
return 0
return sum(1 for num in individuo if num in numeros_sorteados)

def selecionar(populacao, tamanho_elite, numeros_sorteados):
populacao_ordenada = sorted(populacao, key=lambda x: avaliar(x, numeros_sorteados), reverse=True)
return populacao_ordenada[:tamanho_elite]

def cruzar(individuo1, individuo2):
ponto_corte = random.randint(1, len(individuo1) - 1)
filho1 = individuo1[:ponto_corte] + individuo2[ponto_corte:]
filho2 = individuo2[:ponto_corte] + individuo1[ponto_corte:]
return filho1, filho2

def mutar(individuo, taxa_mutacao):
for i in range(len(individuo)):
if random.random() < taxa_mutacao:
individuo[i] = random.randint(1, 60)
return individuo

def proxima_geracao(populacao, tamanho_elite, taxa_mutacao, numeros_sorteados):
elite = selecionar(populacao, tamanho_elite, numeros_sorteados)
novos_individuos = []
while len(novos_individuos) < len(populacao):
pai1 = random.choice(elite)
pai2 = random.choice(elite)
filho1, filho2 = cruzar(pai1, pai2)
novos_individuos.append(mutar(filho1, taxa_mutacao))
novos_individuos.append(mutar(filho2, taxa_mutacao))
return novos_individuos

def evoluir():
global populacao
numeros_sorteados = ler_numeros_sorteados(2686) # Próximo sorteio
if numeros_sorteados:
populacao = proxima_geracao(populacao, tamanho_elite=10, taxa_mutacao=0.1, numeros_sorteados=numeros_sorteados)
melhor_individuo = max(populacao, key=lambda x: avaliar(x, numeros_sorteados))
label_resultado.config(text=f"Melhor indivíduo: {melhor_individuo}, Fitness: {avaliar(melhor_individuo, numeros_sorteados)}")

root = tk.Tk()
root.title("Algoritmo Genético para a Mega Sena")

populacao = gerar_populacao(50)

label_titulo = tk.Label(root, text="Algoritmo Genético para a Mega Sena")
label_titulo.pack()

label_instrucao = tk.Label(root, text="Clique no botão para selecionar o arquivo com os números sorteados:")
label_instrucao.pack()

botao_selecionar_arquivo = tk.Button(root, text="Selecionar Arquivo", command=evoluir)
botao_selecionar_arquivo.pack()

label_resultado = tk.Label(root, text="")
label_resultado.pack()

root.mainloop()

September 16, 2023

Em 08/08/2023 em 19:56, Eolocos disse:

@HIFIMOBIL

fui verificar esta informação que vc disponibilizou e se eu entendi corretamente, Amaury Carvalho encontrou uma maneira de calcular o CSN parcial para conjuntos de dezenas dentro das 15 dezenas sorteadas !

não é exatamente o que eu procurava para resolver o problema dos CSN na Lotomania, aliás, já resolvido, mas, pode ser que tal informação ajude o @Joh2010 que procura uma maneira de criar um CSN personalizado, conforme tópico abaixo:

a informação no entanto é interessante e pode ter utilidade futura.

novamente, obrigado.

Na verdade eu queria essa geração de um "CSN fake" pra qualquer sequência de 15 números. De forma que se pudesse testar em cada um dos sorteios já acontecidos quais CSNs da linha anterior foram premiados no sorteio seguinte. Isso seria capaz de substituir "melhores linhas" que mais premiam, por CSNs que mais premiam de um sorteio para o outro. O teoricamente aumentaria a premiação ou diminuiria a quantidade de linhas de uma "matriz histórica".

September 10, 2022

.

March 24, 2022

11 minutos atrás, Agua Imantada disse:

Boa noite, pessoal!

Estou testando várias matrizes para linhas de 21 dezenas, 20 e 19, e minha frustração com as matrizes usadas para retirar as colunas não poderia ser maior.

Alguém sabe algum macete pra obter uma matriz para colunas que funcione?

As para linhas (jogos), tudo bem, funcionam; mas as para colunas, tá brabo.

Conto com as ideias de todos.

Obrigado pela atenção.

Provavelmente a ordenação não deveria ser do baixo pro alto, mas sim desordenado. Ou em uma ordem estatística das dezenas, por exemplo. Do baixo pro alto, realmente, não faz sentido algum.

December 20, 2021

Em 18/12/2021 em 13:14, welingtonvb disse:

- Números em sequência sorteados;
- Números em sequência não sorteados;
- Ciclo;
- Atraso de dezena;

- "Sorte" (A Ultima).

Reduzir a isto ajudaria mais. O resto é pura ilusão.

September 14, 2021

Pra discussão de uso de fórmulas no campo da loteria

September 11, 2021

.

September 11, 2021

Eu parei no Ensino Médio. Mas considero-me de educação fundamental. Não tenho muito uso dessa formação pra loteria senão matemática básica.

September 5, 2021

Dezenas	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
1	1961256
2	817190	1144066
3	319770	994840	646646
4	116280	610470	881790	352716
5	38760	310080	755820	671840	184756
6	11628	135660	503880	755820	461890	92378
7	3060	51408	278460	636480	656370	291720	43758
8	680	16660	129948	433160	680680	510510	170170	19448
9	120	4480	50960	244608	560560	640640	360360	91520	8008
10	15	945	16380	114660	378378	630630	540540	231660	45045	3003
11	1	140	4095	43680	210210	504504	630630	411840	135135	20020	1001
12		11	715	12870	94380	330330	594594	566280	283140	70785	7865	286
13			66	2640	32670	174240	457380	627264	457380	174240	32670	2640	66
14				286	7865	70785	283140	566280	594594	330330	94380	12870	715	11
15					1001	20020	135135	411840	630630	504504	210210	43680	4095	140	1
16						3003	45045	231660	540540	630630	378378	114660	16380	945	15
17							8008	91520	360360	640640	560560	244608	50960	4480	120
18								19448	170170	510510	680680	433160	129948	16660	680
19									43758	291720	656370	636480	278460	51408	3060
20										92378	461890	755820	503880	135660	11628
21											184756	671840	755820	310080	38760
22												352716	881790	610470	116280
23													646646	994840	319770
24														1144066	817190
25															1961256

September 5, 2021

15 minutos atrás, DixieJoe disse:

Interessante observar, em relação ao ATRASO da dezena 08 na posição 8.

Ela "deveria" já ter saido 14 vezes nos 2304 sorteios ocorridos. SAIU APENAS 7 vezes nessa posição 8.

Então ela está DEVEDORA nessa posição, 7 vezes já.

Quando ela voltar nessa posição 8, só existem 19448 jogos possíveis no universo total de 3,2 milhões!

Jogo de espera? E aplicando outros filtros nos 19448 jogos????

O que acham?

Pq ainda é tão complicado pra nó respondermos perguntas como esta? Complicado.

September 5, 2021

16 minutos atrás, DixieJoe disse:

Só não vieram nas respectivas POSIÇÕES EM QUE ESTAVAM MAIS ATRASADAS.

No meu ver, nesse tipo de estudo há que se analisar o "percentual de confirmação", ou seja a ocorrência de acerto dessa lógica: a dezena mais atrasada é melhor opção? Ou a 'Xª' mais atrasada?

September 5, 2021

5 minutos atrás, DixieJoe disse:

Percentuais em relação ao que? Total de ocorrências possíveis na posição?

Ou Realmente ocorrido em relação ao esperado na faixa analisada?

Não entendi muito bem o objetivo.

No caso, algo bem simples de começo como: a soma dos percentuais das dezenas na posição/15

September 5, 2021

@DixieJoe O estudo era sobre o percentual de cada dezena. Não estudei o dele lá no site. Mas eu pensava em padronizar todas as 3 milhões sob a soma do percentuais e ver como tem se comportado no histórico de sorteios.

September 5, 2021

6 minutos atrás, DixieJoe disse:

Era isso que queria?

Sim . Obrigado. Eu ia fazer um estudo mas acho que o SPHGF já fez.

September 4, 2021

Em 24/08/2021 em 07:48, DixieJoe disse:

Olá @DixieJoe pode printar toda essa tabela pra mim. Das posições de 1 a 15.

Tinha uma tabela dessas mas depois que o Google virou essa porqueira de ruim, não acho mais em lugar algum.

August 21, 2021

8 horas atrás, Pataca disse:

@Joh2010 Interessante que passei 177.100 linhas para TXT e o arquivo abriu normalmente, agora com 11 linhas deu errado. Mas agradeço a sua dica. Obrigado

Eu vou tentar mandar um GIF pra vc visualizar o procedimento

August 21, 2021

2 horas atrás, Pataca disse:

@dois Este erro que acontece

Faço assim:

1) Copio do Excel e colo no cologa.

2) Copio do cologa e colo no notepad++.

3) Editar>operações com espaço> remover espaços à direita e à esquerda.

4) SALVO o arquivo.

5) Uso normalmente no Analisador.

August 21, 2021

Tipo de busca que eu acredito que poderia ter no programa:

1) Máximo acerto

2) Mínimo acerto

3) Máximo IMSP

4) Mínimo IMSP

5) Mínima colisão entre sorteios

A) Mudar o tipo de busca de uma linha pra outra

B) Poder selecionar as linhas pra um "copiar e colar" mais fácil.

INDEPENDENTE disso é um ótimo programa.

July 10, 2021

Se possível em programas conhecidos

July 9, 2021

20 horas atrás, dois disse:

Gostaria muito de compartilhar minhas experiências em estudos parcialmente semelhantes a este,

mas infelizmente continuo gigantescamente atarefado e que para evitar #Tilt atualmente estou me esforçando

só em 2 projetos (sendo que o maior está na pior etapa que é a Mineração) e os demais estão em #ModoPause.

Então vou tentar esta pequena ajuda:

@Wata Para 14 pontos, Em Tese, é mais realista que para 11 pontos devido a Condição proposta.

@Joh2010 Considerando o seu método, sugiro FILTRAR as 3.268.760 em 3 Grupos, para reprovar 1 e processar os outros 2:

GRUPO 1 Considerando o Concurso 1 temos 286.650 Combinações

GRUPO 2 Considerando os demais Concursos que o GRUPO 1 não fez 11 pontos

GRUPO 3 REPROVADO, pois salvo engano, ocorre duplicidade de 11 pontos num mesmo Concurso.

Vale destacar que nesta minha Teoria há 2 Problemas Matemáticos:

(1) Posso estar #ErradoNaMinhaTese

(2) Provavelmente não resulta em Fechamento (100%)

Eu acho que a premissa do Wata ainda é relevante, pra mim, pelo menos no sentido da "Colisão Mínima Entre Sorteios", que teoricamente deixaria a "matriz mais enxuta".

Obviamente, temos visto que não há a possibilidade de mais de 2 linhas sem essa repetição de alguma premiação.

Mas seria interessante poder trabalhar o que é viável, ou seja, a mínima premiação...

Acho que seria interessante alguma busca automática, estou fazendo linha por linha em questão de premiação de 11 a 15, e é trabalhoso.

Se pelo menos o Cologa tivesse a possibilidade de buscar a premiação mínima na filtragem, mas enfim.

Outra coisa é que talvez ficamos naquela de que linha de maior premiação não é a tal "linha inicial". Mas é mais fácil ir por esse caminho dela mesmo assim.

July 8, 2021

1) Busquei a melhor de 11 no Novo Analisador

2) Coloquei as linhas sorteadas por ela na conferência do cologa

3) Gerei as 3 milhões no Cologa

4) Filtrei as elas pela conferência eliminando as que premiaram em sorteios que a linha de mais premiação sorteou.

5) Sobraram 58.000 e poucos

6 Voltei com essas linhas filtradas pro Novo Analisador e busquei qual delas mais premiou nos sorteios que a linha 1 não premiou...

Testei linhas sorteadas até 2273.

A primeira foi a melhor de 11 =271

A segunda linha foi de 255 sorteadas de 11..

July 8, 2021

@WataFiz um teste inicial usando o Cologa... infelizmente começa a ter "colisões" após a 2a linha....

Sign In

Profiles

Forums

Downloads

Posts posted by Joh2010

Todos nós estamos à Anos-luz de se aproximar de ganhar algum premio máximo com Excel, programação, matemática, IA e etc. Não temos sequer a capacidade de dizer com certeza se uma dezena vai vir no próximo jogo ou não, então o que nos resta é avançar com humildade.

Padrões que podem influenciar o próximo sorteio da LotoFácil (com base no último sorteio):

Explicação passo a passo do programa MegaSenaGenerator:

Explicação Detalhada do Algoritmo Genético para Mega Sena