Jump to content

Software Dixie.


wesleybobato

Recommended Posts

1 minuto atrás, DixieJoe disse:

Olá dois,

 

Então essa planilha já é resultado do seu aprendizado? Parabéns pela velocidade que aparentemente deve ser muito boa.

 

Continuo sem entender como posso contribuir com seus estudos. 

 

 

 

 

Ainda não... 

Nem comecei o curso ainda, pois decidi antes aprender o EXCEL a partir do zero (Básico)

através de um "livrinho" de mais de 1200 páginas...

 

Um abraço!

 

  • Like 1
Link to comment
Share on other sites

38 minutos atrás, DixieJoe disse:

 

Continuo sem entender como posso contribuir com seus estudos. 

 

 

 

Depende no que você pode se dedicar.

Há necessidades que dependem de entender os Conceitos que são aplicados nos estudos

(Tabela 60% x 40%, Tabela Diagrama de Venn, Propagação, ...) mas há outras que não,

como, por exemplo:

 

Em 15/11/2016 at 20:33, DixieJoe disse:

 

----

Claro que isso não quer dizer que não haveria 2 outros acertando 100% em todos os sorteios possíveis, se utiizássemos os 3.268.760 contra os 3.268.760... Mas isso é tarefa para gigantes. E eu sou só formiguinha...

 

----

 

O que mais a gente poderia fazer para melhorar essa busca? 

 

 

 

Propositalmente mostro lá na figura (de forma implícita) que, matematicamente,

é possível reduzir gigantescamente o processamento.

 

Lá mostro UMA forma de redução para 25-15-9-15=2

e, SE necessário, ainda se pode reduzir ainda mais.

 

 

Um  abraço!

 

Link to comment
Share on other sites

dois,

 

Com relação ao tempo de processamento, ele vai poder ser reduzido dependendo dos "truques" que vierem a ser utilizados em qualquer processamento.

Um deles talvez seja a questão de usar as matrizes da forma que você vem colocando.

 

Se for para processar tudo contra tudo (força-bruta...), não tem milagre... Veja meus processamentos para a Lotofacil. Eles demoram porque a gente cruza tudo contra tudo... Então, vai ser necessário criar algo novo para "pular" etapas com segurança. Eu ainda não sei como fazer.

 

Com relação aos conceitos de 60% x 40%, ele é matemático e intuitivo para a LF. Só não intui ainda como você pretende utilizar isso.

 

Com relação à Tabela de Venn, idem. Não sei como usar isso a nosso favor.

 

Propagação só entendi a teoria até agora. Como utilizar na prática? Aguma idéia?

 

 

Link to comment
Share on other sites

1 hora atrás, DixieJoe disse:

dois,

 

Questão (1)

Com relação ao tempo de processamento, ele vai poder ser reduzido dependendo dos "truques" que vierem a ser utilizados em qualquer processamento.

Um deles talvez seja a questão de usar as matrizes da forma que você vem colocando.

 

Questão (2)

Se for para processar tudo contra tudo (força-bruta...), não tem milagre... Veja meus processamentos para a Lotofacil. Eles demoram porque a gente cruza tudo contra tudo... Então, vai ser necessário criar algo novo para "pular" etapas com segurança. Eu ainda não sei como fazer.

 

Questão (3)

Com relação aos conceitos de 60% x 40%, ele é matemático e intuitivo para a LF. Só não intui ainda como você pretende utilizar isso.

 

Questão (4)

Com relação à Tabela de Venn, idem. Não sei como usar isso a nosso favor.

 

Questão (5)

Propagação só entendi a teoria até agora. Como utilizar na prática? Aguma idéia?

 

 

 

 

Questão (1)

Não é "truque"... é Matemática + estudos + análises + exaustivos testes... KKK

 

Questão (2)

O processamento continua sendo tudo-contra-tudo (força bruta)...

Porém, matematicamente, é possível FILTRAR até sem nenhuma perda na garantia.

SE não ocorrer nenhum imprevisto, até a próxima Segunda-feira postarei um exemplo

com a Matriz 25-15-9-15=2 e também o passo-a-passo de como foi criada.

 

Questão (3)

Ele norteia as previsões das Quantidades de Dezenas Presentes e de Dezenas Ausentes

quando se deseja quantidades de Linhas/Combinações próximas do mínimo.

 

Questão (4)

A Tabela Diagrama de Venn é um Conceito que continuo estudando, graças a gigantesca colaboração do @Sphgf

a quem aqui agradeço novamente.  O que até atualmente consegui descobrir é:

    1.) Calcular as Quantidades ideais de Dezenas em determinada Matriz, sendo que a sua propriedade

           Intersecção indica a Quantidade de Dezenas FIXAS.

    2.) Cada percentual de garantia do Fechamento Matemático é referência para o respectivo percentual de

          garantia de Fechamento Histórico.

 

Questão (5)

Também será aplicada no exemplo que postarei e também explicado no passo-a-passo..

Talvez antes eu elabore explicações utilizando gráfico.

 

 

Um abraço!

 

  • Like 1
Link to comment
Share on other sites

  • 3 months later...
Em 01/11/2016 at 06:01, DixieJoe disse:

Wesley,

 

Este é o código que encontrei para gerar combinações de qualquer tamanho: 

 

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

procedure GerarNext_Colex( var x : Integer );  // Gera Todas as Combinações em Ordem Co-Lexicográfica
                                               // a partir da primeira passada inicialmente na rotina
                                               // em geral, a primeira é = 0
                                               // var x contem a primeira combinação
var
  r, z: Integer;

begin

  r := x AND ( ( NOT x ) + 1 );
  x := x + r;
  if ( x = 0 ) then Exit;
  z := x AND ( ( NOT x ) + 1 );
  z := z - r;
  while ( ( z AND 1 ) = 0 ) do z := z SHR 1;
  x := x OR ( z SHR 1 );

end;

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

 

-----

 

 

Curiosidade: esta rotina é super rápida. Chega a gerar mais de 80.000.000 de combinações por segundo.

 

E usa manipulação de Bits dentro dos INTEGERS. Cada bit dentro do Integer representa uma dezena.

 

DixieJoe,

 

Caso necessite usar infinitos Bits com limitação sendo a memória do computador para suportar o tamanho do bit, use as funções disponíveis em https://github.com/rvelthuis/DelphiBigNumbers muitas estão escritas em Assembler.

 

Funciona nas versões XE em diante, não chega a ser tão rápido como a INT32, mas para quem precisa, acredito servir.

 

Fiz testes aqui, a meu ver satisfatórios.

 

A execução do código abaixo levou 109 segundos para ser concluído sendo executado em um Intel Core I7 4ª de 3,4GHz. O código refere-se a passar por todas as combinações da Mega Sena.

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

procedure GerarNext_Colex( var x : BigInteger );  // Gera Todas as Combinações em Ordem Co-Lexicográfica
                                               // a partir da primeira passada inicialmente na rotina
                                               // em geral, a primeira é = 0
                                               // var x contem a primeira combinação
var
  r, z: BigInteger;

begin

  r := x AND ( ( NOT x ) + 1 );

  x := x + r;
  if ( x = 0 ) then Exit;
  z := x AND ( ( NOT x ) + 1 );
  z := z - r;
  while ( ( z AND 1 ) = 0 ) do z := z SHR 1;
  x := x OR ( z SHR 1 );

end;

 

function SparseBitCount(X: BigInteger): Integer;
begin
  Result := 0;
  while X <> 0 do begin
    Inc(Result);
    X := X and (X - 1);
  end;
end;

 

procedure TForm1.Button1Click(Sender: TObject);
var x : BigInteger;
 myFile : TextFile;
  text   : string;
  t1, t2, elapsedTime : TDateTime;
  cont,i: integer;

    startTime64, endTime64, frequency64: Int64;
  elapsedSeconds: single;
begin

  x := trunc(power(2,6))-1;
  i := 0;
  AssignFile(myFile, 'Test.txt');
  ReWrite(myFile);

  QueryPerformanceFrequency(frequency64);
  QueryPerformanceCounter(startTime64);

  while i < 50063860 do
  begin
//    cont := SparseBitCount(x);
//      writeln(myFile, x.ToString + ' ' + inttostr(cont));
    GerarNext_Colex(x);
    inc(i);
  end;

  QueryPerformanceCounter(endTime64);
  elapsedSeconds := (endTime64 - startTime64) / frequency64;

  CloseFile(myFile);

  showmessage(floattostr( elapsedSeconds  ));

end;

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

Edited by Guy Novaes
Link to comment
Share on other sites

2 horas atrás, Guy Novaes disse:

 

DixieJoe,

 

Caso necessite usar infinitos Bits com limitação sendo a memória do computador para suportar o tamanho do bit, use as funções disponíveis em https://github.com/rvelthuis/DelphiBigNumbers muitas estão escritas em Assembler.

 

Funciona nas versões XE em diante, não chega a ser tão rápido como a INT32, mas para quem precisa, acredito servir.

 

Fiz testes aqui, a meu ver satisfatórios.

 

A execução do código abaixo levou 109 segundos para ser concluído sendo executado em um Intel Core I7 4ª de 3,4GHz. O código refere-se a passar por todas as combinações da Mega Sena.

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

procedure GerarNext_Colex( var x : BigInteger );  // Gera Todas as Combinações em Ordem Co-Lexicográfica
                                               // a partir da primeira passada inicialmente na rotina
                                               // em geral, a primeira é = 0
                                               // var x contem a primeira combinação
var
  r, z: BigInteger;

begin

  r := x AND ( ( NOT x ) + 1 );

  x := x + r;
  if ( x = 0 ) then Exit;
  z := x AND ( ( NOT x ) + 1 );
  z := z - r;
  while ( ( z AND 1 ) = 0 ) do z := z SHR 1;
  x := x OR ( z SHR 1 );

end;

 

function SparseBitCount(X: BigInteger): Integer;
begin
  Result := 0;
  while X <> 0 do begin
    Inc(Result);
    X := X and (X - 1);
  end;
end;

 

procedure TForm1.Button1Click(Sender: TObject);
var x : BigInteger;
 myFile : TextFile;
  text   : string;
  t1, t2, elapsedTime : TDateTime;
  cont,i: integer;

    startTime64, endTime64, frequency64: Int64;
  elapsedSeconds: single;
begin

  x := trunc(power(2,6))-1;
  i := 0;
  AssignFile(myFile, 'Test.txt');
  ReWrite(myFile);

  QueryPerformanceFrequency(frequency64);
  QueryPerformanceCounter(startTime64);

  while i < 50063860 do
  begin
//    cont := SparseBitCount(x);
//      writeln(myFile, x.ToString + ' ' + inttostr(cont));
    GerarNext_Colex(x);
    inc(i);
  end;

  QueryPerformanceCounter(endTime64);
  elapsedSeconds := (endTime64 - startTime64) / frequency64;

  CloseFile(myFile);

  showmessage(floattostr( elapsedSeconds  ));

end;

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

Guy Novaes,

 

Obrigado pela dica.

 

Só uma pergunta: 109 segundos é para gerar as 50.000.000 de linhas de 6  E GRAVAR no disco?

 

Ou só o tempo de gerar.... Vi que a gravação está comentada.

Link to comment
Share on other sites

3 minutos atrás, DixieJoe disse:

Guy Novaes,

 

Obrigado pela dica.

 

Só uma pergunta: 109 segundos é para gerar as 50.000.000 de linhas de 6  E GRAVAR no disco?

 

Ou só o tempo de gerar.... Vi que a gravação está comentada.

 

Como você pode notar, o código nem gera e nem grava, apenas passa pelas 50.063.860 de combinações sem fazer mais nada, isso levou 109 segundos aqui na maquina. Levou este tempo, pois o inteiro utilizado é do tipo BigInteger, que possui suporte ilimitado para a quantidade de bits... Ganha-se na quantidade de bits e perde um pouco da velocidade.

 

Acredito que o quesito velocidade para processar uma Lotomania da vida só estará resolvido em computadores quânticos, enquanto isso, não há muito o que ser feito.

 

Para processar a Lotofácil aqui, sem o uso do BigInteger, levou 0,01 segundo aproximadamente.

 

 

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

4 horas atrás, DixieJoe disse:

Guy Novaes,

 

Obrigado.

 

Se eu quiser testar essa unit BigInteger, é só baixá-la e adicionar na minha uses onde vou fazer os testes?

Imagino que sim. Só para me ajudar a ganhar tempo

 

1 - Adicione na uses:

 

uses Velthuis.BigIntegers, Math

 

2 - Baixe e descompacte em uma pasta qualquer o BigInteger;

 

3 - Adicione o path das sources do BigInteger no caminho das Libs nas opções do Delphi....

 

Obs.: A BigInteger só funciona da versão XE em diante do Delphi... Nem perca tempo tentando colocar para rodar no Delphi 7 ou inferior.

 

 

Link to comment
Share on other sites

Em 26/12/2017 at 08:29, DixieJoe disse:

Guy Novaes,

 

Muito obrigado pelas dicas. Foi o que pensei fazer... Mas vi que a unit é muito grande

 

DixieJoe,

 

Outra implementação do seu código, só que dessa vez converti em Java, que já possui o BigInteger nativo. Caso queira testar, execute no Java 1.8+.

 

import java.math.BigInteger;

public class principal {
    
    public static BigInteger gerarNextColex( BigInteger x )  // Gera Todas as Combinações em Ordem Co-Lexicográfica
    // a partir da primeira passada inicialmente na rotina
    // em geral, a primeira é = 0
    // var x contem a primeira combinação
    {
        BigInteger r, z;

        r = x.and( x.not().add(BigInteger.ONE)  );
        x = x .add(r);
        if ( x.equals(BigInteger.ZERO) ) return x;
        z = x.and( ( x.not() ).add( BigInteger.ONE ) );
        z = z.subtract(r);
        while ( ( z.and(BigInteger.ONE) ).equals(BigInteger.ZERO)) {
                z = z.shiftRight(1);
        }
        return x.or( z.shiftRight(1) );
    }
    
    public static void main(String[] args) {
        BigInteger bi1;
        long start = System.currentTimeMillis();
        bi1 = new BigInteger("32767"); // representa a primeira combinação de 15 números
        for (int i = 0; i < 3000000; i++) {
            bi1 = gerarNextColex(bi1);
            //System.out.println(bi1.bitCount());        
        }
        long elapsedTimeMillis = System.currentTimeMillis() - start;
        float elapsedTimeSec = elapsedTimeMillis/1000F;
        System.out.println(elapsedTimeSec);        
    }

}

 

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

 

O código acima passa pelas 3 milhões de combinações da Lotofácil em 1.1 segundos em um processador Core i7 de 3.4GHz, isso em Java.

 

A classe BigInteger do Java trabalha com qualquer quantidade de bits, limitado apenas pela quantidade de memória da maquina virtual java. O bom é que esta classe já vem com o contador de bits navito e todas as outras funções para manipulação de bit.

  • Like 1
Link to comment
Share on other sites

1 hora atrás, DixieJoe disse:

Beleza, Guy Novaes

 

Obrigado.

 

Sou pato em Java.... 

 

Sem problema, vai que outra pessoa esteja precisando de algo assim já pronto, né verdade?

 

Creio que 0,0000000000001% da população mundial poderia dar uso para isso ai.. rs

 

Edited by Guy Novaes
  • Like 2
  • Haha 1
Link to comment
Share on other sites

  • 3 weeks later...
  • 1 year later...

Olá para todos!

 

Estive dando uma olhada nesse tópico e, apesar de não haver mais novas respostas desde 2018, achei interessante acrescentar algumas coisas sobre programação. Vamos lá!

 

Primeiro vou comentar o código de criar combinações por bits do DixieJoe.

Em 01/11/2016 at 07:01, DixieJoe disse:

Wesley,

 

Este é o código que encontrei para gerar combinações de qualquer tamanho: 

 

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

procedure GerarNext_Colex( var x : Integer );  // Gera Todas as Combinações em Ordem Co-Lexicográfica
                                               // a partir da primeira passada inicialmente na rotina
                                               // em geral, a primeira é = 0
                                               // var x contem a primeira combinação
var
  r, z: Integer;

begin

  r := x AND ( ( NOT x ) + 1 );
  x := x + r;
  if ( x = 0 ) then Exit;
  z := x AND ( ( NOT x ) + 1 );
  z := z - r;
  while ( ( z AND 1 ) = 0 ) do z := z SHR 1;
  x := x OR ( z SHR 1 );

end;

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

 

-----

 

 

Curiosidade: esta rotina é super rápida. Chega a gerar mais de 80.000.000 de combinações por segundo.

 

E usa manipulação de Bits dentro dos INTEGERS. Cada bit dentro do Integer representa uma dezena.

Sim, essa rotina é rápida, mas não mais rápida que uma rotina de criação de combinações por contêineres (arrays, seqs) - seja lá como a linguagem chama as matrizes. Outro ponto interessante é que essa sua rotina é cerca de 3 vezes mais lenta que uma rotina em ordem lexicográfica - a sua rotina gera uma ordem lexicográfica inversa, do final para o começo. Já a rotina usando contêineres é pelo menos 4 vezes mais rápida que a rotina em ordem lexicográfica e 11 vezes mais rápida que a sua rotina em ordem lexicográfica inversa (isso quando se usa 64 bits).

 

Comparativo:

C(63, 7): 553.270.671 combinações
Método                        | Tempo em segundos
----------------------------------------------------
lexicográfica 128bits         | 1,027422904968262s
lexicográfica inversa 128bits | 2,788392305374146s
contêineres                   | 0,2468569278717041s


C(100, 6): 1.192.052.400 combinações
Método                        | Tempo em segundos
----------------------------------------------------
lexicográfica 128bits         |  5,755671739578247s
lexicográfica inversa 128bits | 16,56242394447327s
contêineres                   |  0,3178164958953857s

Olhando a tabela é possível verificar que usando 128bits, necessário para gerar combinações como da LotoMania, o tempo dos geradores por bits dispara, pois é preciso utilizar implementação de software para usar inteiros de 128 bits, uma vez que a grande maioria das máquinas de hoje em dia suportam apenas 64 bits diretamente por implementação de hardware.

 

Onde eu quero chegar com isso? Simples! Se o objetivo é gerar e obter desdobramentos para LotoMania - C(100, 50) = 100.891.344.545.564.193.334.812.497.256 combinações -, é melhor nem tentar, pois, tomando como base o gerador por contêineres (o mais rápido), demoraria pelo menos 84.636.669.114.180.042.198 segundos ou 2.683.811.171 milênios! :-o

 

Portanto, hoje em dia, com os computadores domésticos que temos, seria inviável qualquer tipo de geração de combinações muito extensas. Outra opção seria utilizar o processamento das placas gráficas (GPU) em vez do CPU, uma vez que aquelas, em sua grande maioria, já trazem inteiros de 128bits implementados em hardware.

 

Dito tudo isto, agora irei falar um pouco sobre os geradores por bits.

 

Acredito que os geradores por bits sejam a melhor opção para realizar filtros e desdobramentos, pois as operações "bitwise" são bem mais rápidas que loops para verificar contêineres.

 

Por fim, queria saber como está o andamento das coisas (se estiver algo caminhando)?

 

Observação: Acredito que o gerador por sets do DixieJoe não esteja tão otimizado assim, pois, acredito, que teria a mesma velocidade de um gerador por contêineres.

Observação 2: Eu estava ausente do fórum há muito tempo, acredito que desde 2014.

Edited by rockcavera
  • Like 1
  • Thanks 1
Link to comment
Share on other sites

@rockcavera 

 

Obrigado pelos comentários e pelas análises.

 

Fico feliz que você tem um gerador muito mais rápido do que em bits.

Como já havia comentado, mais rápido que gerar com bits, só os programas em Assembly que citei.

 

Agora, confesso que fiquei muito curioso para entender o seu gerador com base em conteineres. 

Não entendo o que seriam esses conteineres. Sei o que é um array, claro, mas não entendi como usa para gerar combinações.

 

Se puder nos passar um exemplo do código que utilizou (com base nos conteineres), agradeceria imensamente. Quero sempre melhorar.

 

Aproveito para perguntar sobre como usar esse conceito de conteineres para fazer a Conferência entre dois conjuntos gerados.

 

Hoje, o maior "gargalo" que tenho nas minhas rotinas é, sem dúvida, a conferência. O que mais demora na execução. Em alguns processos com muitos conjuntos, leva uma eternidade.

 

Mais uma vez, obrigado pelos comentários.

 

Em tempo: utilizo o Delphi (base no Pascal).Se seus exemplos puderem ser parecidos com Pascal ou C ou C++, fica mais rápido para adaptar para o Delphi

 

Link to comment
Share on other sites

@rockcavera 

 

Tenho uma outra pergunta e dúvida:

 

Os tempos de execução que você postou acima para comparar os métodos, inclui a geração e a criação, EM MEMÓRIA, dos conjuntos gerados?

 

Ou inclui o tempo de geração e de gravação em arquivo em disco?

 

Nos meus exemplos, eu crio uma matriz em memória com todos os conjuntos gerados. No final, só gravar em disco.

 

Claro que, para Lototacil, isso é tranquilo. Para Dupla Sena e Megasena também é tranquilo (desde que se tenha uma máquina com RAM suficiente).

 

USando Sets, para a Megasena, já fica complicado  gerar todas as 50.063.360 combinações pela utilização de muita memória.

 

Para Timemania, Lotomania, nem me atrevo.

  • Like 1
Link to comment
Share on other sites

8 horas atrás, DixieJoe disse:

@rockcavera 

 

Obrigado pelos comentários e pelas análises.

 

Fico feliz que você tem um gerador muito mais rápido do que em bits.

Como já havia comentado, mais rápido que gerar com bits, só os programas em Assembly que citei.

 

Agora, confesso que fiquei muito curioso para entender o seu gerador com base em conteineres. 

Não entendo o que seriam esses conteineres. Sei o que é um array, claro, mas não entendi como usa para gerar combinações.

 

Se puder nos passar um exemplo do código que utilizou (com base nos conteineres), agradeceria imensamente. Quero sempre melhorar.

 

Aproveito para perguntar sobre como usar esse conceito de conteineres para fazer a Conferência entre dois conjuntos gerados.

 

Hoje, o maior "gargalo" que tenho nas minhas rotinas é, sem dúvida, a conferência. O que mais demora na execução. Em alguns processos com muitos conjuntos, leva uma eternidade.

 

Mais uma vez, obrigado pelos comentários.

 

Em tempo: utilizo o Delphi (base no Pascal).Se seus exemplos puderem ser parecidos com Pascal ou C ou C++, fica mais rápido para adaptar para o Delphi

 

 

8 horas atrás, DixieJoe disse:

@rockcavera 

 

Tenho uma outra pergunta e dúvida:

 

Os tempos de execução que você postou acima para comparar os métodos, inclui a geração e a criação, EM MEMÓRIA, dos conjuntos gerados?

 

Ou inclui o tempo de geração e de gravação em arquivo em disco?

 

Nos meus exemplos, eu crio uma matriz em memória com todos os conjuntos gerados. No final, só gravar em disco.

 

Claro que, para Lototacil, isso é tranquilo. Para Dupla Sena e Megasena também é tranquilo (desde que se tenha uma máquina com RAM suficiente).

 

USando Sets, para a Megasena, já fica complicado  gerar todas as 50.063.360 combinações pela utilização de muita memória.

 

Para Timemania, Lotomania, nem me atrevo.

Boa noite. Essa sexta foi bem corrida para mim. Só consegui acessar o forum agora. Mas vou tentar explicar pelo celular. Fds raramente acesso computador, aproveito para ficar com a família.

 

Vamos lá. Um gerador por array, list, seqs... , os chamados contêineres, é como se cada array fosse um bit, porém o conceito é diferente, pois você não ativa um bit e desliga outro, você apenas corre as casas do array permutando os números da combinação. Outra diferença é que o array tem o tamanho de K números impressos no volante, já a combinação por bits tem que ter um inteiro de pelo menos a quantidade V de números usados na combinação. Exemplo: C(60, 6) - todas combinações da megasena. Por bits você precisa usar um int64, porque possui 64 bits para acondicionar os 60 números. Já por contêineres, você precisa de 6 casas no array para armazenar os 6 números escolhidos.

 

Esse link http://www.rosettacode.org/wiki/Combinations#Lexicographic_ordered_generation tem um exemplo em C do gerador que uso. O exemplo em Pascal não é legal, porque usa recursão. Se você não conseguir transformar esse gerador em C em um código em Pascal, eu faço isso na segunda.

 

A respeito do Assembly, os compiladores atuais de C trazem otimizações tão boas quanto Assembly. Dos compiladores gratuitos que uso: GCC e Clang do LLVM. Por isso, digo que ganho de velocidade programando direto em Assembly talvez não seja tanto.

 

A parte da conferencia usando contêineres vai depender daquilo que tua linguagem, Pascal, tem para fornecer. Na linguagem que eu uso (Nim) eu apenas preciso fazer um: if x in seq. Onde x é um número e o seq é um contêiner. Em bits seria apenas um and em cada combinação e ver quantos bita continuam ativos.

 

Por fim, o tempo de execução é apenas de gerar as combinações em memória ram, sem escrever pro disco, em todos os geradores que publiquei.

 

Sobre o uso de memória, não sei te falar quantos MBs usa para gerar todas aa combinações da mega, mas uso int8 no contêiner para usar apenas 1 byte por número da combinação, assim o gargalo não é a memória ram. Segunda feira te passo melhor os dados.

 

Abraço. Espero ter respondido quase todas suas dúvidas.

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...