Numeros aleatorios para cartelas de bingo

[Halmen 0]

Pessoal não estou conseguindo gerar numeros aleatorios para minhas cartelas sempre que rodo o programa ele gera numeros

repetidos. O programa esta aqui. rodo bem. so falta esse detalhe. Me ajudam aonde posso encaixar.

eu não entendi direito essa função rand. abraço

 

/*Programa BINGO*/
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
#define SOMA 1
#define NOME 20
#define JOG 6
#define LIN 2
#define COL 15
int verifica(int jog, int linha, int coluna, int boll, int gamer[JOG][LIN][COL]);
int numbola();
int randnume();
int randcart(); 
void regras(void);
void inicio(void);
//Função Principal
//********************************************************************************
*
void main(void) /*Inicio do main*/
{ 
 char op;
 static int cartao[JOG][LIN][COL], cart[JOG];
 static char jogador[JOG][NOME];
 int l, c, n, j, bola, teste, vetorsoma[JOG][LIN][COL], soma[JOG][LIN], pausa;
 int quadra, linha, bingo, acumulado;
 clrscr();
for(j = 0; j < JOG; j++) /*Laco*/
{ 
	textcolor(11);
	cprintf("\nQual é o nome do Jogador? "); 
	scanf("%s", &jogador[j][NOME]);
	printf("\nSeu numero de cartela(s) sera sorteado.\n");
	printf("\n");
	cart[j] = randcart(); /*Numero de cartelas eh sorteado*/
	printf("\nJogara com %d cartelas\n", cart[j]);
for(l = 0; l < cart[j]; l++) 
	
{
for(c = 0; c < COL; c++)

{
	cartao[j][l][c] = randnume(); /*Numeros das cartelas sao sorteados*/
	textcolor(4);
	printf("-%d-", cartao[j][l][c]); }
	printf("\n");
 }
	getch();
	clrscr();
 }
inicio(); /* primeira declaracao desta funcao: cria um placar de enfeite*/
textcolor(4); 
gotoxy(4,8);
printf("Entrem os participantes: ");
gotoxy(1,10);
for(j = 0; j < JOG; j++) /*Laco que imprime os participantes e suas cartelas*/
{ 
   printf("Senhor(a) %s, sua cartela eh:\n", &jogador[j][NOME]);
for(l = 0; l < cart[j]; l++) 
{
   printf("\n================================================================\n");
   printf("||");
   for(c = 0; c < COL; c++) {
   printf("-%d-", cartao[j][l][c]); } cprintf("||");
   printf("\n================================================================\n");
printf("\n"); }
}
getch(); 
clrscr();
textcolor(11); 
gotoxy(8,8);
cprintf("Precione qualquer tecla para comecar o jogo");
getche(); clrscr(); inicio();
gotoxy(4,8); /*Chama as regras do jogo, se o usu rio desejar*/
cprintf("Quer estudar as regras do jogo(S-N)? ");
if((op = getche()) == 's' || (op = getche()) == 'S')
{ 
clrscr();
regras();} /*Funcao para escrever as regras*/
getche(); 
clrscr(); 
inicio();
gotoxy(4,8);
cprintf("Vamos sortear as bolas. Boa sorte, jogadores!");
for(j = 0; j < JOG; j++)/*Laco duplo, para inicializar a variavel*/ 
{ 
for(l = 0; l < cart[j]; l++) {soma[j][l] = 0;}} /*soma[j][l]*/
quadra = 1; linha = 1; bingo = 1; acumulado = 1;
for(n = 0; n < 90; n++) /*Inicio das bolas e do jogo*/
{ /*Laco principal*/
getche(); 
clrscr(); 
inicio();
gotoxy(4,8); 
cprintf("Vamos sortear as bolas. Boa sorte, jogadores!");
gotoxy(4,10);
bola = numbola();	/*Chama funcao que sorteia a bola e poe o resultado*/
cprintf("A %da bola eh: %d", n+1, bola); /*na variavel 'bola'*/
getche(); clrscr(); inicio();
for(j = 0; j < JOG; j++) 
{ 
   for(l = 0; l < cart[j]; l++) 
{ 
   for(c = 0; c < COL; c++) 
{ 
   teste = verifica(j,l,c,bola,cartao);/*Funcao que compara*/
   if(teste == 's') vetorsoma[j][l][c] = 1; /*Aqui, eh criado um novo vetor,*/
	else vetorsoma[j][l][c] = 0; /*vetorsoma[][][], onde sera de 1s e 0s*/
   soma[j][l] += vetorsoma[j][l][c]; /*para todos os 1s serem somados*/
   if(soma[j][l] == 4 && quadra) 
{
   gotoxy(2,15); /*Sendo a soma igual a 4, tem a quadra*/
   cprintf("Senhor(a) %s diz: CONSEGUI, GANHEI A QUADRA!!!", &jogador[j][NOME]);
   quadra = 0; }/*Dado novo valor para a variavel, para laco n se repetir*/
   
else 

if(soma[j][l] == 5 && linha) 
{
	gotoxy(2,15);/*Sendo a soma igual a 5, tem a linha*/
	cprintf("Senhor(a) %s diz: CONSEGUI, GANHEI A LINHA!!!", &jogador[j][NOME]);
	linha = 0; 
}
   else 

if(soma[j][0] == 15 && bingo|| (soma[j][0]+soma[j][1]) == 30 && bingo) 
{
   gotoxy(2,15); /*Todos os numeros das cartelas preenchidos, temos bingo*/
   cprintf("Senhor(a) %s diz: CONSEGUI, GANHEI O BINGO!!!", &jogador[j][NOME]);
   bingo = 0; }/*Dado novo valor para a variavel, para laco n se repetir*/

else 

if(n <= 40 && soma[j][0] == 15 && acumulado || n == 40 && (soma[j][0]+soma[j][1] && acumulado) == 30) {
   gotoxy(2,15);/*Todos os numeros em 40 bolas, ou menos, acumulada*/
   cprintf("Senhor(a) %s diz: CONSEGUI, GANHEI O ACUMULADO!!!", &jogador[j][NOME]);
acumulado = 0;/*Dado novo valor para a variavel, para laco n se repetir*/
pausa = 1; 
} /*Entrando no laco da acumulada, d valor de 1 para "pausa"*/

}}}

if(pausa == 1) 
{
	gotoxy(2,20);
	cprintf("FIM DE JOGO! PARABENS, VENCEDOR!!!"); goto Fim; } /*Cursor vai para o "Fim:"*/
}
Fim:
getch();

}
//Fim da funcao Principal
//***********************************************************

void inicio(void)
{
	textcolor(14); /*Imprime uma tela especial*/
	gotoxy(28,2);
	cprintf("=========================\n");
	gotoxy(28,3);
	cprintf("||----JOGO DO BINGO----||\n");
	gotoxy(28,4);
	cprintf("=========================\n");
}
//funcao regras do jogo
//****************************************************************
void regras(void)
{
	textcolor(14);
	gotoxy(28,2);
	cprintf("=========================\n");
	gotoxy(28,3);
	cprintf("||----REGRAS DO JOGO----||\n");
	gotoxy(28,4);
	cprintf("=========================\n");
	textcolor(11);
	gotoxy(1,7);
	printf("Os premios do jogos sao: Quadra, Linha, Bingo e Acumulado\n\n\n");
	printf("Quadra: O primeiro jogador a preencher 4 numeros horizontais\n ");
	printf("de qualquer das linhas da cartela, premio R$100,00\n\n\n");
	printf("Linha: O primeiro jogador a preencher os 5 numeros horizontais\n ");
	printf("de qualquer das linhas da cartela, premio R$ 120\n\n\n");
	printf("Bingo: O primeiro jogador a preencher todos os numeros da cartela, premio R$300,00\n\n\n");
	printf("Acumulado: O primeiro jogador a preencher a cartela até a 40a bola, premio R$400,00\n\n\n");
	printf("\n\n\n");
	gotoxy(3,30);
	cprintf("Digite qualqer tecla para continuar");
	getche();
 }

//Funcao sorteia numeros dos cartoes
//****************************************************************************
int randnume()
{
	int numero; /*Retorna inteiros*/
	numero = random(90)+1;
	return(numero);
}

//funcao do sorteio da quantidade de cartoes
//****************************************************************************
int randcart()
{
	int cart; /*Retorna inteiro*/
	cart = random(2)+1;
	return(cart);
}

//funcao escolhe um numero de 1 a 90
//****************************************************************************
int numbola()
{
	int bola; /*Retorna este numero*/
	bola = random(90)+1;
	return(bola);
}

int verifica(int jog, int linha, int coluna, int boll, int gamer[JOG][LIN][COL])
{
if(gamer[jog][linha][coluna] == boll)
{
return('s');
} /*Funcao complexa. Compara a bola sorteada com*/
} /*o numero respectivo do cartao*/

[José Enésio 4]

Tente utilizar a função randomize(). Dá uma lida aqui: http://www.phanderson.com/C/random.html

 

Em especial aqui:

 

Note that if you run the following program, again and again, the same three random numbers will be generated. That is, TurboC always seeds the random number generator with the same starting number.

 

(...)

 

Therefore, the function "randomize()" may be used to seed the random number generator with a number which is developed from the system clock, which of course, is always changing

.

[Rarylson Freitas 0]

A função rand() gera os números de acordo com um valor chamado seed. Asssim, se seed=1, ela gera determinados números, para seed=2 ela gera outros. No entanto o compilador, para facilitar o "debug", sempre mantém o mesmo valor de seed. Assim, os números gerados por rand() não mudam entre uma execução e outra.

Para contornar o problema, use srand(), que altera o valor de seed inicialmente dado pelo compilador.

 

Exemplo:

printf ("%d",rand());

imprime 10 na primeira execução, 10 na secunda e por aí vai.

 

srand(5);
printf ("%d",rand());

Imprime 2 na primeira, 2 na segunda, etc. (O valor de rand() não muda, pois a semente de geração dos números é uma constante).

 

Para gerar números verdadeiramente aleatórios, basta gerar uma semente aleatória. Uma boa forma de fazer isso é:

 

srand(time(NULL));
printf ("%d",rand());

time(NULL) é uma função da biblioteca time (tem que dar "#include time.h" também). time(NULL) retorna um número associado ao relógio do sistema, que serve como uma forma simplificada para gerar sementes aleatórias.

Mesmo que a função rand() seja usada em diversos locais, inclusive em outra função, basta colocar o "srand(time(NULL))" no início da função main().

[Edultra 13]

A um tempo atrás utilizei a função srand() para sortear palavras em um trabalho, agora pensando no que o Rarylson falou pensei um pouco e fiz um pequeno tutorial e espero que ajude:

 

http://forum.imasters.com.br/index.php...p;#entry1157260