Jump to content

Pedido: Algoritmo, pseudo código ou código fonte


Carlos Martins

Recommended Posts

Ola pessoal do fórum,

 

por acaso alguém de vocês tem o algoritmo ou pseudo código ou código fonte (qualquer linguagem) para a criação de desdobramentos. Por exemplo 25/15/11/15. Preciso mesmo do algoritmos ou código fonte e não de software que faça isso como por exemplo o Cologa. 

 

Desde já agradeço !!!

 

 

Link to comment
Share on other sites

Guest Zangado
20 minutos atrás, Crazy Rabbit disse:

é como você dar de graça (Não estamos falando em dinheiro) mas o trabalho

e o tempo desperdiçado.

engraçado que é a mesma pessoa que fala que tudo em loteria tem que ser de graça

tá ok só a planilhas ela são faceis de fazer e não tomam tempo algum na elaboração das macros e formulas , é assim num piscar de olhos não precisa nem piscar nem aprender nada

Link to comment
Share on other sites

Guest Zangado
11 minutos atrás, Crazy Rabbit disse:

Não é questão de fazer uma planilha, que lhe dá minutos ou poucas horas, estamos falando de dias, meses, anos,

para conseguir montar o software.

 

Então sei o que é difícil, sei também o quanto é difícil, estamos eu e um programador, reconstruindo novamente

o PapaSorte, estamos a 2 meses de trabalho.

 

Então o criador, não vai dar para ninguém (Não estou falando em Dinheiro) estou falando de tempo e também

de abuso por não ter conseguido terminá-lo, é igual a um estupro não consentido.

 

Por isso afirmo, quem tem não dará a ele, nem a mim, nem a ninguém.

Não é questão monetária, é íntimo, simples assim.

 

Crazy Rabbit

macro tbm é programação

a diferença é que planilhas tem um corpo mais facil de montar interfaces e ferramentas já prontas e nem dá para proteger o projeto em si

 

no caso ele falou no codigo que que desdobra e não num fonte de um programa com interface e tudo

qualquer projeto pode levar pouco ou muito tempo e isso depende da complexidade e não se é em basic ou c++ ou java e logicamente a pessoa vai usar a linguagem que domina

 

para vc ter uma ideia a maioria do que eu fiz "que não passei" é em arrys e não em range de planilha portanto muito facil de traduzir para outra linguagem

eu mesmo pensei em transformar em dll em c++ usando a planilha apenas como interface, mas percebi que não vale a pena o trabalho

um codigo desse dá para fazer tbm em vba ficando o limite na propria plataforma em velocidade, se é 32 64b para questão de uso de memoria

Link to comment
Share on other sites

Guest Zangado

putz , tenho que sair cedo e estou aqui discutido

 

3 minutos atrás, Crazy Rabbit disse:

sempre achando uma maneira branda, para suportar seus questionamentos,

e como vc queria que eu argumentasse, com truculência e arrogância ?

 

5 minutos atrás, Crazy Rabbit disse:

aqui ele não foi a fundo no que queria, que é mesmo um "Código Fonte", pois se fosse apenas desdobramentos ele não

precisaria de pedir a ninguém, está disponível em qualquer software, só fazer um dissambler e

teria o mesmo. (Não o Código Fonte Original)

e vc já considerou que ele queria todo um projeto né, com interface e tudo

fora que  vc considera que é melhor usar um disassemble , violar o trabalho de alguem para tentar localizar um trecho de codigo em vez de perguntar e pedir , bem mais facil né

 

 

Link to comment
Share on other sites

Guest Zangado
5 horas atrás, Crazy Rabbit disse:

 

Olá Edcronos,

 

Sou o Crazy Rabbit, nunca fui tão brando com um membro, como você, talvez porque goste

de você, talvez.?????

 

A vida é feita de oportunidades, as vezes você pode apenas ver o tempo passar a sua frente,

ou possa colocar o corpo para atrapalhar, ou talvez aprender com cada um.

 

Faço isso sempre, aprendo com todos, mas tem pessoas que ficam só se lamentando,

toda hora, todo tempo e fico pensando, porque. ?????

 

Se você leva um GOL, não adianta se lamentar, foi culpa deste, foi culpa daquele, o sol que

está prejudicando, está muito frio, está muito quente, o juiz está roubando, nada disso vale,

simplesmente em meu time, joga quem simplesmente, diz, SEGUE LÁ PELOTA.

 

A vida é mais simples do que ficar questionando, questionando, questionando, porque não

mudar e ficar ativo e ir direto aos problemas, aceitá-los as vezes, mesmo contrário e ajudar

a mudar isso, mas não com o discurso de "Oh, Vida, Oh, Azar".

 

Respire Hoje Ainda o Ar de Mudança, ela não está em todos, está em nós, basta deixarmos

que nos invada e apenas um gesto de bondade a um ser será já de grande mudança.

 

Talvez, faça inimigos, porque não aceito tais atitudes, mas nunca me acovardei e sempre

serei combativo perante minhas convicções, não importando com represálias.

 

De Um Amigo,

 

Crazy Rabbit

 

 

bem , cada um com suas particularidades

mas nem tenho como refutar "o discurso de "Oh, Vida, Oh, Azar"."

 

sim temos que ter um diferencial de atitudes e eu nem tenho oq reclamar assim,

talvez por ver o pessoal falando em gastar 200 reais por semana em loteria ou mais , bem cada um faz com seu dinheiro oq bem entende ,

mas daí chegam e falam que quem sabe excel , programação, tem um esquema tem que ajudar , tem que fazer uma boa ação, que isso e aquilo tem que ser de graça pq não garante nada

legal né o cara gasta 200 contos por semana e quer que outro gaste seu tempo que podia estar trabalhando para custear seus próprios jogos trabalhe de graça

outros ainda ficam, faz isso que eu garanto depois te mando as dezenas para vc apostar :shock: ,

se o cara confia tanto assim no seu taco que pague adiantado

fazer amizades onde a regra é o anonimato e todos tem medo de aparece e vim a ganhar brevemente ?

 

e tem aqueles que falam que loteria é investimento de algo risco,

investimento de alto risco é quando a pessoa abre uma joalheria em uma area de muitos assaltos

nem esses lances de bolsa onde o cara "Aposta" se a ação vai subir ou descer no dia  é um investimento pq está apostando na reação das pessoas e não na capacidade da empresa e deixando a grana meses para ser convertida em investimentos e trabalho

 

sim a culpa da minha situação é minha mesmo, pq não soube aproveitar as oportunidade que a vida me deu , muitas delas eu perdi por confiar demais ,

sim tem o fato de já ter passado fome e até comido coisa do lixo, mas tenho que agradecer por ter sido abençoado com uma mente que analisa "pena que não tem a mesma capacidade de agir"

pq tem pessoas que estão praticamente na mesma situação daquela epoca por não saber viver e querer esbanjar tudo oq ganha

 

sobre criticar eu falo apenas onde cabe a minha critica,  e tbm não quero sair de bonzinho como uns e outros

 

sobre respirar o ar da mudança realmente vc está certo, eu sei até algumas mudanças seriam significativas em minha vida

 uma delas seria largar isso aqui de lado que nem tem futuro

"ME" ajudar, sair um pouco sem pesar nas contas que tenho que pagar "infelizmente depois elas ficam pior"

tentar conhecer gente que valha a pena fora desse lugar

arrumar outro tipo de emprego mesmo que seja serviços gerais onde não precise ficar pensando nisso e naquilo , é só chegar e fazer

 

 

putz, e entra naquele momento que vc enxerga que tá perdendo um bocado de tempo e devia troca de livro em vez de apenas virar a pagina

 

 

 

Link to comment
Share on other sites

8 horas atrás, Carlos Martins disse:

Ola pessoal do fórum,

 

por acaso alguém de vocês tem o algoritmo ou pseudo código ou código fonte (qualquer linguagem) para a criação de desdobramentos. Por exemplo 25/15/11/15. Preciso mesmo do algoritmos ou código fonte e não de software que faça isso como por exemplo o Cologa. 

 

Desde já agradeço !!!

 

 

Carlos Martins,

 

Veja aqui mesmo no forum o post do colega substantivo que publicou um pseudo-algoritmo muito inteligente para gerar desdobramento do tipo que você mencionou.

Já está publicado aqui no forum. Só pegar. Mas estou anexando abaixo também.

 

Quanto a outros, em muitos anos de pesquisa que andei fazendo a respeito pela Internet afora, encontrei o código-fonte "básico" do ININUGA e também do COVER.

 

São dois dos mais rápidos softwares do mercado (FREE, porisso publicaram na Internet).

 

Mais rápido do esses só o do Aleksander da AS Computer Software que utliza Assembler junto com Power Basic

 

http://www.as-computer-software.com/lotto.html

 

No caso do Aleksander, a meta dele é ter o mais rápido software de desdobramento e de filtragem.  Ele vende os fontes (eu comprei - mas confesso que não tenho "capacidade" para entender e programar em Assembly -- quem sabe um dia, eu me dedique a aprender Assembly)..

Não vou mandar os fontes dele porque eu paguei e me comprometi a não distribuir.

 

Quanto aos softwares ININUGA e COVER você encontra facilmente na Internet. Vou montar um arquivo zip para deixar disponível numa pasta dropbox para download (sempre por algum tempo, depois eu preciso do espaço e de vez em quando, apago). 

 

Não consigo anexar aqui pelas regras do forum quanto aos tipos de arquivo.

 

Aqui está:

 

https://www.dropbox.com/s/ct4vc12keowxzrp/Materiais Interesse Combinacoes.rar?dl=1

 

Fontes, Materiais, Comentários Diversos que podem ser úteis para quem se aventurar a desenvolver programas de loterias.

 

Faça bom proveito e lembre-se de nós pobres mortais quando tiver algo semelhante para retribuir, por favor!

 

 

----------------------

 

Permita-me algumas considerações pessoais:

 

1- Se for programar para Desdobramentos, utilize Assembly. É o mais rápido que você vai conseguir. E vai necessitar de velocidade, acredite. 

2- Compre os fontes do Aleksander da AS ComputerSoftware. Vale cada centavo para quem entende de programação Assembly e Power Basic. (Não é o meu caso... Só mexo com Delphi, atualmente).

3- Se for desenvolver pensando em mais de 64 dezenas, só depois que tiver o melhor programador em Assembly. 

4- Para muitas dezenas (acima de 60) eu usaria o COLOGA. É o melhor software para fazer isso para loterias... Explico: O Cover e o ININUGA são ótimos para loterias mas foram desenvolvidos pensando em otimizar a quantidade de linhas de cada tipo de desdobramento. Infelizmente, os dois softwares só trabalham diretamente com até 32 dezenas. Precisa de muito trabalho para otimizar para linhas maiores...

5- MINHA DECISÃO PESSOAL ATÉ AGORA FOI DE NÃO ME AVENTURAR EM DESENVOLVER PROGRAMAS PARA DESDOBRAMENTOS. Sou muito "burro" para aprender Assembly adequadamente no sentido de "incrementar" e de tentar melhorar o que já existe e está pronto.

 

São anos e anos de estudo e esta conclusão a que cheguei depois de tentar linguagens diferentes e de aprender um pouco sobre Assembly. Desisti do Assembly, por enquanto. Precisa-se de muito tempo e estudo para usar adequadamente.

 

 

--------

 

De novo, espero que a comunidade do forum seja beneficiada com seus estudos e conclusões...

 

 

 

 

 

  • Like 1
  • Thanks 1
Link to comment
Share on other sites

Guest Pitaco_certo!

 

 

 

Substantivo, talvez ajude você a elaborar sua planilha ou mesmo incrementar algo nela;

 

Quando me conte o que precisa para que você possa ajudar a completar seu projeto que vou te ajudar como for;

 

 

Carlos, avalie e por favor veja se serve;

 

 

Eu tenho aqui te muito tempo, e estou compartilhando;

 

 

Dim matrizNum 

Private Sub Command1_Click()
List1.Clear

matrizNum = Split(txtnumeros, ",")
Call geraComb(UBound(matrizNum) + 1, CInt(txtelementos), 1, 1, "")
MsgBox List1.ListCount
End Sub

Sub geraComb(totalNum As Integer, totalElementos As Integer, ElementoAtual As Integer, num As Integer, sequencia As String)
Dim seqTemp As String
Dim limiteElem As Integer

limiteElem = totalNum - (totalElementos - ElementoAtual)

For i = num To limiteElem
    seqTemp = sequencia & Format(matrizNum(i - 1), "00")
    If ElementoAtual < totalElementos Then
        Call geraComb(totalNum, totalElementos, ElementoAtual + 1, i + 1, seqTemp & " - ")
    Else
        List1.AddItem seqTemp
    End If
Next i

End Sub 
 

Link to comment
Share on other sites

Guest Pitaco_certo!

Dixie;

 

Agora talvez ajude em algo para você especificamente;

 

 

Function TfrmForm.Sorteio(InicioIntervalo, FimIntervalo, QuantosRetornos: Integer): String;
Var Retorno, SS: String;
    Vetor : array of integer;
    Valor, i, j, x : Integer;
    Repetido : Boolean;
    label volta;

    function BuscaRND(vValor:Integer):Integer;
    begin
       Result := Random(vValor)
    end;

Begin

  //incrementa 1 ex: Ramdom(100) vai considerar 0 a 99
  FimIntervalo := FimIntervalo + 1;

  //redimensiona vetor para a quant. de retornos requerida
  SetLength(Vetor, QuantosRetornos);

  Randomize;

  For i := 0 To QuantosRetornos - 1 Do Begin

    Valor := 0;

    volta: //foi achado repetido mais abaixo

    //se retornou zero busca recursivamente até retornar > 0
    repeat
      Valor := BuscaRND(FimIntervalo);
    until (Valor >= InicioIntervalo) and (Valor < FimIntervalo); //permanece na repetição até que a condição seja atendida

    //vê se valor já existe no vetor
    Repetido := False;
    for j := 0 to QuantosRetornos - 1 do begin
       if Vetor[j] = Valor then begin
        Repetido := True;
        break;
       end;
    end;

    //se não é repedido insere no vetor
    if (Valor >= 1) AND (Repetido = False) then
      Vetor := Valor
    else
      goto volta; //busca novo valor qdo repetido, sem sair da repetição i atual
                
  End;

  //ordena valores em ordem crescente
  for i := Low(Vetor) to (High(Vetor)-1) do begin
    for j := i + 1 to High(Vetor) do
    begin
        if Vetor > Vetor[j] then
        begin
             x           := Vetor;
             Vetor    := Vetor[j];
             Vetor[j]    := x
        end;
    end;
  end;

  //lê vetor e concatena resultado para texto
  for j := 0 to High(Vetor) do begin
    Retorno := Retorno + IntToStr(Vetor[j]) + #13#10;
  end;

  Result := Retorno;
End; 
 

 

 

Edited by Pitaco_certo!
Link to comment
Share on other sites

Obrigado, Pitaco_certo!

 

Vou analisar com carinho e te dou retorno.

 

---------------------

 

Você sabe que o "MAIOR PROBLEMA" na geração de bons programas do tipo Desdobramentos e avaliações de conjuntos é a parte da CONTAGEM?

 

Uma função de Contagem de ACERTOS entre 2 conjuntos ou mesmo de contagem dentro de um único conjunto (tipo QTE de valores existentes num array), é chamada milhares ou milhões ou mesmo bilhões de vezes nos diversos testes que são necessários.

 

Quanto mais linhas de teste e quanto mais dezenas envolvidas, mais necessária essa função. E mais velocidade é necessária, claro.

 

Porisso, o ponto nevrálgico dos nossos programas de loterias (em especial para contagem...) é justamente essa função.

 

As demais, podemos até conviver com uma certa "lentidão".

 

Gerar jogos é sempre rápido com as funções existentes. Filtrar jogos pode ser demorado dependendo da "criatividade" do autor.

 

Mas CONTAR precisa ter uma rotina SUPER ESPERTA. 

 

Qualquer dia, vou procurar um professor de Assembly para me ajudar a criar essa função de CONTAGEM em Assembly com o objetivo de usar dentro do próprio DELPHI.

  • Thanks 1
Link to comment
Share on other sites

Guest Pitaco_certo!

Você sabe o que é o pior...

 

Eu fazia aulas de Assembler e tenho vários amigos altamente especializados em Assembler, já trabalhei com microcontroladores e afins, mas minha função era apenas executiva.

 

Quase hein....

 

Estou pensando em fazer muitas coisas....

 

Nós que gostamos de loterias, precisamos nós mesmos financiar isso, daria certo pode acreditar....

 

Isso resolveria um problemão....para todos nós....

 

Eu conheço escritores de livros de assembler, vou pensar em algo....

 

Att,

Edited by Pitaco_certo!
Link to comment
Share on other sites

ok dixie, o problema vai ficar no caso de escolher exemplo 30 numero de 50

 ou uma parte de um todo de uma loteria é acertar dentro dos 30 todas as dezenas sorteadas

 porque partir de um todo tem muita combinaçao, temos achar um viés de achar os nueros que podem

 sair ai um desdobre serve, uma forma , seria escolher certos numeros que vai sair no inicio e no final da aposta

 e tambem nao repetir na posiçao=  exemplo algoritmo que filtro na posiçao exemplo a dezena 04 na lotofacil

so para 3ª ou 4ª posiçao  outro exemplo na mega a dezena 51 so  para a 5ª e 6ª posiçao,

sincronidadas com cruzamento de patroes exemplo= 3/3 pares e impares

Link to comment
Share on other sites

Pitaco_certo!

 

kkkkk. Você conhece Assembler. Legal.

 

É basicamente 1 função que precisamos fazer no Assembler:

 

1- Contar Qte de Itens num INTEGER com até 64 bits (Seria a contagem de BITs setados em 1, o que corresponde a saber quantos valores dos 64 bits terão o valor 1)

(Eu tenho essa rotina em Assembler... mas conta até 32 bits.... SUPER RÁPIDO... Ela foi feita pelo Uros Boltin, programador do ININUGA--- ATÈ já tentei passar para 64 bits, mas meu conhecimento de Assembler não é suficiente.) Contando até 64 bits, temos chances de trabalhar com loterias até 64 dezenas... Ainda não para Timemania, nem para Quina, nem para a Lotomania)

 

Ampliar essa mesma rotina contador de 64 bits para um INTEGER de 128 bits... SEI que é possível, mas não sei fazer.

 

Colocar essa rotina em Assembler dentro de uma função em Delphi para "Emendar" nos meus programas.

 

Outra função que seria importante fazer é a União de dois valores INTEGER em um TERCEIRO Integer.

Mas vamos devagar.

 

----

 

Se você quiser, te mando as funções em Assembler (Assembly????) que tenho para 32 bits e você passa para seus amigos para ver o que pode ser feito para adaptá-las para 64 bits e depois para 128 bits.  Ou já fazer para 128 bits, usando Assembler com QUADWord (que permite trabalhar com 128 bits).

 

----

 

Tenho também uma função que conta (em Assembler, mas em chamadas do PowerBasic) que é utilizada pelo Aleksander Stefanovic da AS-ComputerSoftware de quem adquiri os fontes para alguns programas dele. Neste nosso caso, não tenho problemas em "separar" essas funções e passar parav você ou seus amigos para ajudar na elaboração do que nos é necessário fazer.

  • Like 1
Link to comment
Share on other sites

4 minutos atrás, sorel disse:

ok dixie, o problema vai ficar no caso de escolher exemplo 30 numero de 50

 ou uma parte de um todo de uma loteria é acertar dentro dos 30 todas as dezenas sorteadas

 porque partir de um todo tem muita combinaçao, temos achar um viés de achar os nueros que podem

 sair ai um desdobre serve, uma forma , seria escolher certos numeros que vai sair no inicio e no final da aposta

 e tambem nao repetir na posiçao=  exemplo algoritmo que filtro na posiçao exemplo a dezena 04 na lotofacil

so para 3ª ou 4ª posiçao  outro exemplo na mega a dezena 51 so  para a 5ª e 6ª posiçao,

sincronidadas com cruzamento de patroes exemplo= 3/3 pares e impares

Sorel,

 

Para conjuntos maiores do que 10-15 dezenas, temos de usar a criatividade e trabalhar com JOGOS previamente prontos e feitos por outros desdobramentos ou gerados usando o mesmo princípio que o Cologa usa: ALEATÓRIOS e TESTES contínuos...

 

Suas outras dicas são importantes mas não necessárias, por enquanto. São FILTROS, e podemos aplicar depois...

 

  • Thanks 1
Link to comment
Share on other sites

Pitaco_certo!

 

Esta rotina está em Delphi (Pascal).

 

Count := 0; 
while x<>0 do begin 
    x := x and (x-1); 
    Inc(Count); 
end;

 

É exatamente isso que precisamos fazer (Em Assembly) para permitir usar In-Line dentro do Delphi.

 

O que ela faz:

 

1- Recebe um INTEGER (preferencialmente, no nosso caso, de 128 bits) onde cada bit estará SETADO em 1 se o valor correspondente existir.

Explicado melhor: cada BIT representa uma DEZENA nossa. No caso, vamos usar do Bit 0 até o Bit 99 = Dezena 1 até Dezena 100.

Inicializa um contador Count em 0 (vai armazenar a quantidade de BITS setados em 1.

Testa os bits, um por um, enquanto eles tiverem o valor de 1... É aí que está a BELEZA do código!!!! Só conta quando o valor estiver em 1, senão, simplesmente vai para o próximo bit com valor 1.

 

Depois te mando a rotina do AS em Assembler. Acho que ele conta diferente. Mas é super rápido também.

 

----

 

 

Outro ponto importante: nos Assemblers para processadores mais modernos, parece que já existe uma rotina no próprio Assembler que já faz isso.

 

Chama-se 

 

popcout

 

NÃO SEI COMO USAR ISSO, INFELIZMENTE....

 

----------------

Link to comment
Share on other sites

Guest Pitaco_certo!

Dixie, 

 

Vai ser feito, fica suze!

 

Vou ler com calma, mas eu vou tentar te ajudar nisso!

 

Matemos contato!

 

Até!

Edited by Pitaco_certo!
Link to comment
Share on other sites

Pitaco_Certo!

 

Esta é a função que utilizo atualmente quando uso Integers (até 32 bits). Precisamos trabalhar com 64 bits ou, de preferência, com 128 bits

 

Função PARA TRABALHAR COM BITS EM  valores INTEGER ----Funciona para até 32 bits porque não sei trabalhar com mais BITS...

 

 Conjunto = Jogo = primeiro valor em Integer com os bits setados representando as dezenas presentes no conjunto - Máximo de 32 bits, por enquanto.

 Resultado = Outro Jogo (chamei de Resultado) usado para comparar com o primeiro

 x  =  Terceiro conjunto gerado onde os BITS setados são apenas aqueles que forem IGUAIS entre os 2 primeiros jogos. Este conjunto X é que vai ser 'CONTADO'.

          Quantos BITS setados (dezenas que ficaram iguais entre os 2 primeiros) no conjunto X (terceiro conjunto).

 

AND   =  faz a intersecção dos 2 primeiros conjuntos (sempre em Integer). Lembre-se que aqui estamos trabalhando com os BITS diretamente.

 

 

QUEREMOS FAZER ALGO PARECIDO PARA 64 BITS (Megasena) e para 128 bits (na verdade, serão usados apenas os bits 0 a 99 = 100 bits (para outras loterias com mais dezenas.

 

 

E, de preferência, queremos fazer isso diretamente em Assembly e não em PASCAL ou Delphi, como no exemplo abaixo.

 

//-------------------------------------------------------

 

function ContarAcertos( Conjunto, Resultado: Integer ): Integer;       // OK

var

  x : Integer;

begin

 

  Result := 0;                                      // Valor do Contador

  x := Conjunto AND Resultado;  // o AND faz a INTERSECÇÃO dos dois conjuntos recebidos

// e gera um terceiro conjunto X onde vai ser contada a

// quantidade de BITS setados.

 

  while x <> 0 do                              // Enquanto X for diferente de 0

                begin

                   x := x AND ( x - 1 );        // faz com que X seja ele próprio AND ele menos 1... isso muda

// os bits internamente para agilizar na conferência

                   Inc( Result );                  // Incrementa o Contador de Quantidade de BItS Setados em

              // 1… E devolve o resultado pela função

                end;

end;

 

//-------------------------------------------------------

Link to comment
Share on other sites

program Reducteur; 


{$APPTYPE CONSOLE} 


uses 
  SysUtils; 



  Objetivo: programa de cálculo do sistema de redução
O programa calcula o número de combinações necessárias para
Certifique-se de obter n números entre m puxados em uma seleção de números p


type 
  TCombinaison = record 
    Necessaire : Boolean; 
    Tirage : array[0..5] of byte; 
  end; 


function Combinaison(AValeurMax : Integer; ASelection : Integer) : Integer; 
var 
  i : Integer; 
  p : Integer; 
  r : Int64; 
begin 
  r := 1; 
  p := AValeurMax; 
  for i := 0 to Pred(ASelection) do begin 
    r := p * r; 
    Dec(p); 
  end; 
  p := ASelection; 
  for i := 0 to Pred(ASelection) do begin 
    r := r div p; 
    Dec(p); 
  end; 
  Result := r; 
end; 


var 
  i : integer; 
  j,k,l : Integer; 
  nb_numeros_tires : Integer; 
  nb_numeros_selectionnes : Integer; 
  nb_numeros_objectif : Integer; 
  nb_numeros_max : Integer; 
  combinaisons : array of TCombinaison; 
  nb_combinaisons : Integer; 
  nb_numero_communs : Integer; 
  nb_combinaisons_selectionnee : Integer; 
begin 
  nb_numeros_tires := 6;     // numeros por coluna
  nb_numeros_max := 49;   //numeros total
  nb_numeros_objectif := 3;  //garantia de acerto
  for nb_numeros_selectionnes := nb_numeros_tires to nb_numeros_max do begin 
    // calcul du nombre de combinaisons possibles 
    nb_combinaisons := Combinaison(nb_numeros_selectionnes, nb_numeros_tires); 
    SetLength(combinaisons, nb_combinaisons); 
    System.Writeln(Format('Selection : %d '#7' Combinaisons : %d', [nb_numeros_selectionnes, nb_combinaisons])); 


    // remplissage du tableau 
    combinaisons[0].Tirage[0] := 1; 
    combinaisons[0].Tirage[1] := 2; 
    combinaisons[0].Tirage[2] := 3; 
    combinaisons[0].Tirage[3] := 4; 
    combinaisons[0].Tirage[4] := 5; 
    combinaisons[0].Tirage[5] := 6; 
    Combinaisons[0].Necessaire := True;   // Par défaut on garde tout 
    if High(Combinaisons) > 0 then begin 
      for i := 1 to High(Combinaisons) do begin 
        for j := 0 to High(Combinaisons.Tirage) do begin 
          Combinaisons.Tirage[j] := Combinaisons[i-1].Tirage[j]; 
        end; 
        j := High(Combinaisons.Tirage); 
        Inc(Combinaisons.Tirage[j]); 
        while Combinaisons.Tirage[j] > (nb_numeros_selectionnes + j - High(Combinaisons.Tirage)) do begin 
          Inc(Combinaisons.Tirage[j-1]); 
          Dec(j); 
        end; 
        for j := 1 to High(Combinaisons.Tirage) do begin 
          if Combinaisons.Tirage[j] > (nb_numeros_selectionnes + j - High(Combinaisons.Tirage)) then begin 
            Combinaisons.Tirage[j] := Combinaisons.Tirage[j-1] + 1; 
          end; 
        end; 
        Combinaisons.Necessaire := True; 
      end; 
    end; 


    //Encontrando as combinações necessárias
    nb_combinaisons_selectionnee := 0; 
    for i := 0 to Pred(nb_combinaisons) do begin 
      if Combinaisons.Necessaire then begin 
        Inc(nb_combinaisons_selectionnee); 
        for j := i + 1 to Pred(nb_combinaisons) do begin 
          nb_numero_communs := 0; 
          for k := 0 to High(Combinaisons.Tirage) do begin 
            for l := 0 to High(Combinaisons[j].Tirage) do begin 
              if Combinaisons.Tirage[k] = Combinaisons[j].Tirage[l] then begin 
                Inc(nb_numero_communs); 
                if nb_numero_communs = nb_numeros_objectif then break; 
              end; 
            end; 
            if nb_numero_communs = nb_numeros_objectif then break; 
          end; 
          if nb_numero_communs = nb_numeros_objectif then begin 
            Combinaisons[j].Necessaire := False; 
          end; 
        end; 
      end; 
    end; 


    // Affichage 
    Writeln(Format('%d combinaisons necessaires', [nb_combinaisons_selectionnee])); 
    for i := 0 to Pred(nb_combinaisons) do begin 
      if Combinaisons.Necessaire then begin 
        for j := 0 to High(Combinaisons.Tirage) do begin 
          write(Format('%.2d ', [Combinaisons.Tirage[j]])); 
        end; 
        writeln(''); 
      end; 
    end; 


  end; 
  system.Readln; 


end.

Link to comment
Share on other sites

Tem também este fonte em C

 

C Code to generate Wheels

 


#define        ORDER        6        // eg, the 6 in 6/49

int        N;        // your series length - eg, 15
int        M;        // order eg, 6 - the ORDER

int        minWin;        // guaranteed win...
int        minHit;        // every time you hit these many


long        cmbcnt = 0;        // total # of combinations generated
long        sqzcnt = 0;        // total # of combinations extracted (squeezed)

WORD        tabmax;        // size of squeeze table
BYTE *        sqztab;        // squeeze table

BYTE        indxtab[LASTN + 1];     // index from 1
BYTE        combtab[LASTN + 1];     // your series goes in here
/*----------------------------------------------------------------------*/
// first you'll need a method of generating combinations
void        comb(int i, int n, int m, int pos)
{
        int        j;

        if (m <= 1)
                while (i <= n)
                        {
                        indxtab[pos] = i++;
                        emit();        // supply your own stub
                        }
        else
                while (n - i + 1 >= m)
                        {
                        indxtab[pos]  = i++;
                        comb(i,n,m-1,pos+1);
                        }
}
/*----------------------------------------------------------------------*/
void        emit(void)
{
        BYTE        srccmb[ORDER];

        int        i;
        long        j;
        int        hit;


        for (i = 1; i <= M; i++)
                srccmb[i-1] = combtab[indxtab];
        cmbcnt += 1;

        // filter out unwanted combinations here
        if (!foobar())
                return;

        // discard any combination that repeats an 
        // identical minWin for maxHit
        hit = FALSE;
        for (j = 0; j < sqzcnt; j++)
                {
                if (match(&sqztab[j * ORDER], srccmb, win))
                        {
                        hit = TRUE;
                        break;
                        }
                }

        if (!hit)
                {
                if (sqzcnt >= (long)memNcombos)
                        {
                        printf("the sky has fallen again!\n");
                        exit(1);
                        }
                memcpy(&sqztab[sqzcnt++ * ORDER], srccmb, ORDER);
                }
}
/*----------------------------------------------------------------------*/
int        match(BYTE *tar, BYTE *pat, int hit)
{
        int        i;
        int        j;
        int        m;

        m = 0;
        for (i = 0; i < ORDER; i++)
                for (j = 0; j < ORDER; j++)
                        if (tar == pat[j])
                                {
                                m +=1;
                                break;
                                }
        return (m >= hit);
}
/*----------------------------------------------------------------------*/
void        main(int argc, char *argv[])
{
        int        i;


        blah blah blah...

        minWin = 5;
        maxHit = 6;        // ie win 5 if you hit 6

        for (memNcombos = ((64 * 1024L - ORDER)/6); memNcombos != 0; memNcombos -= 1)
                if ((sqztab = malloc(ORDER * memNcombos)) != NULL)
                        break;
        if (!sqztab)
                showErrorAndQuit("out of memory");

        for (i = 1; i <= N /* your series length */; i++)
                cmbtab = any #; the same numbers arranged in a 
                                   different order yield different
                                   output.
                                   if you assign i to combtab
                                   then you can write it to disk and
                                   read it to index any given series
                                   without regenerating the combinations

        memset(sqztab,  0, memNcombos * ORDER);
        M  = ORDER;
        cmbcnt = 0;
        sqzcnt = 0;
        comb(1, N, M, 1);

        dump the contents of sqztab (sqzcnt combinations)
}

 

 

 

 

 

Link to comment
Share on other sites

Join the conversation

You can post now and register later. If you have an account, sign in now to post with your account.
Note: Your post will require moderator approval before it will be visible.

Guest
Reply to this topic...

×   Pasted as rich text.   Paste as plain text instead

  Only 75 emoji are allowed.

×   Your link has been automatically embedded.   Display as a link instead

×   Your previous content has been restored.   Clear editor

×   You cannot paste images directly. Upload or insert images from URL.

  • Recently Browsing   0 members

    • No registered users viewing this page.
×
×
  • Create New...