Jump to content

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


Carlos Martins

Recommended Posts

Dado qualquer declaração, variáveis p, q e r, uma tautologia t e uma contradição c, as seguintes equivalências lógicas são válidas 
.

p∧q≡q∧ p p∨q≡q∨ p
(p∧q) ∧r≡ p∧ (q∧r) (p∨q) ∨r≡ p∨ (q∨r)
p∧ (q∨r) ≡ (p∧q) ∨ (p∧r) p∨ (q∧r) ≡ (p∨q) ∧ (p∨r)
p∧t≡ p p∨c≡ p
p∨~p≡ t p∧~p≡ c
~ (~p) ≡ p
p∧ p≡ p p∨ p≡ p
pstrot≡ t p∧c≡ c
~ (P∧q) ≡~p∨~q ~ (P∨q) ≡~p∧~q
p∨ (p∧q) ≡ p p∧ (p∨q) ≡ p
~t≡ c ~ C≡ t

 

Contradições e equivalências são reais - mesmo em lógica. O fato de você acreditar que as redes neurais são maçantes, não significa que outros tenham percepção igual. Os dados da Loteria têm buracos de loop em todo o lugar - é apenas uma questão de descoberta, aprendizagem persistente a partir dele, construir novos algoritmos para problemas e, eventualmente, aplicar uma solução vencedora. E por que não fazê-lo com o uso de algoritmos já poderosos como NN. Aqueles que dão por certo podem ficar atrasados.

As redes neurais funcionam ao nível decimal das matemáticas. Por quê? porque, para encontrar o peso certo de valores que podem representar uma saída precisa, primeiro devemos encontrar  N  linhas tangentes  que apresentam a taxa instantânea de mudança da função em um determinado ponto. A inclinação da  linha tangente  em um ponto da função é igual à derivada da função no mesmo ponto, e ao tentar encontrar o limite ao qual uma taxa de mudança está em execução é necessário "aumentar o zoom" na nível decimal. Para fins de otimização, se os valores forem altos, a rede deve fazer muita pesquisa antes de encontrar uma boa solução, onde a descoberta de derivativos usando pequenos valores é mais fácil para um otimizador fazer seu trabalho (referente a Descida de Gradiente).

Como você sabe, o booleano trabalha como zero e aqueles que também podem ser traduzidos como um valor probabilístico, ou uma operação bastante sábia que representa uma saída verdadeira ou falsa. Sendo o caso do NN, ele funciona melhor quando as entradas são convertidas em booleano, e o resultado também é um booleano.

Cadeia Binária Valor octal
000 0
001 1
010 2
011 3
100 4
101 5
110 6
111 7

Não importa o quão grande o valor "inteiro", os processadores ainda calculam como portas lógicas.

 

Link to comment
Share on other sites

tem esta que estou montando,o codigo foi achado na internet e estou modificando e se alguem queira ajudar a terminar. para fazer redução depois de gerar.não tem dll só o codigo mesmo direto em vb6 ou vba.

Private Sub Command1_Click()

Timer1.Interval = 1000
Timer1.Enabled = True
Command1.Enabled = False
Command2.Enabled = False
n = Text2.Text
Select Case n
    Case 15
        Call Quinze
   ' Case 16
        'Call Dezesseis
    'Case 17
        'Call Dezessete
    Case 18
        Call Dezoito
        Case Else
End Select

Command1.Enabled = True
Command2.Enabled = True
Timer1.Enabled = False


End Sub
Sub Quinze()
Dim a1 As Long, a2 As Long, a3 As Long, a4 As Long, a5 As Long, a6 As Long
Dim a7 As Long, a8 As Long, a9 As Long, a10 As Long, a11 As Long, a12 As Long
Dim a13 As Long, a14 As Long, a15 As Long, a16 As Long, a17 As Long, a18 As Long
Dim i As Long, j As Long, soma As Long
Dim r As Long, x As Long, pares As Long, impares As Long
'Dim arrCombs() As Long
'List1.Clear
ReDim arr(1 To Text2.Text) As Long
ReDim bigArr(1 To Text2.Text, 1 To 100000) As Long
mx = Text1.Text
For a1 = mx - (mx - Text2.Text) + 1 To mx
arr(1) = arr(1) + 1
arr(2) = arr(1)
For a2 = a1 - 1 To mx
arr(2) = arr(2) + 1
arr(3) = arr(2)
For a3 = a2 To mx
arr(3) = arr(3) + 1
arr(4) = arr(3)
For a4 = a3 To mx
arr(4) = arr(4) + 1
arr(5) = arr(4)
For a5 = a4 To mx
arr(5) = arr(5) + 1
arr(6) = arr(5)
For a6 = a5 To mx
arr(6) = arr(6) + 1
arr(7) = arr(6)
For a7 = a6 To mx
arr(7) = arr(7) + 1
arr(8) = arr(7)
For a8 = a7 To mx
arr(8) = arr(8) + 1
arr(9) = arr(8)
For a9 = a8 To mx
arr(9) = arr(9) + 1
arr(10) = arr(9)
For a10 = a9 To mx
arr(10) = arr(10) + 1
arr(11) = arr(10)
For a11 = a10 To mx
arr(11) = arr(11) + 1
arr(12) = arr(11)
For a12 = a11 To mx
arr(12) = arr(12) + 1
arr(13) = arr(12)
For a13 = a12 To mx
arr(13) = arr(13) + 1
arr(14) = arr(13)
For a14 = a13 To mx
arr(14) = arr(14) + 1
arr(15) = arr(14)
For a15 = a14 To mx
arr(15) = arr(15) + 1


'pares = a1 Mod 2 + a2 Mod 2 + a3 Mod 2 + a4 Mod 2 + a5 Mod 2 + a6 Mod 2
'+ a7 Mod 2 + a8 Mod 2 + a9 Mod 2 + a10 Mod 2 + a11 Mod 2 + a12 Mod 2 + a13 Mod 2 _
'+ a14 Mod 2 + a15 Mod 2
'impares = a1 Mod 2 + a2 Mod 2 + a3 Mod 2 + a4 Mod 2 + a5 Mod 2 + a6 Mod 2 _
+ a7 Mod 2 + a8 Mod 2 + a9 Mod 2 + a10 Mod 2 + a11 Mod 2 + a12 Mod 2 + a13 Mod 2 _
+ a14 Mod 2 + a15 Mod 2
'If pares > 6 And impares < 9 Then

'If arr(1) + arr(2) + arr(3) + arr(4) + arr(5) + arr(6) + arr(7) + arr(8) _
'+ arr(9) + arr(10) + arr(11) + arr(12) + arr(13) + arr(14) + arr(15) + arr(16) _
'+ arr(17) + arr(18) = 230 Then
'If arr(1) + arr(2) + arr(3) + arr(4) + arr(5) + arr(6) + arr(7) + arr(8) _
+ arr(9) + arr(10) + arr(11) + arr(12) + arr(13) + arr(14) + arr(15) + arr(16) _
+ arr(17) + arr(18) >= 247 Then
filterComb bigArr, arr, x
'End If
'End If

Next
Next
Next
Next
Next
Next
Next
Next
Next
Next
Next
Next
Next
Next
Next


' the last one
For i = 1 To Text2.Text
arr(i) = mx - Text2.Text + i

Next

filterComb bigArr, arr, x
ReDim Preserve bigArr(1 To Text2.Text, 1 To x)

End Sub
Sub Dezoito()
Dim a1, a2, a3, a4, a5, a6
Dim a7, a8, a9, a10, a11, a12
Dim a13, a14, a15, a16, a17, a18
Dim i As Long, j As Long, soma As Long
Dim r As Long, x As Long, pares As Long, impares As Long
Dim arrCombs() As Long
List1.Clear
ReDim arr(1 To Text2.Text) As Long
ReDim bigArr(1 To Text2.Text, 1 To 100000) As Long
mx = Text1.Text
For a1 = mx - (mx - Text2.Text) + 1 To mx
arr(1) = arr(1) + 1
arr(2) = arr(1)
For a2 = a1 - 1 To mx
arr(2) = arr(2) + 1
arr(3) = arr(2)
For a3 = a2 To mx
arr(3) = arr(3) + 1
arr(4) = arr(3)
For a4 = a3 To mx
arr(4) = arr(4) + 1
arr(5) = arr(4)
For a5 = a4 To mx
arr(5) = arr(5) + 1
arr(6) = arr(5)
For a6 = a5 To mx
arr(6) = arr(6) + 1
arr(7) = arr(6)
For a7 = a6 To mx
arr(7) = arr(7) + 1
arr(8) = arr(7)
For a8 = a7 To mx
arr(8) = arr(8) + 1
arr(9) = arr(8)
For a9 = a8 To mx
arr(9) = arr(9) + 1
arr(10) = arr(9)
For a10 = a9 To mx
arr(10) = arr(10) + 1
arr(11) = arr(10)
For a11 = a10 To mx
arr(11) = arr(11) + 1
arr(12) = arr(11)
For a12 = a11 To mx
arr(12) = arr(12) + 1
arr(13) = arr(12)
For a13 = a12 To mx
arr(13) = arr(13) + 1
arr(14) = arr(13)
For a14 = a13 To mx
arr(14) = arr(14) + 1
arr(15) = arr(14)
For a15 = a14 To mx
arr(15) = arr(15) + 1
arr(16) = arr(15)
For a16 = a15 To mx
arr(16) = arr(16) + 1
arr(17) = arr(16)
For a17 = a16 To mx
arr(17) = arr(17) + 1
arr(18) = arr(17)
For a18 = a17 To mx
arr(18) = arr(18) + 1

pares = a1 Mod 2 + a2 Mod 2 + a3 Mod 2 + a4 Mod 2 + a5 Mod 2 + a6 Mod 2 _
+ a7 Mod 2 + a8 Mod 2 + a9 Mod 2 + a10 Mod 2 + a11 Mod 2 + a12 Mod 2 + a13 Mod 2 _
+ a14 Mod 2 + a15 Mod 2 + a16 Mod 2 + a17 Mod 2 + a18 Mod 2
impares = a1 Mod 2 + a2 Mod 2 + a3 Mod 2 + a4 Mod 2 + a5 Mod 2 + a6 Mod 2 _
+ a7 Mod 2 + a8 Mod 2 + a9 Mod 2 + a10 Mod 2 + a11 Mod 2 + a12 Mod 2 + a13 Mod 2 _
+ a14 Mod 2 + a15 Mod 2 + a16 Mod 2 + a17 Mod 2 + a18 Mod 2
If pares > 8 And impares > 8 Then

'If arr(1) + arr(2) + arr(3) + arr(4) + arr(5) + arr(6) + arr(7) + arr(8) _
'+ arr(9) + arr(10) + arr(11) + arr(12) + arr(13) + arr(14) + arr(15) + arr(16) _
'+ arr(17) + arr(18) = 230 Then
'If arr(1) + arr(2) + arr(3) + arr(4) + arr(5) + arr(6) + arr(7) + arr(8) _
+ arr(9) + arr(10) + arr(11) + arr(12) + arr(13) + arr(14) + arr(15) + arr(16) _
+ arr(17) + arr(18) >= 247 Then
filterComb bigArr, arr, x
'End If
End If
Next
Next
Next
Next
Next
Next
Next
Next
Next
Next
Next
Next
Next
Next
Next
Next
Next
Next

' the last one
For i = 1 To Text2.Text
arr(i) = mx - Text2.Text + i

Next

filterComb bigArr, arr, x

End Sub
Function filterComb(bigArr, arr() As Long, x As Long) As Boolean
Dim b As Boolean
Dim i As Variant, j As Long, k As Variant
Dim f As Variant, soma As Variant

If x < 1 Then
x = x + 1
For i = 1 To Text2.Text
bigArr(i, 1) = arr(i)
Next

Else
For i = 1 To x
f = 0

For j = 1 To Text2.Text
For k = 1 To Text2.Text
If bigArr(j, i) = arr(k) Then
b = True
Exit For
End If
Next

If b Then
f = f + 1
b = False
If f = Text3.Text Then
' already found  dups, no point to look for more
Exit Function
End If
End If

If j - f > Text4.Text - Text3.Text Then
' can't be dups in this array so skip to the next
Exit For
End If

Next
Next

x = x + 1
For i = 1 To Text2.Text
 bigArr(i, x) = arr(i)
Next

End If
DoEvents

Text5.Text = x
List1.AddItem _
Format(arr(1), "00") & " " & Format(arr(2), "00") & " " & Format(arr(3), "00") & " " & _
Format(arr(4), "00") & " " & Format(arr(5), "00") & " " & Format(arr(6), "00") & " " & _
Format(arr(7), "00") & " " & Format(arr(8), "00") & " " & Format(arr(9), "00") & " " & _
Format(arr(10), "00") & " " & Format(arr(11), "00") & " " & arr(12) & " " & arr(13) _
& " " & arr(14) & " " & arr(15) '_
'& " " & arr(16) & " " & arr(17) & " " & arr(18)

Exit Function


End Function

Private Sub Command2_Click()
' Save List Box Items in File
Open "Combinações.txt" For Output As #1
For i = 0 To List1.ListCount - 1
    Print #1, List1.List(i)
Next
Close
End Sub


Private Sub Form_Load()
Label6.Caption = "00:00:00"
End Sub

Private Sub HScroll1_Change()
Text1.Text = HScroll1.Value

End Sub

Private Sub HScroll2_Change()
Text2.Text = HScroll2.Value
End Sub

Private Sub HScroll3_Change()
If HScroll3.Value > HScroll4.Value Then
HScroll4.Value = HScroll.Value:
End If
Text3.Text = HScroll3.Value
End Sub

Private Sub HScroll4_Change()
If HScroll4.Value < HScroll3.Value Then
HScroll3.Value = HScroll4.Value:
End If
Text4.Text = HScroll4.Value
End Sub

Private Sub Timer1_Timer()
Dim Horas As String
Dim Minutos As String
Dim Segundos As String
Horas = Split(Label6.Caption, ":")(0)
Minutos = Split(Label6.Caption, ":")(1)
Segundos = Split(Label6.Caption, ":")(2)
If Int(Segundos) < 59 Then
Segundos = Int(Segundos) + "01"
Else
Minutos = Int(Minutos) + "01"
Segundos = "00"
End If
If Int(Minutos) > 59 Then
Horas = Int(Horas) + "01"
Minutos = "00"
End If
Label6.Caption = Horas & ":" & Minutos & ":" & Segundos
End Sub

Combinador.png

  • Thanks 1
Link to comment
Share on other sites

Pitaco_certo!

 

Como prometido, aqui está um material que explica a necessidade da função Contar Bits setados em 1 num integer.

 

https://www.dropbox.com/s/6t70z0z7mcma8xd/Counting bits set.docx?dl=1

 

Pode ser que seus amigos de Assembler consigam ajudar.

 

Em vermelho, no meio do material, coisas que encontrei que acredito possam ajudar para contar em Assembler (dentro do Delphi) para Int64 (inteiros de 64 bits).

Não consegui testar isso ainda. Nem sei se vou conseguir fazer isso facilmente. Mas vou tentar montar o teste. Depois comento, caso consiga fazer isso.

 

Na verdade, nossa meta seria ter uma função parecida para inteiros com 128 bits (para podermos usar em valores com até 100 dezenas (caso da Lotomania).

 

Vamos com calma... Hora qualquer chegamos lá.

Link to comment
Share on other sites

5 horas atrás, DixieJoe disse:

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;

 

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

 

Olá Dixie,

acho que já falei isso... mas vou insistir, justamente por não entender direito...

 

em vez de ter uma variável de 32 bits, poderia ser uma variável de somente 25 bits, certo? (para lotofácil no caso).

e em vez de tratar somente UMA variável de 25 bits, poderia tratar 5 variáveis de 5 bits?

Explico: se é possível fazer a mesma rotina, com algum prejuízo no desempenho, mas ainda assim funcional com essas 5 variáveis de 5 bits cada, poderá implementar 5 variáveis de 20 bits cada para uso na Lotomania, ou 3 de 20 para a Megasena, ou 2 variáveis de 25 bits para a DuplaSena...

 

Desculpe a ignorância, se falei algo "absurdo"... mas TALVEZ seja uma forma de "tratar" sem se preocupar com o tamanho... claro que exigirá que a cada XX dezenas troque a variável em estudo... e o resultado do filtro (9 impares por exemplo), será obtido da "soma das cinco variáveis de cinco bits"....

 

Será que me entende?

Link to comment
Share on other sites

18 horas atrás, Carlos Martins disse:

 

 

Olha esse post do Youtube, é do canal do amigo Wata, ele ensina como usar a macro de um outro colega para fazer desdobramentos.     www.youtube.com/watch?v=Hm4yg3Bc-aE&t=33s

 

Eu particularmente gosto de fazer a mão, uso um código antigo meu que faz os arranjos, cercar 10 com 10 casando para 10 casas é melhor do que cerca 20 em 10 é só criar as tabelas dos arranjos e depois fazer um JOIN simples tipo "Select * from TB_10c6_A, TB_10c4_B" e os outros casamentos. 7c3, 4c6, 3c7. Com as combinações é só substituir cada letra, por cada valor, de cada casa.

 

wwwbombytes.000webhostapp.com/cerco.php

 

Isso facilita e me dá muito mais confiança. Espero que ajude.

 

Edited by NandoADM
Link to comment
Share on other sites

1 hora atrás, Bruno Cintra disse:

tem esta que estou montando,o codigo foi achado na internet e estou modificando e se alguem queira ajudar a terminar. para fazer redução depois de gerar.não tem dll só o codigo mesmo direto em vb6 ou vba.

 

 

Tentei jogar no VBA, mas confesso que essa parte de formulários não é o meu forte... gosto de tratar diretamente nas celulas... ficando "intelígivel" para todos os usuários. (eu inclusive)

 

Você tem algo pronto?

Ou talvez a conversão disso para MS-SQL ?

 

Link to comment
Share on other sites

Guest Zangado
9 minutos atrás, oiregor disse:

Explico: se é possível fazer a mesma rotina, com algum prejuízo no desempenho, mas ainda assim funcional com essas 5 variáveis de 5 bits cada, poderá implementar 5 variáveis de 20 bits cada para uso na Lotomania, ou 3 de 20 para a Megasena, ou 2 variáveis de 25 bits para a DuplaSena...

sim, dependendo do propósito

complicando apenas nas interseções , tbm tem que haver um pre tratamento dos dados para separar as dezenas em seus conjunto

mesmo em vba dá para fazer,

aqui tem um topico a respeito onde eu estava na tentativa de usar esse artificial e tinha montado varias funções de trabalho antes do hd ir pro brejo, onde se transformava  as combinações em bit e vise versa, comparava e contava

 

Link to comment
Share on other sites

oiregor,

 

Você está 100% correto com sua proposta de quebrar em tipos de 20 bits.

O único ponto é que "deve" (precisaria ser testado) ficar lento e todas as funções necessárias teriam que ser refeitas.

 

Por exemplo, uma função do tipo Intersecção que eu faço com apenas 1 linha, teria que ser refeita para tratar 5 vezes (de vinte em vinte bits) e depois "juntar".

 

Na verdade, nem sei como fazer isso. Só se criasse um array de 5 valores para cada conjunto...

 

Eu já tinha pensado nisso, mas usando apenas 2 valores de 64 bits (no Delphi, tenho o type UInt64 =unsigned 64 bits integer).

Mesma dificuldade. Mas imagino que seria mais fácil implementar. 

 

De novo, não fossem todas as demais funções, isso seria tranquilo fazer.

 

Então, para simplificar: já trabalho com SETS que me permitem trabalhar com até 100 bits. E todas as minhas funções já são funcionais. Funções como:

 

Gerar jogos

Filtrar

Contar

Comparar,  Somar, Retirar Set de outro Set, etc...

Transformar de Inteiro para Set

Tranformar de Set para Inteiro

etc.....

 

Todas as funções são satisfatórias. Com exceção da função  CONTAR. Isso, porque um SET é armazenado de forma própria no Delphi.

 

Estou, no momento, pesquisando se encontro uma maneira de agilizar a contagem dos itens SETADOS no SET usando algo mais rápido do que simplesmente "varrer" de 1 a 100 e verificar se o valor está contido no SET (o que indica que ele está SETADO).

 

Então, ao invés de "varrer" todo o SET, eu precisaria de algo como o exemplo acima que apenas CONTA se o valor está SETADO. Fica ótimo em termos de velocidade.

 

Na contagem do SET, não tenho como fazer isso. Preciso loopar pela quantidade de itens existentes em cada loteria:

 

Lotofacil de 1 a 25

Quina e Timemania de 1 a 80

Megasena de 1 a 60

Lotomania de 1 a 100

SuperSena de 1 a 50, etc......

 

Acho que você conseguiu entender a minha "dificuldade"... Quero apenas agilizar a função de contagem porque ela é fundamental em qualquer processo de conferência, testes, etc...

  • Sad 1
Link to comment
Share on other sites

Guest Zangado

imagina 256bit

dariia  para fazer testes paralelos 

https://translate.google.com.br/translate?hl=pt-BR&sl=ja&u=https://qiita.com/Seizh/items/26eef63af739ba48e36b&prev=search

 

#include <immintrin.h>
#include <iostream>
#include <cstdint>
#include <ctime>     // for clock()

using namespace std;
uint64_t F_popcnt64(uint64_t n)
{
    uint64_t sum = 0;
    for (uint64_t i = 1; i <= n; i++) {
        sum += _mm_popcnt_u64(i);
    }
    return sum;
}

uint64_t F_AVX2(uint64_t n)
{
    __m256i vk = _mm256_set_epi64x(1, 2, 3, 4);
    __m256i vsum = _mm256_setzero_si256();

    const __m256i vzero = _mm256_setzero_si256();
    const __m256i mask55 = _mm256_set1_epi8(0x55);
    const __m256i mask33 = _mm256_set1_epi8(0x33);
    const __m256i mask0F = _mm256_set1_epi8(0x0F);

    const uint64_t step = 4;
    const __m256i vstep = _mm256_set1_epi64x(step);

    uint64_t i;
    for (i = 0; i < (n & ~(step - 1)); i += step) {
        __m256i a = _mm256_and_si256(vk, mask55);
        __m256i b = _mm256_srli_epi32(vk, 1);
        b = _mm256_and_si256(b, mask55);
        a = _mm256_add_epi32(a, b);
        b = _mm256_srli_epi32(a, 2);
        b = _mm256_and_si256(b, mask33);
        a = _mm256_and_si256(a, mask33);
        a = _mm256_add_epi32(a, b);
        b = _mm256_srli_epi32(a, 4);
        a = _mm256_add_epi32(a, b);
        a = _mm256_and_si256(a, mask0F);
        a = _mm256_sad_epu8(a, vzero);
        vsum = _mm256_add_epi64(vsum, a);
        vk = _mm256_add_epi64(vk, vstep);
    }
    __m128i vsum2 = _mm_add_epi64(
        _mm256_castsi256_si128(vsum),
        _mm256_extracti128_si256(vsum, 1)
    );
    vsum2 = _mm_add_epi64(vsum2, _mm_srli_si128(vsum2, 8));
    uint64_t sum = _mm_cvtsi128_si64(vsum2);

    for (; i < n; i++) {
        sum += _mm_popcnt_u64(i + 1);
    }
    return sum;
}

uint64_t F_AVX2_v2(uint64_t n)
{
    __m256i vk = _mm256_set_epi64x(1, 2, 3, 4);
    __m256i vsum = _mm256_setzero_si256();

    const __m256i vzero = _mm256_setzero_si256();
    const __m256i vmask = _mm256_set1_epi8(0xF);
    const __m256i vpop = _mm256_setr_epi8(
        0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4,
        0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4
    );

    const uint64_t step = 4;
    const __m256i vstep = _mm256_set1_epi64x(step);

    uint64_t i;
    for (i = 0; i < (n & ~(step - 1)); i += step) {
        __m256i a = _mm256_and_si256(vk, vmask);
        __m256i b = _mm256_srli_epi32(vk, 4);
        b = _mm256_and_si256(b, vmask);
        a = _mm256_shuffle_epi8(vpop, a);
        b = _mm256_shuffle_epi8(vpop, b);
        a = _mm256_add_epi8(a, b);
        a = _mm256_sad_epu8(a, vzero);
        vsum = _mm256_add_epi64(vsum, a);
        vk = _mm256_add_epi64(vk, vstep);
    }
    __m128i vsum2 = _mm_add_epi64(
        _mm256_castsi256_si128(vsum),
        _mm256_extracti128_si256(vsum, 1)
    );
    vsum2 = _mm_add_epi64(vsum2, _mm_srli_si128(vsum2, 8));
    uint64_t sum = _mm_cvtsi128_si64(vsum2);

    for (; i < n; i++) {
        sum += _mm_popcnt_u64(i + 1);
    }
    return sum;
}


int main(void) {
    clock_t start;

    cout << "[popcnt64]" << endl;
    start = clock();
    cout << "F(10^10) = " <<  F_popcnt64(10000000000) << endl;
    cout << "duration = " << (double)(clock() - start) / CLOCKS_PER_SEC << "sec." << endl;

    cout << "[AVX2 ver.1]" << endl;
    start = clock();
    cout << "F(10^10) = " <<  F_AVX2(10000000000) << endl;
    cout << "duration = " << (double)(clock() - start) / CLOCKS_PER_SEC << "sec." << endl;

    cout << "[AVX2 ver.2]" << endl;
    start = clock();
    cout << "F(10^10) = " << F_AVX2_v2(10000000000) << endl;
    cout << "duration = " << (double)(clock() - start) / CLOCKS_PER_SEC << "sec." << endl;

    return 0;

 

Link to comment
Share on other sites

5 horas atrás, oiregor disse:

 

Tentei jogar no VBA, mas confesso que essa parte de formulários não é o meu forte... gosto de tratar diretamente nas celulas... ficando "intelígivel" para todos os usuários. (eu inclusive)

 

Você tem algo pronto?

Ou talvez a conversão disso para MS-SQL ?

 

eu consigo passar em vba,amanha eu posto pra vc

  • Thanks 1
Link to comment
Share on other sites

11 horas atrás, edcronos2 disse:

imagina 256bit

dariia  para fazer testes paralelos 

https://translate.google.com.br/translate?hl=pt-BR&sl=ja&u=https://qiita.com/Seizh/items/26eef63af739ba48e36b&prev=search

 


#include <immintrin.h>
#include <iostream>
#include <cstdint>
#include <ctime>     // for clock()

using namespace std;
uint64_t F_popcnt64(uint64_t n)
{
    uint64_t sum = 0;
    for (uint64_t i = 1; i <= n; i++) {
        sum += _mm_popcnt_u64(i);
    }
    return sum;
}

uint64_t F_AVX2(uint64_t n)
{
    __m256i vk = _mm256_set_epi64x(1, 2, 3, 4);
    __m256i vsum = _mm256_setzero_si256();

    const __m256i vzero = _mm256_setzero_si256();
    const __m256i mask55 = _mm256_set1_epi8(0x55);
    const __m256i mask33 = _mm256_set1_epi8(0x33);
    const __m256i mask0F = _mm256_set1_epi8(0x0F);

    const uint64_t step = 4;
    const __m256i vstep = _mm256_set1_epi64x(step);

    uint64_t i;
    for (i = 0; i < (n & ~(step - 1)); i += step) {
        __m256i a = _mm256_and_si256(vk, mask55);
        __m256i b = _mm256_srli_epi32(vk, 1);
        b = _mm256_and_si256(b, mask55);
        a = _mm256_add_epi32(a, b);
        b = _mm256_srli_epi32(a, 2);
        b = _mm256_and_si256(b, mask33);
        a = _mm256_and_si256(a, mask33);
        a = _mm256_add_epi32(a, b);
        b = _mm256_srli_epi32(a, 4);
        a = _mm256_add_epi32(a, b);
        a = _mm256_and_si256(a, mask0F);
        a = _mm256_sad_epu8(a, vzero);
        vsum = _mm256_add_epi64(vsum, a);
        vk = _mm256_add_epi64(vk, vstep);
    }
    __m128i vsum2 = _mm_add_epi64(
        _mm256_castsi256_si128(vsum),
        _mm256_extracti128_si256(vsum, 1)
    );
    vsum2 = _mm_add_epi64(vsum2, _mm_srli_si128(vsum2, 8));
    uint64_t sum = _mm_cvtsi128_si64(vsum2);

    for (; i < n; i++) {
        sum += _mm_popcnt_u64(i + 1);
    }
    return sum;
}

uint64_t F_AVX2_v2(uint64_t n)
{
    __m256i vk = _mm256_set_epi64x(1, 2, 3, 4);
    __m256i vsum = _mm256_setzero_si256();

    const __m256i vzero = _mm256_setzero_si256();
    const __m256i vmask = _mm256_set1_epi8(0xF);
    const __m256i vpop = _mm256_setr_epi8(
        0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4,
        0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4
    );

    const uint64_t step = 4;
    const __m256i vstep = _mm256_set1_epi64x(step);

    uint64_t i;
    for (i = 0; i < (n & ~(step - 1)); i += step) {
        __m256i a = _mm256_and_si256(vk, vmask);
        __m256i b = _mm256_srli_epi32(vk, 4);
        b = _mm256_and_si256(b, vmask);
        a = _mm256_shuffle_epi8(vpop, a);
        b = _mm256_shuffle_epi8(vpop, b);
        a = _mm256_add_epi8(a, b);
        a = _mm256_sad_epu8(a, vzero);
        vsum = _mm256_add_epi64(vsum, a);
        vk = _mm256_add_epi64(vk, vstep);
    }
    __m128i vsum2 = _mm_add_epi64(
        _mm256_castsi256_si128(vsum),
        _mm256_extracti128_si256(vsum, 1)
    );
    vsum2 = _mm_add_epi64(vsum2, _mm_srli_si128(vsum2, 8));
    uint64_t sum = _mm_cvtsi128_si64(vsum2);

    for (; i < n; i++) {
        sum += _mm_popcnt_u64(i + 1);
    }
    return sum;
}


int main(void) {
    clock_t start;

    cout << "[popcnt64]" << endl;
    start = clock();
    cout << "F(10^10) = " <<  F_popcnt64(10000000000) << endl;
    cout << "duration = " << (double)(clock() - start) / CLOCKS_PER_SEC << "sec." << endl;

    cout << "[AVX2 ver.1]" << endl;
    start = clock();
    cout << "F(10^10) = " <<  F_AVX2(10000000000) << endl;
    cout << "duration = " << (double)(clock() - start) / CLOCKS_PER_SEC << "sec." << endl;

    cout << "[AVX2 ver.2]" << endl;
    start = clock();
    cout << "F(10^10) = " << F_AVX2_v2(10000000000) << endl;
    cout << "duration = " << (double)(clock() - start) / CLOCKS_PER_SEC << "sec." << endl;

    return 0;

 

Obrigado pela ajuda edcronos2,

 

Confesso que não entendi como usar ainda. Mas valeu.

Link to comment
Share on other sites

Em 23/10/2017 at 00:33, 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 !!!

 

 

Amigo você está tentando fazer algum tipo de engenharia reversa?

Link to comment
Share on other sites

Guest Zangado
3 horas atrás, DixieJoe disse:

Obrigado pela ajuda edcronos2,

 

Confesso que não entendi como usar ainda. Mas valeu.

kkk só entrei de gaiato no assunto

não coloquei nada que preste não,

mesmo não sou programador dessas linguagens

mas assim como dá para subdividir as dezenas  em grupos de 32 bit dá para colocar um conjunto maior em 256bit

isso facilitaria fazer testes de colisão por exemplo ou teste de valor esperado

 

mas bem, a pagina tem outras indicações até matematicamente falando,

k * 2 ** ( k - 1 ) + 1 + n - 2 ** k + f ( n - 2 ** k )

oq eu não consegui modificar para usar em vba

Link to comment
Share on other sites

10 horas atrás, Bruno Cintra disse:

eu passei mais ficou meio lento,vou ver se da pra melhorar e te envio

me manda o que tiver... mesmo que seja lento... largo em servidores focados para isso...

veja que a ideia final é processar "algo" que seja de fácil acesso aos usuários leigos...

só precisará copiar e colar... ou quem sabe até a impressão de volantes em folha A4

veja que estou querendo aprender mais um pouco para agilizar o processamento...

gerar jogos aleatórios tenho vários... porém de forma "menos lenta" só com VBA...

e olha que acho bem rápido com as formulas que uso no excel kkkkkkkkkk

Link to comment
Share on other sites

Option Explicit
Sub test6()
Dim i As Long, j As Long
Dim s As String
Dim arrCombs() As Long

Range("a:a").Clear

Combs4from6 arrCombs, 22

For i = 1 To UBound(arrCombs, 2)
s = arrCombs(1, i)
For j = 2 To 6
s = s & " " & arrCombs(j, i)

Next
Cells(i, 1) = s
Cells(1, 3) = i
Next

End Sub

Function Combs4from6(bigArr, mx As Long) As Long
Dim a1 As Long, a2 As Long, a3 As Long, a4 As Long, a5 As Long, a6 As Long
Dim i As Long, j As Long
Dim r As Long, x As Long

ReDim arr(1 To 6) As Long
ReDim bigArr(1 To 6, 1 To 1000) As Long

For a1 = mx - (mx - 6) + 1 To mx
arr(1) = arr(1) + 1
arr(2) = arr(1)
For a2 = a1 - 1 To mx
arr(2) = arr(2) + 1
arr(3) = arr(2)
For a3 = a2 To mx
arr(3) = arr(3) + 1
arr(4) = arr(3)
For a4 = a3 To mx
arr(4) = arr(4) + 1
arr(5) = arr(4)
For a5 = a4 To mx
arr(5) = arr(5) + 1
arr(6) = arr(5)
For a6 = a5 To mx
arr(6) = arr(6) + 1
r = r + 1
filterComb bigArr, arr, x
Next
Next
Next
Next
Next
Next


For i = 1 To 6
arr(i) = mx - 6 + i
Next
filterComb bigArr, arr, x

ReDim Preserve bigArr(1 To 6, 1 To x)

Combs4from6 = x

End Function
Function filterComb(bigArr, arr() As Long, x As Long) As Boolean
Dim b As Boolean
Dim i As Long, j As Long, k As Long
Dim f As Long

On Error GoTo errH

If x < 1 Then
x = x + 1
For i = 1 To 6
bigArr(i, 1) = arr(i)
Next
filterComb = True
Else

For i = 1 To x
f = 0

For j = 1 To 6
For k = 1 To 6
If bigArr(j, i) = arr(k) Then
b = True
Exit For
End If
Next

If b Then
f = f + 1
b = False
If f = 3 Then ' garantia

Exit Function
End If
End If

If j - f > 6 - 3 Then 'acerto pretentido

Exit For
End If

Next
Next

x = x + 1
For i = 1 To 6
999 bigArr(i, x) = arr(i)
Next
filterComb = True
End If

Exit Function
errH:
If Err.Number = 9 And Erl = 999 Then
'need to resize the array
ReDim Preserve bigArr(1 To 6, 1 To UBound(bigArr, 2) + 1000)
Resume
End If

End Function
 

  • Thanks 1
Link to comment
Share on other sites

mais um em html para fazer fechamento com garantia

 

 

 <html>
 <script language="javascript">
  function wheel(frm)
   { tComb=Math.pow(2,frm.fro.value);
     rAry=new Array();
     for(i=1;i<tComb;i++)
      if(bitCnt(i)==frm.qty.value)
       { flag=false;
         pntr=0;
         while(pntr<=rAry.length && flag==false)
          if(bitCnt(rAry[pntr++]&i)>=frm.gua.value)
           flag=true;
         if(flag==false)
          rAry[rAry.length]=i;
       };
     rslt="";
     for(i=0;i<=rAry.length;i++)
      { delim="";
        cntr=1;
        while(rAry>0)
         { if(rAry&1)
            { rslt+=delim+cntr;
              delim=",";
            };
           cntr++;
           rAry>>=1;
         };
        rslt+="<br>";
      };
     document.getElementById('result').innerHTML=rslt;
   };

  function bitCnt(n)
   { if(n==0)
      { return 0; }
     else
      { re=new RegExp("1","g");
        b=n.toString(2);
        tAry=b.match(re);
        return tAry.length;
      };
   };
 </script>
 <body>
  <form>
   Garante <input type="text" value=4 name="gua" size=3>
   se acertar <input type="text" value=5 name="qty" size=3>
   de<input type="text" value=14 name="fro" size=3> Numeros
   <input type="button" value="Gerar" onclick="wheel(this.form);"><br>
  </form>
  <div id="result" style="border:2px white inset; background:#c0d0e0;"></div>
 </body>
</html>

Link to comment
Share on other sites

Em 23/10/2017 at 02:23, Bruno Cintra disse:

eu tenho,vc programa?

Olá Bruno,

 

sou programador Java e estou estudando a Lotofacil para ver se consigo algo que garanta 50% das minhas apostas com prêmios de 11 acertos em 100% dos casos. Caso tenha algum material e possa me passar ficarei grato.

 

Abraço !!!

Link to comment
Share on other sites

Em 23/10/2017 at 10:07, DixieJoe disse:

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

 

 

 

 

 

Ola DixieJoe,

 

perfeito era disso que eu precisava. Vou estudar o material e ver o que sai de idéias dele. Meu desejo é conseguir um conjunto de jogos que me garanta (100%) que em 50% das minhas apostas em tenho 11 acertos. Assim, estou queimando uns neurônios aqui kkk.

 

Obrigado pela contribuição.

Link to comment
Share on other sites

Em 23/10/2017 at 10:50, Pitaco_certo! disse:

 

 

 

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 
 

Olá Pitaco_certo,

 

obrigado por compartilhar. Esse código gera apenas a combinação né? Ou entendi ele errado ? 

 

Forte abraço !!!

Link to comment
Share on other sites

Em 24/10/2017 at 08:56, phabio junior disse:

Amigo você está tentando fazer algum tipo de engenharia reversa?

Olá Phabio Junior,

 

Não. O meu desejo é fazer uma combinação de jogos que me garanta em 100% um acerto de 50% de minhas apostas com prêmios de 11 acertos. Acredito que meus jogos ficariam entre 1000 a 5000 combinações (intervalo ótimo). Com isso conseguiria registrar os jogos.

 

Forte Abraço !!!

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