Jump to content

Joh2010

Super VIP
  • Posts

    1,512
  • Joined

  • Last visited

  • Days Won

    3

Everything posted by Joh2010

  1. (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
  2. 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.
  3. 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!
  4. 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()
  5. 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".
  6. 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.
  7. Reduzir a isto ajudaria mais. O resto é pura ilusão.
  8. Pra discussão de uso de fórmulas no campo da loteria
  9. 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.
  10. 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
  11. Pq ainda é tão complicado pra nó respondermos perguntas como esta? Complicado.
  12. 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?
  13. No caso, algo bem simples de começo como: a soma dos percentuais das dezenas na posição/15
  14. @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.
  15. Sim . Obrigado. Eu ia fazer um estudo mas acho que o SPHGF já fez.
  16. 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.
  17. Eu vou tentar mandar um GIF pra vc visualizar o procedimento
  18. 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.
  19. 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.
  20. Que legal @BigMax. Boa postagem. Visual muito limpo da planilha. Simples e objetiva.
  21. 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.
  22. 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..
×
×
  • Create New...