Treinando lógica: mapeando todos os jogos da lotofácil

yugi386 · Mensagem por **yugi386** » 27 Abr 2014 19:25

Prezados amigos,

Em 2010 criei uma rotina para mapear todos os jogos da lotofácil. Tendo inclusivi postado um arquivo contendo todos os jogos no 4shared: http://www.4shared.com/rar/zXmPWszM/lot ... cale=pt-BR.

Infelizmente perdi o código fonte e aí neste sábado resolvi recriá-lo. O código fonte original ficou bem menor, mas não me lembro a lógica que usei.
Neste escrevi um pouco mais mas o resultado é idêntico: um arquivo .txt com todos as 3.268.760 combinações.

Por curiosidade, ou caso seja de interesse de algum de vocês segue aqui o código fonte.

Código: Selecionar todos

/**
====================================================================================================
MAPEANDO TODOS OS JOGOS DA LOTO-FÁCIL
----------------------------------------------------------------------------------------------------
PROGRAMADOR: YUGI
====================================================================================================
*/
function main()
	LOCAL ct:=0	
	PUBLIC vet1:=array(6), vet2:=array(6), vet3:=array(6), vet4:=array(6), vet5:=array(6)
	PUBLIC jog1:={}, jog2:={}, jog3:={},  jog4:={},  jog5:={}  
	
	inicializa() 	    // Preenchendo os vetores de inicialização
	calcularJogadas()  	// calculando todas as jogadas possíveis por blocos

	? time()
	criarArquivo("a.txt")
		calcularJogo()	// calcular todos os jogos possíveis para lotofacil
	fecharArquivo()
	? time()

return

/**
====================================================================================================
Cria um arquivo texto permitindo escrever nele como se estivesse mostrando informações na tela
do computador
====================================================================================================
*/
function criarArquivo(wArq)
	set printer on
	set device to printer
	set console off
	set printer to &wArq
return

/**
====================================================================================================
Fecha um arquivo Texto e retorna o direcionamento para a tela
====================================================================================================
*/
function fecharArquivo()
	set printer off
	set device to screen
	set console on
	set printer to 
return

/**
====================================================================================================
Preenche os vetores de inicialização para calcular todas as jogadas
====================================================================================================
*/
function inicializa()
	LOCAL ct:=0

	vet1[1] = ""
	for ct:= 2 to 6
		vet1[ct] = strzero(ct-1,2,0)
	next	

	vet2[1] = ""
	for ct:= 2 to 6
		vet2[ct] = strzero(5 + val(vet1[ct]),2,0)
	next	

	vet3[1] = ""
	for ct:= 2 to 6
		vet3[ct] = strzero(10 + val(vet1[ct]),2,0)
	next	

	vet4[1] = ""
	for ct:= 2 to 6
		vet4[ct] = strzero(15 + val(vet1[ct]),2,0)
	next	

	vet5[1] = ""
	for ct:= 2 to 6
		vet5[ct] = strzero(20 + val(vet1[ct]),2,0)
	next	

return

/**
====================================================================================================
Calcula todas as jogadas para cada um dos 5 grupos
====================================================================================================
*/
function calcularJogadas()
	LOCAL ct:=0, vetorTmp := {}, contador:={1,1,1,1,1,1}, cStr:="", modelo := {1,2,3,4,5}

	do while .t.
		cStr = vet1[contador[1]] + vet1[contador[2]] + vet1[contador[3]] + vet1[contador[4]] + vet1[contador[5]] + vet1[contador[6]]

		++ contador[1]

		if (contador[1]>6)
			contador[1] = 1
			++ contador[2]
		endif

		if (contador[2]>6)
			contador[2] = 1
			++ contador[3]
		endif

		if (contador[3]>6)
			contador[3] = 1
			++ contador[4]
		endif

		if (contador[4]>6)
			contador[4] = 1
			++ contador[5]
		endif

		if (contador[5]>6)
			contador[5] = 1
			++ contador[6]
		endif

		if (contador[6]>6)
			exit
		endif

		if jogadaValida(cStr) 
			cStr = ordenaJogada(cStr)
			if !contemJogada(vetorTmp,formata(cStr))
				aadd(vetorTmp, formata(cStr))
			endif
		endif
	enddo

	jog1 = vetorTmp

	// calculando as outras jogadas
	
	tam := len(jog1)

	valor = 5
	for ct:= 1 to tam
		cstr = jog1[ct]
		for ct2:= 1 to 5
			cstr = strtran(cStr,strzero(modelo[ct2],2,0),strzero(modelo[ct2]+valor,2,0))
		next
		aadd(jog2,cStr)
	next
	
	valor = 10
	for ct:= 1 to tam
		cstr = jog1[ct]
		for ct2:= 1 to 5
			cstr = strtran(cStr,strzero(modelo[ct2],2,0),strzero(modelo[ct2]+valor,2,0))
		next
		aadd(jog3,cStr)
	next

	valor = 15
	for ct:= 1 to tam
		cstr = jog1[ct]
		for ct2:= 1 to 5
			cstr = strtran(cStr,strzero(modelo[ct2],2,0),strzero(modelo[ct2]+valor,2,0))
		next
		aadd(jog4,cStr)
	next

	valor = 20
	for ct:= 1 to tam
		cstr = jog1[ct]
		for ct2:= 1 to 5
			cstr = strtran(cStr,strzero(modelo[ct2],2,0),strzero(modelo[ct2]+valor,2,0))
		next
		aadd(jog5,cStr)
	next

return

/**
====================================================================================================
formata a jogada colocando espaços entre os números
====================================================================================================
*/
function formata(jogada)
	local ret := ""

	do case
	case len(jogada) = 10
		ret = substr(jogada,1,2) + " "  + substr(jogada,3,2) + " " + substr(jogada,5,2) + " " +  substr(jogada,7,2) + " " + ;
		      substr(jogada,9,2)
	case len(jogada) = 8
		ret = substr(jogada,1,2) + " "  + substr(jogada,3,2) + " " + substr(jogada,5,2) + " " +  substr(jogada,7,2)
	case len(jogada) = 6
		ret = substr(jogada,1,2) + " "  + substr(jogada,3,2) + " " + substr(jogada,5,2)
	case len(jogada) = 4
		ret = substr(jogada,1,2) + " "  + substr(jogada,3,2)
	case len(jogada) = 2
		ret = jogada
	endcase

return ret

/**
====================================================================================================
Verifica se a jogada é valida
====================================================================================================
*/
function jogadaValida(jogada)
	local ct:=0, valida := "0102030405", verifica:= 1, tam:= 0

	if len(jogada) <= 2
		return .T.
	endif

	if len(jogada) > 10
		return .F.
	endif
	
	if len(jogada) = 2
		if (substr(jogada,1,2) == substr(jogada,3,2))
			return .F.
		else
			return .T.	
		endif
	endif
		
	tam = len(jogada)
	for ct:= 1 to tam step 2
		if substr(jogada,ct,2) $ valida
			valida = strtran(valida,substr(jogada,ct,2),"")
		else
			verifica = 0
			exit
		endif	
	next

	if verifica == 1
		return .T.
	endif

return .F.

/**
====================================================================================================
Verifica se a jogada já foi adicionada ao vetor 
====================================================================================================
*/
function contemJogada(vetor,jogada)
	LOCAL tam:= 0

	tam := len(vetor)

	for ct:= 1 to tam
		if (jogada == vetor[ct])
			return .T.
		endif
	next

return .F.

/**
====================================================================================================
Ordena uma jogada de forma ascendente
====================================================================================================
*/
function ordenaJogada(cStr)
	local ret := "", vet := {}

	if len(cStr) <= 2
		return cStr
	endif

	for ct:= 1 to len(cStr) step 2
		aadd(vet,val(substr(cStr,ct,2)))	
	next

	asort(vet)
	ret := ""

	for ct:= 1 to len(vet)
		ret := ret + strzero(vet[ct],2,0)
	next
	
return ret

/**
====================================================================================================
Verifica se uma jogada completa é valida
====================================================================================================
*/
function verificaJogada(cStr)
	local ct:= 0, tam := 0, valida := "01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25"

	cStr := strtran(cStr," ","")
	tam := len(cStr)

	if tam <> 30
		return .F.
	endif

	for ct:= 1 to tam step 2
		if substr(cStr,ct,2) $ valida
			valida = strtran(valida,substr(cStr,ct,2),"")
		else
			return .F.
		endif	
	next

return .T.

/**
====================================================================================================
Calcular Jogo
====================================================================================================
*/
function calcularJogo()
	local contador:={1,1,1,1,1}, limite:= len(jog1), ct:= 1
	
	do while.t.
		cStr := jog1[contador[1]] + " " + jog2[contador[2]] + " " + jog3[contador[3]] + " " + jog4[contador[4]] + " " + jog5[contador[5]] 

		if verificaJogada(cStr)
			if ct = 1
				?? strzero(ct,7) + ": " + Alltrim(strtran(cStr,"  "," "))
			else
				? strzero(ct,7) + ": " + Alltrim(strtran(cStr,"  "," "))
			endif
			++ ct
		endif

		++ contador[1]

		if (contador[1]>limite)
			contador[1] = 1
			++ contador[2]
		endif

		if (contador[2]>limite)
			contador[2] = 1
			++ contador[3]
		endif

		if (contador[3]>limite)
			contador[3] = 1
			++ contador[4]
		endif

		if (contador[4]>limite)
			contador[4] = 1
			++ contador[5]
		endif

		if (contador[5]>limite)
			exit
		endif

	enddo

return

att,

Yugi.

Mensagem por **lugab** » 27 Abr 2014 20:07

Yug,

Seria interessante se a rotina aceitasse informar N (onde N > 15 .and. N<25) dezenas e combiná-las, em vez de todas as 25

Combinar todas deve custar centenas de vez mais caro q o prémio pago

yugi386 · Mensagem por **yugi386** » 27 Abr 2014 23:58

Prezado Lugab,

O que me interessou ao escrever esta rotina foram os aspectos lógicos. De qualquer forma segue o código sugerido. Você escolhe entre 1 e 14 números e o sistema completa o restante pra você. Por exemplo, se você escolher 11 dos 15 números necessários para a aposta da lotofacil, quantos cartões são necessários para fechar o jogo?

De 25 tiramos 11, sobra 14. Destes 14 o sistema fará combinações de 4 em 4 para completar os números que faltam.
4 números de 14 dá: 14 * 13 * 12 * 11 = 24024. Mas como a ordem não importa você divide este total por 4! (quatro fatorial) = 24.
O resultado é 1001.
Ou seja será necessário jogar 1001 cartões para fechar o jogo. O código a seguir lhe diz quem são estes 1001 cartões.
Isto significa que se você jogar 1001 cartões e se os 11 números iniciais que você escolheu forem sorteados você ganha com 15 números.

Sou contra todo tipo de vício e inclusive o vício do jogo que já arruinou muitas famílias. Mas uma vez repito: meu interesse neste tema é somente no que se refere à lógica e à programação!!!

Segue o código fonte:

Código: Selecionar todos

/**
====================================================================================================
MAPEANDO TODOS OS JOGOS DA LOTO-FÁCIL
----------------------------------------------------------------------------------------------------
PROGRAMADOR: YUGI
====================================================================================================
*/
function main()
	LOCAL ct:=0, lista:="S"	
	PUBLIC vet1:=array(6), vet2:=array(6), vet3:=array(6), vet4:=array(6), vet5:=array(6)
	PUBLIC jog1:={}, jog2:={}, jog3:={},  jog4:={},  jog5:={}, numeroPersonalizado := {}
	
	inicializa() 	    // Preenchendo os vetores de inicialização
	calcularJogadas()  	// calculando todas as jogadas possíveis por blocos

	set confirm on

	cls
	@ 00,01 say "JOGOS DA LOTOFACIL"
	@ 01,01 say "Gerar lista Completa, Personalizada ou Sair? [C/P/S]..: " get lista pict "!" valid lista $ "CPScps"
	Read

	lista := upper(lista)

	do case
	case lista = "C"
		@ 02,01 say "Aguarde, mapeando todos os jogos..."
		? time()
		criarArquivo("a.txt")
			calcularJogo()	// calcular todos os jogos possíveis para lotofacil
		fecharArquivo()
		? time()
	case lista = "S"
		quit
	case lista = "P"	
		num = space(60)
		@ 02,01 say "Digite os numeros que voce quer que aparecam no seu jogo, separe por virgulas!!! "
		@ 03,01 say "Os numeros devem estar entre 1 e 25."
		@ 04,01 say "Sua lista pode conter um numero, 2, 3 ou ate 14 numeros."
		@ 05,01 say "Ex: 2, 5, 24, 13"
		@ 06,01 say "Numeros para o jogo...: " get num picture "@s50"
		Read

		num = alltrim(num)
		num = strtran(num," ","")
		
		do while.t.
			tmp := ""
			for ct:= 1 to len(num)
				if isDigit(substr(num,ct,1))
					tmp = tmp + substr(num,ct,1)
				else
					exit
				endif
			next

			num = substr(num,ct+1)
			if !empty(tmp) 
				if (val(tmp) >= 1 .and. val(tmp) <= 25)
					if !contemJogada(numeroPersonalizado,strzero(val(tmp),2,0))
						aadd( numeroPersonalizado, strzero(val(tmp),2,0))
					endif
				else 
					@ 07, 01 say "Os numeros devem estar entre 1 e 25!!!"	
					quit
				endif
			endif

			if len(num)=0
				exit
			endif
		enddo

		Asort(numeroPersonalizado)
		jogoPersonalizado := ""

		if len(numeroPersonalizado) > 14 .or. len(numeroPersonalizado) < 1
			@ 07,01 say "Quantidade de numero invalida!!! Deve estar entre 1 e 14!!!"
			quit
		endif

		for ct:= 1 to len( numeroPersonalizado)
			 jogoPersonalizado += numeroPersonalizado[ct] + " "
		next

		jogoPersonalizado = alltrim(jogoPersonalizado)

		@ 07,01 say "Numeros escolhidos: " + jogoPersonalizado
		@ 08,01 say "Aguarde, calculando jogo personalizado..."
		? time()
		criarArquivo("a.txt")
			calcularJogoPersonalizado(numeroPersonalizado)	// calcular jogo personalizado...
		fecharArquivo()
		? time()

	endcase

return

/**
====================================================================================================
Cria um arquivo texto permitindo escrever nele como se estivesse mostrando informações na tela
do computador
====================================================================================================
*/
function criarArquivo(wArq)
	set printer on
	set device to printer
	set console off
	set printer to &wArq
return

/**
====================================================================================================
Fecha um arquivo Texto e retorna o direcionamento para a tela
====================================================================================================
*/
function fecharArquivo()
	set printer off
	set device to screen
	set console on
	set printer to 
return

/**
====================================================================================================
Preenche os vetores de inicialização para calcular todas as jogadas
====================================================================================================
*/
function inicializa()
	LOCAL ct:=0

	vet1[1] = ""
	for ct:= 2 to 6
		vet1[ct] = strzero(ct-1,2,0)
	next	

	vet2[1] = ""
	for ct:= 2 to 6
		vet2[ct] = strzero(5 + val(vet1[ct]),2,0)
	next	

	vet3[1] = ""
	for ct:= 2 to 6
		vet3[ct] = strzero(10 + val(vet1[ct]),2,0)
	next	

	vet4[1] = ""
	for ct:= 2 to 6
		vet4[ct] = strzero(15 + val(vet1[ct]),2,0)
	next	

	vet5[1] = ""
	for ct:= 2 to 6
		vet5[ct] = strzero(20 + val(vet1[ct]),2,0)
	next	

return

/**
====================================================================================================
Calcula todas as jogadas para cada um dos 5 grupos
====================================================================================================
*/
function calcularJogadas()
	LOCAL ct:=0, vetorTmp := {}, contador:={1,1,1,1,1,1}, cStr:="", modelo := {1,2,3,4,5}

	do while .t.
		cStr = vet1[contador[1]] + vet1[contador[2]] + vet1[contador[3]] + vet1[contador[4]] + vet1[contador[5]] + vet1[contador[6]]

		++ contador[1]

		if (contador[1]>6)
			contador[1] = 1
			++ contador[2]
		endif

		if (contador[2]>6)
			contador[2] = 1
			++ contador[3]
		endif

		if (contador[3]>6)
			contador[3] = 1
			++ contador[4]
		endif

		if (contador[4]>6)
			contador[4] = 1
			++ contador[5]
		endif

		if (contador[5]>6)
			contador[5] = 1
			++ contador[6]
		endif

		if (contador[6]>6)
			exit
		endif

		if jogadaValida(cStr) 
			cStr = ordenaJogada(cStr)
			if !contemJogada(vetorTmp,formata(cStr))
				aadd(vetorTmp, formata(cStr))
			endif
		endif
	enddo

	jog1 = vetorTmp

	// calculando as outras jogadas
	
	tam := len(jog1)

	valor = 5
	for ct:= 1 to tam
		cstr = jog1[ct]
		for ct2:= 1 to 5
			cstr = strtran(cStr,strzero(modelo[ct2],2,0),strzero(modelo[ct2]+valor,2,0))
		next
		aadd(jog2,cStr)
	next
	
	valor = 10
	for ct:= 1 to tam
		cstr = jog1[ct]
		for ct2:= 1 to 5
			cstr = strtran(cStr,strzero(modelo[ct2],2,0),strzero(modelo[ct2]+valor,2,0))
		next
		aadd(jog3,cStr)
	next

	valor = 15
	for ct:= 1 to tam
		cstr = jog1[ct]
		for ct2:= 1 to 5
			cstr = strtran(cStr,strzero(modelo[ct2],2,0),strzero(modelo[ct2]+valor,2,0))
		next
		aadd(jog4,cStr)
	next

	valor = 20
	for ct:= 1 to tam
		cstr = jog1[ct]
		for ct2:= 1 to 5
			cstr = strtran(cStr,strzero(modelo[ct2],2,0),strzero(modelo[ct2]+valor,2,0))
		next
		aadd(jog5,cStr)
	next

return

/**
====================================================================================================
formata a jogada colocando espaços entre os números
====================================================================================================
*/
function formata(jogada)
	local ret := ""

	do case
	case len(jogada) = 10
		ret = substr(jogada,1,2) + " "  + substr(jogada,3,2) + " " + substr(jogada,5,2) + " " +  substr(jogada,7,2) + " " + ;
		      substr(jogada,9,2)
	case len(jogada) = 8
		ret = substr(jogada,1,2) + " "  + substr(jogada,3,2) + " " + substr(jogada,5,2) + " " +  substr(jogada,7,2)
	case len(jogada) = 6
		ret = substr(jogada,1,2) + " "  + substr(jogada,3,2) + " " + substr(jogada,5,2)
	case len(jogada) = 4
		ret = substr(jogada,1,2) + " "  + substr(jogada,3,2)
	case len(jogada) = 2
		ret = jogada
	endcase

return ret

/**
====================================================================================================
Verifica se a jogada é valida
====================================================================================================
*/
function jogadaValida(jogada)
	local ct:=0, valida := "0102030405", verifica:= 1, tam:= 0

	if len(jogada) <= 2
		return .T.
	endif

	if len(jogada) > 10
		return .F.
	endif
	
	if len(jogada) = 2
		if (substr(jogada,1,2) == substr(jogada,3,2))
			return .F.
		else
			return .T.	
		endif
	endif
		
	tam = len(jogada)
	for ct:= 1 to tam step 2
		if substr(jogada,ct,2) $ valida
			valida = strtran(valida,substr(jogada,ct,2),"")
		else
			verifica = 0
			exit
		endif	
	next

	if verifica == 1
		return .T.
	endif

return .F.

/**
====================================================================================================
Verifica se a jogada já foi adicionada ao vetor 
====================================================================================================
*/
function contemJogada(vetor,jogada)
	LOCAL tam:= 0

	tam := len(vetor)

	for ct:= 1 to tam
		if (jogada == vetor[ct])
			return .T.
		endif
	next

return .F.

/**
====================================================================================================
Ordena uma jogada de forma ascendente
====================================================================================================
*/
function ordenaJogada(cStr)
	local ret := "", vet := {}

	if len(cStr) <= 2
		return cStr
	endif

	for ct:= 1 to len(cStr) step 2
		aadd(vet,val(substr(cStr,ct,2)))	
	next

	asort(vet)
	ret := ""

	for ct:= 1 to len(vet)
		ret := ret + strzero(vet[ct],2,0)
	next
	
return ret

/**
====================================================================================================
Verifica se uma jogada completa é valida
====================================================================================================
*/
function verificaJogada(cStr)
	local ct:= 0, tam := 0, valida := "01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25"

	cStr := strtran(cStr," ","")
	tam := len(cStr)

	if tam <> 30
		return .F.
	endif

	for ct:= 1 to tam step 2
		if substr(cStr,ct,2) $ valida
			valida = strtran(valida,substr(cStr,ct,2),"")
		else
			return .F.
		endif	
	next

return .T.

/**
====================================================================================================
Calcular Jogo
====================================================================================================
*/
function calcularJogo()
	local contador:={1,1,1,1,1}, limite:= len(jog1), ct:= 1
	
	do while.t.
		cStr := jog1[contador[1]] + " " + jog2[contador[2]] + " " + jog3[contador[3]] + " " + jog4[contador[4]] + " " + jog5[contador[5]] 

		if verificaJogada(cStr)
			if ct = 1
				?? strzero(ct,7) + ": " + Alltrim(strtran(cStr,"  "," "))
			else
				? strzero(ct,7) + ": " + Alltrim(strtran(cStr,"  "," "))
			endif
			++ ct
		endif

		++ contador[1]

		if (contador[1]>limite)
			contador[1] = 1
			++ contador[2]
		endif

		if (contador[2]>limite)
			contador[2] = 1
			++ contador[3]
		endif

		if (contador[3]>limite)
			contador[3] = 1
			++ contador[4]
		endif

		if (contador[4]>limite)
			contador[4] = 1
			++ contador[5]
		endif

		if (contador[5]>limite)
			exit
		endif

	enddo

return

/**
====================================================================================================
Calcular Jogo Personalizado
====================================================================================================
*/
function calcularJogoPersonalizado(wJogo)
	local contador:={1,1,1,1,1}, limite:= len(jog1), ct:= 1
	
	do while.t.
		cStr := jog1[contador[1]] + " " + jog2[contador[2]] + " " + jog3[contador[3]] + " " + jog4[contador[4]] + " " + jog5[contador[5]] 

		if verificaJogada(cStr)
			if contemJogadaPersonalizada(wJogo, cStr)
				if ct = 1
					?? strzero(ct,7) + ": " + Alltrim(strtran(cStr,"  "," "))
				else
					? strzero(ct,7) + ": " + Alltrim(strtran(cStr,"  "," "))
				endif
				++ ct
			endif
		endif

		++ contador[1]

		if (contador[1]>limite)
			contador[1] = 1
			++ contador[2]
		endif

		if (contador[2]>limite)
			contador[2] = 1
			++ contador[3]
		endif

		if (contador[3]>limite)
			contador[3] = 1
			++ contador[4]
		endif

		if (contador[4]>limite)
			contador[4] = 1
			++ contador[5]
		endif

		if (contador[5]>limite)
			exit
		endif

	enddo

return

/**
====================================================================================================
Verifica se a jogada contém os números selecionados
====================================================================================================
*/
function contemJogadaPersonalizada(vetor,jogo)
	LOCAL tam:= 0

	tam := len(vetor)

	for ct:= 1 to tam
		if !(vetor[ct] $ jogo)
			return .F.
		endif
	next

return .T.

att,

Yugi

carlos_dornelas · Mensagem por **carlos_dornelas** » 28 Abr 2014 18:00

yugi386, esse negócio de números e loterias sempre me fascinou. Aliás, o que me levou ao mundo da programação lá pelos anos 90 foi justamente a necessidade de se resolver problemas de combinações, estatísticas, etc. Depois, acabei utilizando os conhecimentos obtidos através de muitos testes, erros e acertos, em outras áreas. Sempre fui auto-didata, desde o basic, passando pelo clipper e agora o xHarbour. Muitas vezes dormi pensando em como resolver um bug num programa e acordei com uma solução! Incrível como esse negócio de programar números me deu e me dá prazer! Se você quiser mais um desafio para exercitar a lógica, pense, por exemplo no caso da lotofácil, como fazer fechamentos com garantia de 14 ou 13 acertos. Será um bom exercício.

[]s

Antonio Carlos

luiz antonio da silva · Mensagem por **luiz antonio da silva** » 08 Mai 2014 08:57

Olá !

Tenho vários programas para loteria(s), um deles tá no 4shared, busque por GCSN2.exe, quem sabe ajuda nas suas ideias.

Abraço.
Luiz

EANDRIOLI · Mensagem por **EANDRIOLI** » 04 Abr 2016 14:14

YUGI, tudo bem!

É possível nos informar onde mudar no seu fonte, para que o sistema gere jogos acima de 15 dezenas?

A princípio ele só gera jogos de 15 dezenas.

Se for fácil, claro.

Abraços,

ERASMO ANDRIOLI

yugi386 · Mensagem por **yugi386** » 06 Mai 2016 12:57

Saudações!

O sistema faz jogos de 15 números, não mais que isto. Você pode especificar quantos quiser abaixo de 15.

Para fazer o que você quer será necessário modificar a maneira como eu fiz o código. Ele foi feito pensando em 15 números e então mudar isto ... Eu não sei intuitivamente como fazer...
Infelizmente não posso implementar as mudanças que você comentou.

att

Yugi