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

[Omesmo]

algum programador já usou contagem de bits em C para conferencia em loterias?

quais métodos implementaram?

é bom na velocidade ou nao é coisa de outro mundo?
vale a pena implementar?

 

 

@Jimmy seria bom mudar o nome mudar o nome dessa seção para  "programas & programação para loterias, assim atenderia tbm a implementação de codigos

[Omesmo]

alguem sabe me dizer se isso está certo?

 

Citar

 

qual o valor maximo de um int de 32 bit que tenha 15 bit setado?

 

 

 

Um inteiro de 32 bits com 15 bits definidos como 1 tem 17 bits restantes que podem ser definidos como 0 ou 1.

O valor máximo que um inteiro de 32 bits pode representar é (2^32) - 1, que é 4294967295 em decimal.

Para calcular o valor máximo que um inteiro de 32 bits com 15 bits definidos como 1 pode ter, podemos considerar que os 15 bits definidos como 1 devem estar nas posições mais significativas.

Assim, o valor máximo que um inteiro de 32 bits com 15 bits definidos como 1 pode ter é:

(1 << 15) - 1) << 17 + (1 << 17) - 1

Isso pode ser simplificado para:

4294705151

Portanto, o valor máximo de um inteiro de 32 bits com 15 bits definidos como 1 é 4294705151 em decimal.

 

Citar

de 25 bit e 15 bit setados ?

 

 

Da mesma forma que no caso anterior, um inteiro de 25 bits com 15 bits definidos como 1 tem 10 bits restantes que podem ser definidos como 0 ou 1.

O valor máximo que um inteiro de 25 bits pode representar é (2^25) - 1, que é 33554431 em decimal.

Para calcular o valor máximo que um inteiro de 25 bits com 15 bits definidos como 1 pode ter, podemos considerar que os 15 bits definidos como 1 devem estar nas posições mais significativas.

Assim, o valor máximo que um inteiro de 25 bits com 15 bits definidos como 1 pode ter é:

(1 << 15) - 1) << 10 + (1 << 10) - 1

Isso pode ser simplificado para:

65407

Portanto, o valor máximo de um inteiro de 25 bits com 15 bits definidos como 1 é 65407 em decimal.

 

o ruim do gpt é que quando a gente nao sabe muito sobre o assunto ficamos sem saber se a ia está nos trollando

queria ver se tem como definir um codigo para gerar só os inteiros ou binários que tenham 15 bit setados, para fazer um conferidor de matrizes

 

[DixieJoe]

38 minutos atrás, Omesmo disse:

alguem sabe me dizer se isso está certo?

 

 

 

o ruim do gpt é que quando a gente nao sabe muito sobre o assunto ficamos sem saber se a ia está nos trollando

queria ver se tem como definir um codigo para gerar só os inteiros ou binários que tenham 15 bit setados, para fazer um conferidor de matrizes

 

Tenho algumas rotinas que trabalham com bits (principalmente em Delphi - Turbo Pascal).

E também criei várias funções com SETS (de novo, no Delphi) para tentar agilizar. Mas não chega nem perto do Assembly e quem sabe, nem do C.

 

Não sei programar em C. Mas temos muitos exemplos de rotinas boas em C na Internet trabalhando com bits

 

Se você consegue programar em C, com certeza, vai ser muito mais rápido mesmo.

 

De tudo que já tentei e estudei, temos uma única função que é crucial nos estudos de loterias:

 

Contar (qualquer coisa.... Dezenas, Bits, etc)

 

Quem dominar C ou Assembly (seria mais rápido ainda se feito em Assembly) e conseguir integrar essa função (seja em planilha, DLL ou noutra linguagem) vai ter progamas super rápidos para estudar e montar jogos.

 

Vale muito a pena aprender o básico com bits para criar funções e DLLs, com certeza.

 

 

[Omesmo]

7 minutos atrás, DixieJoe disse:

Quem dominar C ou Assembly (seria mais rápido ainda se feito em Assembly) e conseguir integrar essa função (seja em planilha, DLL ou noutra linguagem) vai ter progamas super rápidos para estudar e montar jogos.

 

Vale muito a pena aprender o básico com bits para criar funções e DLLs, com certeza.

nao sei programar em c, nisso o chat gpt tá fazendo o trabalho, sabendo o basico da programação dá para pegar oq ela faz e montar algo completo
a ia tbm faz em outras linguagens, talvez possa te ajudar a melhorar seus codigos te dando exemplos para instruções focadas em avx, sse , mult processamento

a ia é uma ajuda e tanto

[Omesmo]

17 minutos atrás, DixieJoe disse:

Mas não chega nem perto do Assembly e quem sabe, nem do C.

voce tem um codigo que gera as combinações em assembly né, se puder passar para eu ver se o gpt faz uma analise e poder passar para uma dll em c

[Omesmo]

só  tem que tomar cuidado com o gpt pq as vezes ele gera umas respostas nada a ver,

tipo eu pedi isso:

Citar

voce consegue criar um codigo assembly para ser usado em no C que gere todas as combinações de 15 numeros de 1 a 25?

e ele fez isso

section .data
num_array: db 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25
comb_array: times 15 db 0

section .text
global generate_combinations

generate_combinations:
    mov rdi, comb_array
    mov rsi, 15
    call generate_combinations_recursive
    ret

generate_combinations_recursive:
    push rbp
    mov rbp, rsp
    sub rsp, 32
    
    mov rcx, [rbp + 8] ; número de elementos a serem escolhidos
    cmp rcx, 0
    je .end
    
    mov rdx, [rbp + 16] ; ponteiro para o array de combinações atual
    mov r8, num_array
    mov r9, [rbp + 24] ; tamanho do array de números possíveis
    mov rax, 0 ; índice do número atual
    
.next_num:
    cmp rax, r9
    jge .end_loop
    movzx ecx, byte [r8 + rax] ; número atual
    movzx edx, byte [rdx + rcx * 1] ; valor já escolhido
    cmp edx, 0
    jne .next_num_loop ; número já foi escolhido
    mov byte [rdx + rcx * 1], cl ; adiciona número atual à combinação
    mov rcx, rcx - 1 ; decrementa contador
    call generate_combinations_recursive ; recursão
    mov byte [rdx + rcx * 1], 0 ; remove número atual da combinação
    add rcx, 1 ; incrementa contador
.next_num_loop:
    add rax, 1 ; incrementa índice
    jmp .next_num
.end_loop:
    leave
    ret
    
.end:
    leave
    ret

acho que isso é vbnet kkkkk
mas aí é só pedi para gerar novametne

 

[DixieJoe]

Vou localizar os códigos que tenho em Assembly. Mas ele foi criado para ser usado em DLL dentro do TurboBasic.

 

Comprei os códigos do programador há muitos anos.

Mas não sei usar o Turbo Basic e desisti de implementar porque não consegui adpatar para usar no Delphi que gosto de usar.

 

Só pra você ter uma idéia:

 

Esse programador tem programas que geram e filtram jogos com até 7 dezenas na velocidade de 300.000.000 de jogos por segundo!!!!

 

Assembly (em DLL) dentro do TurboBasic.

 

Cheguei até a comprar o Turbo Basic também há muitos anos. Não consegui me adaptar.

 

Se achar os fontes do Assembly para você ter uma idéia, te mando.

 

Por enquanto, vai se divertindo com alumas coisas que eu fiz que trabalham com Delphi e bits.

Tem também exemplos com Visual Basic 

 

https://www.dropbox.com/s/rvdllpp2h5qhbbd/Arquivos Sobre Uso BITS.rar?dl=1

 

Espero que ajude.

 

 

[DixieJoe]

Eu não estou gostando de usar o ChatGPT. Por enquanto, só tenho retornos que não ajudam muito.

 

Vou esperar ele "evoluir".... kkkk

[Omesmo]

6 minutos atrás, DixieJoe disse:

Eu não estou gostando de usar o ChatGPT. Por enquanto, só tenho retornos que não ajudam muito.

 

Vou esperar ele "evoluir".... kkkk

bem, tem que aprender a falar com ele
por exemplo, eu tive que mudar o pedido para ele gerar algo dentro dos parâmetros

 

Citar

o que eu quero é um codigo em assembly que gere todas as combinações de 15 numeros de 1 a 25 , mas no formato binario em inteiro, mas tem que estar dentro de uma função C

 

 

Entendi. Aqui está um exemplo de código em assembly que gera todas as combinações de 15 números de 1 a 25 no formato binário em inteiro, dentro de uma função

#include <stdio.h>

void generate_combinations(int* combinations) {
    __asm__(
        ".intel_syntax noprefix\n"
        "push rbp\n"
        "mov rbp, rsp\n"
        "sub rsp, 16\n"
        "mov QWORD PTR [rbp-8], rdi\n"
        "mov eax, 0\n"
        "mov ecx, 0\n"
        "mov edx, 15\n"
        "mov esi, 1\n"
        "mov edi, 1\n"
        "jmp .outer_loop\n"

    ".inner_loop:\n"
        "test esi, esi\n"
        "jle .outer_loop\n"
        "shl eax, 1\n"
        "mov ebx, DWORD PTR [rbp-4]\n"
        "add ebx, edi\n"
        "mov ebx, DWORD PTR [rbx]\n"
        "cmp ebx, 25\n"
        "jg .next\n"
        "inc eax\n"
        "mov ebx, DWORD PTR [rbp-4]\n"
        "add ebx, edi\n"
        "mov ecx, DWORD PTR [rbp-8]\n"
        "mov edx, eax\n"
        "add ecx, edx\n"
        "mov DWORD PTR [ecx*4], ebx\n"
        "inc edi\n"
        "dec esi\n"
        "jmp .inner_loop\n"

    ".next:\n"
        "inc edi\n"
        "mov ebx, DWORD PTR [rbp-4]\n"
        "add ebx, edi\n"
        "cmp ebx, DWORD PTR [rbp+8]\n"
        "jg .done\n"
        "jmp .outer_loop\n"

    ".outer_loop:\n"
        "cmp edx, 0\n"
        "jle .done\n"
        "mov esi, edx\n"
        "mov eax, 0\n"
        "mov edi, 1\n"
        "jmp .inner_loop\n"

    ".done:\n"
        "add rsp, 16\n"
        "pop rbp\n"
        ".att_syntax prefix\n"
    );
}

int main() {
    int combinations[15];
    generate_combinations(combinations);
    for (int i = 0; i < 15; i++) {
        printf("%d ", combinations[i]);
    }
    printf("\n");
    return 0;
}

 

O código acima implementa a função generate_combinations em assembly, que recebe um ponteiro para um array de 15 inteiros e preenche esse array com todas as combinações de 15 números de 1 a 25 no formato binário em inteiro. O código em C chama essa função e imprime o resultado na tela.

O código em assembly usa dois loops aninhados para gerar as combinações. O loop externo controla o número de elementos na combinação, que começa em 15 e vai decrescendo até 1. O loop interno adiciona cada elemento à combinação e avança para o próximo elemento. O loop interno usa a instrução shl para deslocar o valor atual da combinação uma posição para a esquerda e a instrução mov para carregar o próximo elemento do array de números. Se o próximo elemento for maior que 25, o loop inter

 

[DixieJoe]

Veja se te ajuda em alguma coisa.

 

Eu não posso ajudar com isso.

 

 

https://www.dropbox.com/s/y7i3wfa9soe3tck/Special Assembly Routines.rar?dl=1

 

[Omesmo]

no caso so assembly o certo é fazer uma função em DLL para outros programas usarem no caso se pode implementar em planilhas e até no Delphi
dll são bibliotecas dinâmicas externas, vc pode programar elas em qualquer linguagem compilada e usar em outros programas , mesmo numa planilha

[DixieJoe]

Pra mim, não quero falar com o ChatGPT, kkkk.

 

Achei esse código ai em cima, super complicado.

Acho que temos coisa mais enxuta.

 

Quer?

 

 

[DixieJoe]

Não sei como fazer nem trabalhar com DLL.

 

Na verdade, só preciso mesmo de uma unica função em Assembly para contar bits, passados dois valores.

 

E que pudesse aceitar valores até 100 (pensando na Lotomania).

 

Para até 32 bits, sei fazer isso, sem DLL, no próprio Delphi.

 

Bem rápido.

 

Mas com ASsembly vai voar.

 

Veja os exemplos que mandei 

[Omesmo]

4 minutos atrás, DixieJoe disse:

Pra mim, não quero falar com o ChatGPT, kkkk.

 

Achei esse código ai em cima, super complicado.

Acho que temos coisa mais enxuta.

mas aí que está, o gpt está mais para ajudar a entender como funciona
dll s são super praticas de usar
é a mesma coisa que uma função interna, só que ela está fora do programa principal , vc declara ela e a usa internamente

 

mas a graça do gpt é que vc pode pegar exemplos de codigos
 

8 minutos atrás, DixieJoe disse:

Na verdade, só preciso mesmo de uma unica função em Assembly para contar bits, passados dois valores.

E que pudesse aceitar valores até 100 (pensando na Lotomania).

o fato é que existe varias maneira de fazer isso, e tbm dependo do seu processador o uso de certas instruções

usando o gpt e o Delphi se pode pegar exemplos
para lm vc pode dividir as seções em 32 bit e somar as contagens

 

Spoiler

preciso mesmo de uma unica função em Assembly para contar bits, passados dois valores. dentro de um codigo Delphi

Citar

Sim, é possível escrever uma função em assembly para contar o número de bits diferentes entre dois valores (também conhecido como distância de Hamming) em Delphi. Aqui está um exemplo de como fazer isso:

program CountBits;

{$APPTYPE CONSOLE}

uses
  SysUtils;

function CountBits(a, b: Integer): Integer;
asm
  push ebp
  mov ebp, esp
  sub esp, 4
  xor eax, eax
  xor edx, edx
  mov ecx, 32

@loop:
  cmp ecx, 0
  je @done
  mov ebx, a
  shr ebx, cl - 1
  and ebx, 1
  mov esi, b
  shr esi, cl - 1
  and esi, 1
  cmp ebx, esi
  jne @count
  jmp @next

@count:
  inc eax

@next:
  dec ecx
  jmp @loop

@done:
  mov eax, [ebp - 4]
  add esp, 4
  pop ebp
end;

var
  a, b: Integer;
  bits: Integer;
begin
  a := 12345;
  b := 67890;
  bits := CountBits(a, b);
  WriteLn('The number of different bits between ', a, ' and ', b, ' is ', bits);
  ReadLn;
end.

O código em Delphi define a função CountBits, que recebe dois parâmetros de entrada a e b, que são números inteiros, e retorna o número de bits diferentes entre esses dois números. A função é implementada em assembly e usa uma série de instruções lógicas para comparar os bits de cada número.

A função usa um loop para comparar cada bit dos dois números. O loop começa com o valor 32 em ecx, que é o número de bits em um número inteiro de 32 bits. A cada iteração do loop, a função usa as instruções shr e and para obter o valor do bit atual de a e b, compara esses valores usando a instrução cmp e incrementa o contador de bits diferentes em eax, se os valores são diferentes. A função continua a percorrer os bits, decrementando ecx em cada iteração, até que todos os bits tenham sido comparados.

Depois de contar o número de bits diferentes, a função coloca o valor em eax e retorna. O código em Delphi chama a função CountBits com dois valores de exemplo e imprime o resultado na tela.

 

 

 

mas existe avx2, sse, que fornece instruções própria dentro do processador que são mais rapidas , mas dependem se o processador tem as instruções

o metodo de tabela , contagem bit a bit

 

 

[DixieJoe]

Essa função em Delphi conta bits dentro de um integer com 32 bits.

 

Se eu tiver um valor ("integer") maior, posso usar 64 bits, ok...

 

Mas... Se eu quiser contar um valor com 100 bits (para lotomania, por exemplo), fico no ar...

Não sei como Separar o valor em 4 pedaços de 32 bits e contar separadamente, depois somando os resultados.

 

Ou separar em 2 pedaços de 64 bits e fazer a mesma coisa.

 

Parece que no C++ dá para fazer isso.

 

Mas não programa em C++

 

[Guest]

5 hours ago, Omesmo said:

algum programador já usou contagem de bits em C para conferencia em loterias?

quais métodos implementaram?

é bom na velocidade ou nao é coisa de outro mundo?
vale a pena implementar?

 

 

@Jimmy seria bom mudar o nome mudar o nome dessa seção para  "programas & programação para loterias, assim atenderia tbm a implementação de codigos

 @Omesmo

 

desculpe a minha ignorância...

 

mas o que é um bitcount ?

 

por favor, se tiver ume xemplo mesmo em basic, serve....

 

eu uso algo assim, em perl:

 

for ( $cell = 0 ; $cell <= 24; $cell++ ) {
        
        if ( $resultados[$cell] == $palpites[$cell] ) { $counter++ }
        
    }
    
    if ( $counter == 11) { 

 

    #algum comando aqui !

     $counter = 0;

 

}

[Omesmo]

6 minutos atrás, DixieJoe disse:

Ou separar em 2 pedaços de 64 bits e fazer a mesma coisa.

vc pode separar em 4 pedaços de 32 bit,
para falar a verdade acho que o avx e o sse fazem justamente isso, o avx trabalha com matrizes de 256bit e acho que tem até 512bit, mas isso dentro de uma matriz

3 minutos atrás, Eolocos disse:

mas o que é um bitcount ?

bit count é justamente isso, contagem de bit
imagina a lf como 15 bit =1 dentro de 25 bit

1,2,3,4,5,6,7,8,9,10,11,12,13,14,15
sseri igual a 1111111111111110000000000

então seria contar os 1

sde pode comparar um binario com outro com and por exempro e vai resultar em um binario que só tem os 1 que caem na mesma possiçao do outro

[DixieJoe]

Eolocos,

 

É apenas a contagem dos bits com valor 1 dentro de um integer.

 

Se você saber quantos valores iguais (bits iguais com 1) dentro de 2 integers passados para a função, ela primeiro, cria um terceiro integer fazendo um AND nos 2 integers recebidos e depois conta quantos bits com valor 1 tem no terceiro integer.

 

 

[Guest]

2 minutes ago, Omesmo said:

vc pode separar em 4 pedaços de 32 bit,
para falar a verdade acho que o avx e o sse fazem justamente isso, o avx trabalha com matrizes de 256bit e acho que tem até 512bit, mas isso dentro de uma matriz

bit count é justamente isso, contagem de bit
imagina a lf como 15 bit =1 dentro de 25 bit

1,2,3,4,5,6,7,8,9,10,11,12,13,14,15
sseri igual a 1111111111111110000000000

então seria contar os 1

sde pode comparar um binario com outro com and por exempro e vai resultar em um binario que só tem os 1 que caem na mesma possiçao do outro

 

ah tá, entonces, sim, eu uso o tal do bitcount

 

bom, não sei em C, mas em Perl, que é uma linguagem interpretada,

 

num PC, i7 com 16 GB DDR3, o código acima que uso, compara 278 mil linhas por segundo, rodando dentro do Cygwin ( um "linux" dentro do windows )

 

no momento, o código gera 1 bilhão de matrizes por hora, e compara cada uma com uma "string" ( padrão específico, em posição específica ), e se encontra, escreve em um arquivo txt.

[DixieJoe]

Sim, Eolocos, é algo parecido que você faz em Perl (que não conheço).

 

Para mim, com o Delphi, são 2 gargalos:

 

1- Conferir cada linha da matriz com uma string de resultados (Faço isso bem mais rápido do que o Perl faz)

2- Gravar as linhas de interesse (quando o arquivo é grande, é o Windows que demora... Pode até ser o próprio Delphi.)

 

Mas vou convivendo.

 

Para gerar e conferir (filtrar com 3 filtros pré-setados) todos os 3,2 milhões de jogos da Lotofacil, gasto menos de 5,58 segundos. Gerando 130158 jogos de 15 dezenas.

 

Isso, no Delphi usando minhas funções "caseiras" de contagem e filtragem com SETS (tipo conjuntos) que criei para chegar mais perto da idéia dos bits.

Com SETS, consigo trabalhar com as 100 dezenas da Lotomania.

 

Mas, esse tempo poderia, talvez ser cortado por 10 se eu soubesse trabalhar com BITCOUNT em Assembly, com certeza.

 

 

[DixieJoe]

Mas, no momento, isso não é uma prioridade minha. Toma muito tempo e vai exigir mudanças grandes nas minhas rotinas.

 

Depois que ganhar e tiver tempo sobrando, quem sabe, kkkk

 

[Guest]

1 minute ago, DixieJoe said:

Sim, Eolocos, é algo parecido que você faz em Perl (que não conheço).

 

Para mim, com o Delphi, são 2 gargalos:

 

1- Conferir cada linha da matriz com uma string de resultados (Faço isso bem mais rápido do que o Perl faz)

2- Gravar as linhas de interesse (quando o arquivo é grande, é o Windows que demora... Pode até ser o próprio Delphi.)

 

Mas vou convivendo.

 

Para gerar e conferir (filtrar com 3 filtros pré-setados) todos os 3,2 milhões de jogos da Lotofacil, gasto menos de 5,58 segundos. Gerando 130158 jogos de 15 dezenas.

 

Isso, no Delphi usando minhas funções "caseiras" de contagem e filtragem com SETS (tipo conjuntos) que criei para chegar mais perto da idéia dos bits.

Com SETS, consigo trabalhar com as 100 dezenas da Lotomania.

 

Mas, esse tempo poderia, talvez ser cortado por 10 se eu soubesse trabalhar com BITCOUNT em Assembly, com certeza.

 

 

 

sim, Perl é interpretado, portanto bem lento, quando comparado com uma linguagem compilada.

 

e com certeza, rotinas em Assembly são extremamente velozes, visto que eu só uso Assembly ao programar micro - controladores ( para uso médico ) ao invés de C !

[Omesmo]

2 minutos atrás, DixieJoe disse:

Mas, no momento, isso não é uma prioridade minha. Toma muito tempo e vai exigir mudanças grandes nas minhas rotinas.

 

Depois que ganhar e tiver tempo sobrando, quem sabe, kkkk

para mim tbm nao, só estou tentando aprender algo, e como vc sabe mesmo quando eu monto minhas coisas eu nao mexo com matrizes

mas ve isso

Citar

tem como usar avx sse em Delphi?

 

 

Sim, é possível usar instruções SIMD (Single Instruction, Multiple Data) como AVX e SSE em um programa Delphi usando as bibliotecas externas apropriadas. Existem várias bibliotecas disponíveis que oferecem suporte a instruções SIMD em Delphi, incluindo:

• Delphi SIMD Library: https://github.com/JackTrapper/Delphi-SIMD-Library
• Agner Fog's Vector Class Library for Delphi: https://www.agner.org/optimize/vectorclass/

Essas bibliotecas incluem rotinas otimizadas para operações comuns em vetores, como somas e produtos de ponto, usando instruções SIMD.

Para usar essas bibliotecas, você precisa incluir os arquivos de cabeçalho e as bibliotecas dinâmicas fornecidas em seu projeto Delphi e usar as funções fornecidas em suas rotinas.

Além disso, é importante notar que a capacidade de usar instruções SIMD depende do processador em que o código é executado. Nem todos os processadores suportam todas as instruções SIMD, e a detecção de recursos deve ser usada para garantir que as instruções adequadas estejam sendo usadas em cada plataforma.

 

[DixieJoe]

Agora, Eolocos disse:

 

sim, Perl é interpretado, portanto bem lento, quando comparado com uma linguagem compilada.

 

e com certeza, rotinas em Assembly são extremamente velozes, visto que eu só uso Assembly ao programar micro - controladores ( para uso médico ) ao invés de C !

Então você programa em Assembly?

Legal.

Veja os exemplos que mandei pro omesmo que tem rotinas em Assembly que eu comprei de um programador da Servia há muitos anos atrás. Tem os fontes e alguns exemplos.

 

As rotinas dele voam... Chegam a 300.000.000 de conjuntos gerados e filtrados por segundo.

 

 

[DixieJoe]

Isso ai, omesmo

 

Tem muita coisa. Só que vai tomar tempo para entender, programar, testar e depois agregar nas rotinas e sistemas que já criei.

 

Então, só uma função de ContarAcertos entre dois valores (Em ASSEMBLY) que eu possa usar dentro do próprio Delphi, já deve fazer muita diferença, para melhor.

 

No resto, estou satisfeito com a velocidade que tenho conseguido

 

 

-----

 

Para quem quer ganhar, o mais importante é ter idéias de como  reduzir, com segurança, as quantidades dos jogos finais.

Nisso que estou investindo meu tempo, sempre! kkkk