Leaderboard

@Rezende O método que estou utilizando considero muito promissor. Então os bons resultados estão aparecendo, mas ainda preciso manter uma boa pontuação com maior frequência.

Vamos.concorrer pelo segundo lugar....kkkk Pq o @Pataca ta cruel neste ano... Parabéns.

@Giancarlo B. Tessaro Obrigado pela ilustração. Agora temos que "batizar" o Tópico com os 15 Pontos. Este ano algum participante vai acertar os 15 pontos.

@Pataca

01 02 03 04 06 07 08 10 11 13 14 15 17 18 19 20 22 23 24 01 02 03 05 06 07 08 10 11 13 14 15 16 17 18 20 22 24 25 02 03 04 05 06 08 10 11 13 14 15 16 18 19 20 22 23 24 25 so para o 2745

Torcendo por voce. Vai conseguir.

Não procede. A lista dos sorteios simétricos está aqui.

PTV-RJ - 16:20 1°1246 12....Par 12 + Par 24 + Grupo12 2°2989 23....Par 29 3°2217 05....Par 22 + ....Par 21 4°7479 20 5°8591 23 6°2522 06....Par 25 + Dezena 22 7° 724 06....Dezena 24

2745 01 02 03 05 06 09 11 12 14 17 18 21 23 24 25 01 02 03 05 06 09 10 12 14 17 19 21 23 24 25 01 02 03 05 06 09 10 12 14 17 20 21 23 24 25 01 03 04 05 06 08 09 11 14 15 17 18 20 21 24 01 03 04 05 06 08 09 11 14 15 17 20 21 22 24

PT-RJ - 14:20 1°7105 02....Grupo 2 2°4002 01....Dezena 02 3°8755 14 4°8614 04 5°2797 25....Par 27 6°1273 19....Par 12 + Par 27 7° 434 09

@genesioggs23 linha 3,4,5 a dezena 02 está repetida.

E vice-versa.

Ao lado da analise da LBR foi anotado alguns Pares que se fossem fixados, ganha-se na MI - Milhar Invertida (2 fixos e 8 algarimos flutuantes) PTM 4287 22 6270 18....Aqui 76 como fixa, ganha na MI 0579 20....Aqui 59 como fixa, ganha na MI 0382 21 9354 14....Aqui 59 como fixa, ganha na MI 0872 18 879 20

estava vendo os codigos gerados pelo gpt e reparei nisso if (__builtin_popcount(i) == k) { // verifica se i tem exatamente k bits definidos __builtin_popcount(i) pesquisando vi que apesar de nao ser padrão do C tem compilador que incorpora funções desse tipo como o GCC para int use __builtin_popcount(n) para int longo use __builtin_popcountl(n) para long long int use __builtin_popcountll(n) o problema é que parece que precisaria fazer um para cada tipo, se fosse escolhido o tipo em tempo de execução ficaria mais lento pedi para o gpt montar um contador de bits para 100bits usando assembly numa função c #include <stdint.h> uint64_t popcnt_100bits(const void *ptr) { uint64_t count; __asm__ volatile ( "movdqu xmm0, [%[ptr]] \n" "movdqu xmm1, [%[ptr]+16] \n" "movdqu xmm2, [%[ptr]+32] \n" "movdqu xmm3, [%[ptr]+48] \n" "movdqu xmm4, [%[ptr]+64] \n" "pshufb xmm5, xmm0 \n" "pshufb xmm6, xmm1 \n" "pshufb xmm7, xmm2 \n" "pshufb xmm8, xmm3 \n" "pshufb xmm9, xmm4 \n" "popcnt %[count], xmm5 \n" "popcnt %%rdx, xmm6 \n" "add %[count], %%rdx \n" "popcnt %%rcx, xmm7 \n" "add %[count], %%rcx \n" "popcnt %%rbx, xmm8 \n" "add %[count], %%rbx \n" "popcnt %%rsi, xmm9 \n" "add %[count], %%rsi \n" : [count] "=r" (count) : [ptr] "r" (ptr) : "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7", "xmm8", "xmm9", "memory" ); return count; } eu adoraria fazer funções em dll para usar em planilhas apesar da maioria das coisas que eu faço funcionar muito bem em vba tem uns testes meus que demora muito pelo grande numero de testes que faz

Analise LBR 10 hs Para PTs LBR - 10:00 1°7766 17..........77 76 66 2°3549 13..........59 3°8063 16..........86 4°7569 18..........76 59 5°8168 17..........86 --------------- 6°5115 04 7° 561 16 Pela analise do 1 ao 5, temos a ausencia do algarismo 2 Grupos 2 - 12 - 22 Dezenas ou Pares de 20 a 29 (g5, g6, g7, g8) Dezenas ou Pares que terminam com unidade 2 02 12 22 32 42 52 62 72 82 92

21.03.2023 Analise LBR 8 hs LBR - 08:30 1°8743 11....83 2°2213 04 3°4032 08....03 4°7928 07....79 5°2436 09....43 -------------- 6°5352 13 7° 348 12 Está faltando o algarismo 5 do 1 ao 5, como foi o reflexo na LBR 10hs LBR - 10:00 1°7766 17 2°3549 13....Par 35 + Par 54 3°8063 16 4°7569 18....Par 75 + Par 56 5°8168 17 --------------- 6°5115 04....Par 51 + Dezena 15 7° 561 16....Par 56 Nota: Ausência de algum algarismo funciona como bússola

Para 21.02.2023 Para premios do 1 ao 7 Dezena do dia 50 a 59 (Grupos 13 - 14 - 15) Atenção dezena 90 a 99 Só Primeiro Premio Ciclo A de dezenas 00 a 09 Ciclo B de dezenas 50 a 59 Ciclo dos Grupos 6x16 9x19

@dois Deixar o valor de A8 igual ao número do Concurso; funciona normalmente. Alguma sugestão?

Parabéns ao Pataca!!!

@dois Abas: Conferidor , LP , MatrizParaFiltrar , Palpites , Laranjas , Binário , LF_ReSorteio.

um codigo em assembler do programa oscover que gerar v,k,t,m=b .386 .model flat, stdcall option casemap :none ; case sensitive ; ######################################################################### include \masm32\include\windows.inc include \masm32\include\user32.inc include \masm32\include\kernel32.inc includelib \masm32\lib\user32.lib includelib \masm32\lib\kernel32.lib combinations PROTO :DWORD,:DWORD ; ######################################################################### szText MACRO Name, Text:VARARG LOCAL lbl jmp lbl Name db Text,0 lbl: ENDM m2m MACRO M1, M2 push M2 pop M1 ENDM return MACRO arg mov eax, arg ret ENDM .code ; ########################################################################## LibMain proc hInstDLL:DWORD, reason:DWORD, unused:DWORD szText LmTitle,"Cover Functions" .if reason == DLL_PROCESS_ATTACH szText ATTACHPROCESS,"PROCESS_ATTACH" return TRUE ; ----------------------------- ; If error at startup, return 0 ; System will abort loading DLL ; ----------------------------- .elseif reason == DLL_PROCESS_DETACH szText DETACHPROCESS,"PROCESS_DETACH" .elseif reason == DLL_THREAD_ATTACH szText ATTACHTHREAD,"THREAD_ATTACH" .elseif reason == DLL_THREAD_DETACH szText DETACHTHREAD,"THREAD_DETACH" .endif ret LibMain Endp ; ########################################################################## ; *** Count the number of bits in DWORD bitCount proc STDCALL number:DWORD sub eax,eax mov ecx,number cmp eax,ecx je noBits bitLp: inc eax mov ebx,ecx dec ebx and ecx,ebx jne bitLp noBits: ret bitCount endp ; *** Count combinations of subsets in full set n!/k!(n-k)! combinations proc STDCALL subSet:DWORD,fullSet:DWORD sub edx,edx push edx mov eax,subSet bts edx,eax dec edx nextLp: sub ecx,ecx mov ebx,edx bitLp: inc ecx mov eax,ebx dec eax and ebx,eax jnz bitLp cmp ecx,subSet jne badCount inc DWORD PTR [esp] mov eax,edx dec eax or edx,eax badCount: inc edx mov eax,fullSet bt edx,eax jnc nextLp pop eax ret combinations endp ; *** Count how many cover sets are contained within a list of source sets ; *** ignore sets with MSb on checkCover proc STDCALL cover:DWORD,subSet:DWORD,fullSet:DWORD,setList:DWORD push edi push esi sub edx,edx push edx mov eax,subSet bts edx,eax dec edx mov esi,setList lea edi,subSet nextTestSet: sub ebx,ebx add ebx,edx jz badCount sub ecx,ecx bitLp: inc cx mov eax,ebx dec eax and ebx,eax jnz bitLp cmp cx,[edi] jge isGoodCnt badCount: bt ecx,16 jc isBadCover nextComb: inc edx mov ebx,fullSet bt edx,ebx jnc nextTestSet jmp finished isGoodCnt: bts ecx,16 jc isCoverTest jne nextComb isBadCover: lea edi,cover testSetLp: add ebx,[esi] jz endTestSet add esi,4 bt ebx,31 jnc notFlagged sub ebx,ebx notFlagged: and ebx,edx jz testSetLp sub cx,cx jmp bitLp isCoverTest: inc DWORD PTR [esp] mov eax,edx dec eax or edx,eax endTestSet: mov esi,setList sub ecx,ecx lea edi,subSet jmp nextComb finished: pop eax pop esi pop edi ret checkCover endp ; *** calculate how many unique combinations are covered by each set in list rankSets proc STDCALL cover:DWORD,subSet:DWORD,fullSet:DWORD,setList:DWORD LOCAL setAddr:DWORD push edi push esi mov esi,setList sub eax,eax notZero: add eax,4 cmp DWORD PTR [esi+eax],0 jne notZero invoke GlobalAlloc,GMEM_FIXED or GMEM_ZEROINIT, eax push eax mov eax,subSet sub edx,edx bts edx,eax dec edx nextCheck: lea edi,subSet mov ebx,edx sub ecx,ecx mov setAddr,ecx bitLp: inc cx mov eax,ebx dec eax and ebx,eax jnz bitLp cmp cx,[edi] bts ecx,16 jge goodCount jc nextSet jmp nextComb goodCount: jnc isCover cmp ebx,setAddr jne notUnique mov setAddr,esi jmp nextSet isCover: jne nextComb lea edi,cover mov esi,setList nextSet: add ebx,[esi] je endList add esi,4 and ebx,edx je nextSet sub cx,cx jmp bitLp endList: add ebx,setAddr je notUnique sub ebx,setList add ebx,[esp] mov esi,ebx inc DWORD PTR [esi-4] notUnique: mov eax,edx dec eax or edx,eax nextComb: inc edx mov eax,fullSet bt edx,eax jnc nextCheck pop eax pop esi pop edi ret rankSets endp ; *** search for the best set to add to a set list bestSet proc STDCALL cover:DWORD,subSet:DWORD,fullSet:DWORD,setList:DWORD LOCAL condition:DWORD LOCAL workList:DWORD LOCAL coverCntr:DWORD LOCAL bestCover:DWORD LOCAL newBestSet:DWORD push edi push esi mov condition,6 sub eax,eax mov bestCover,eax invoke combinations,subSet,fullSet shl eax,4 invoke GlobalAlloc,GMEM_FIXED or GMEM_ZEROINIT, eax push eax mov eax,setList mov workList,eax mov eax,cover stageLp: push DWORD PTR [esp] sub edx,edx bts edx,eax dec edx nextCheck: mov ebx,edx lea edi,condition and ecx,20000H jnz bitLp lea edi,subSet bitLp: inc cx mov eax,ebx dec eax and ebx,eax jnz bitLp cmp cx,[edi] bts ecx,16 jge goodCount jc noBits jmp nextComb goodCount: jnc isComb bt ecx,17 jnc isCover ; *** stage two - count a cover for this draw set inc DWORD PTR coverCntr jmp noBits isComb: jne nextComb mov esi,workList noBits: add ebx,[esi] je endSetList add esi,4 sub cx,cx and ebx,edx lea edi,cover jne bitLp jmp noBits endSetList: bt ecx,17 jnc incListAddr mov eax,coverCntr mov coverCntr,ebx cmp eax,bestCover jle isCover mov bestCover,eax mov newBestSet,edx jmp isCover incListAddr: mov esi,[esp] mov [esi],edx add DWORD PTR [esp],4 isCover: mov eax,edx dec eax or edx,eax nextComb: inc edx mov eax,fullSet bt edx,eax jnc nextCheck ; *** move to stage two - find best set of six numbers to cover all uncovered combinations pop eax mov eax,[esp] mov workList,eax sub ebx,ebx mov coverCntr,ebx mov eax,condition bts ecx,17 jnc stageLp pop eax invoke GlobalFree,eax mov eax,newBestSet pop esi pop edi ret bestSet endp ; ########################################################################## End LibMain

O motivo não era o que pensávamos, é erro mesmo em algumas Fórmulas Por favor diga quais abas você está usando que #Nóis postamos aqui o motivo do erro e como corrigir, OK ? Basicamente o erro é estar usando a célula A8 como número do Concurso Quem estiver usando outras abas e notou algum erro, por favor informe aqui

2745 06 08 10 17 22 23 24 01 05 12 13 14 19 20 21 06 08 10 17 22 23 24 01 05 12 13 15 19 20 21 06 08 10 17 22 23 24 01 14 15 16 18 19 20 21 06 08 10 17 22 23 24 05 12 13 14 15 19 20 21 06 08 10 17 22 23 24 05 12 13 16 18 19 20 21

2745 FIXO FORA FIXAS 14 16 04 05 06 08 09 10 01 17 11 13 15 18 19 22 17 21 03 04 05 06 07 10 02 14 05 09 20 21 24 25 18 19 02 05 20 22 24 25

2745 FIXO 01 04 05 06 08 10 11 13 14 15 16 18 20 21 01 02 03 06 07 10 12 14 16 17 20 21 23 24

2745 FIXO 02 03 05 07 09 13 15 17 22 23 03 06 07 13 16 19 20 23 24 25 01 02 03 04 06 11 17 21 23 25

2745 FIXO 01 12 21 22 03 10 14 21

2745 FIXO 02 06 07 10 11 14 15 16 18 19 21 23 24 01 04 05 07 09 10 13 16 17 20 22 23 24

PTM 8285 22 4908 02....Par 90 + Dezena 08 9401 01....Par 40 + Dezena 01 9671 18 2453 14 4718 05 662 16

2744 03 04 06 09 12 13 15 17 18 19 20 21 22 24 03 04 05 08 09 10 12 13 14 16 17 18 21 24

2744 01 02 04 08 09 10 11 12 13 19 20 21 23 24 02 03 05 07 08 09 11 13 16 17 18 19 20 21

2744--2748 02 03 05 09 10 11 12 13 14 20 21 22 24 25 01 02 04 06 07 08 10 12 15 16 17 18 19 23

@Giancarlo B. Tessaro Muito bom.

"Faiou feio". É a primeira vez nos últimos 68 concursos que não acontece o "previsto". Ficou para "amenhã". Hehehe.

@Pataca e demais amigos já são dez participantes . Crescendo.... muto legal ... num dos melhores tópicos para palpites, talvez o mais próximo do nosso cotidiano e dignificando o criador deste tópico o Mestre @AIRTON MIRANDA , bem como do atual ADM, Mestre @Pataca

Se fosse padrão eu estaria rico.

Realmente em uma das ultimas vezes que saíram 10 repetidas depois veio 11, mais sabia que é isso que quebra a gente? achar que é padrão, aí a LF vai e baixa para 09 a 08 repetidas e nos quebra... mais vou arriscar de 09 a 10 repetidas também.. boa sorte!

2743 01 03 04 05 07 11 12 14 15 18 20 22 23 25 01 02 04 05 07 09 11 13 14 15 17 18 20 22 "Algo me diz" que hoje teremos 11 repetentes. Baseado nesse insight astralino vou apostar em 14 dezenas do resultado anterior e usar outra sequência com 11 repetentes. A conferir. Hehe.

2741 1 4 12 23 2 6 10 22 Fixar até final fevereiro

2741 1 4 12 23 2 6 10 22 Fixar

De fato o ChatGPT é algo incrível. No entanto, o seu caso de uso, atualmente, está mais voltado para substituir as buscas do Google que substituir o trabalho de um ser humano. Com certeza o pessoal da OpenAI deve estar recebendo um fluxo enorme de Brs nesses dias, pois vi em diversos lugares saindo reportagem sobre o ChatGPT nessa semana, de jornais em papel até sites. Sobre substituir programadores... Eu fiz alguns testes no começo do ano e final do ano passado. Estava bem longe de fornecer códigos 100% funcionais para linguagens que testei. Olha que eram coisas simples. Porém, ele trouxe um código que, para quem não sabe, pode ser um caminho a seguir. É aquele negócio. Para se programar precisa de lógica de programação, mas será que uma máquina consegue imitar o raciocínio lógico do ser humano? Quando isso acontecer, se acontecer, acredito que será algo muito perigoso. Veja teste de Turing. Outra questão envolvendo o ChatGPT é em relação a direitos autorais, uma vez que ele pode estar fazendo um cópia e cola alterando alguma coisa (aplicando sinônimos). Nos resta esperar pelos próximos capítulos.

Se você pretende encontrar manipulação, procure por desvios estatísticos. O que viria a ser tais desvios? São variações fora do esperado para certa modalidade de loteria em um campo amostral. Mas como irei fazer isso? Ai já depende de você, mas como as loterias são basicamente análise combinatória, é só você criar "filtros" e estudar o universo de possibilidades (todas as combinações de uma loteria) e confrontar contra o campo amostral (quantidade de resultados/sorteios). Caso haja alguma divergência, você encontrou indícios de manipulação e possivelmente uma "tendência" de tal loteria. Observação final: eu acredito na lisura e aleatoriedade das loterias, pelo menos da CEF (Caixa Econômica Federal), portanto não acredito que ocorra uma tendência, mas, sim, cumprimento das probabilidades.