Ir ao conteúdo
  • Cadastre-se

C Fazer Alocação Dinamica em um código de sorteio de números em C


Posts recomendados

Olá, estou com duvida em uma questão de como fazer uma alocação dinâmica em um programa na qual faz sorteios de números, onde o usuário faz aposta de até 20 números e de 0 a 100.A parte em especifico que estou com duvida é onde o programa compara os números sorteados com o(os) número(os):

int compara_aposta(int *aposta,int *sorteio,int *val_certos, int na, int ns)
{
   //realocar memoria para val_certos
}

 

EDIT: Após isso tudo, o meu receber tais valores o programa deverá sortear, aleatoriamente, 20 valores (entre 0 e 100). Após o sorteio, o programa deverá comparar os valores apostados com os sorteados e retornar para o usuário a quantidade de acertos e os números que ele acertou.

 

Código completo :

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <time.h>

void ler_aposta(int *aposta,int n)
{
  int i;
  printf("informe o(os) %d valor(es) certo(os) (0-100) \n",n);
  for(i=0;i<n;i++)
  {
    scanf("%d",&aposta[i]);
  }
}

void sorteio_valores(int *sorteio,int n)
{
  int i;
  srand(time(NULL));
  for(i=0;i<n;i++)
  {
    sorteio[i]=rand()%100;
  }
}

int compara_aposta(int *aposta,int *sorteio,int *val_certos, int na, int ns)
{
   //realocar memoria para val_certos
}
int main(void) {
  int i,nap,*aposta,sorteio[20],*val_certos,qtd_certos;
  
  printf("Informe a quantidade de números a serem apostados: \n");
  scanf("%d",&nap);
  aposta=(int *) malloc(nap*sizeof(int));
  val_certos=(int) malloc(i*sizeof(int));
  ler_apostas(aposta,nap);
  sorteio_valores(sorteio,20);
  qtd_certos=compara_apostas(aposta,sorteio,val_certos,nap,20);
  printf("Valores acertados: \n");
  for(i=0;i<20;i++);
  {
   printf("%d",sorteio[i]);
  }
  printf("valores acertados: \n");
  if(qtd_certos==0)
  {
    printf("Não acertou nada. \n");
  }
  else{
    for(i=0;i<qtd_certos;i++)
    {
      printf("%d \n",val_certos[i]);
    }
  }

  return 0;
}

 

Obs: Caso tenha algo faltando em meu código, aceito ajudas e dicas.

Link para o post
Compartilhar em outros sites

O seu algoritmo está meio confuso para mim, eu refiz uma parte que eu entendi como exemplo

Spoiler

#include <stdio.h>
#include <stdlib.h>

struct numeros_jogados
{
    unsigned short quantidade_numeros, quantidade_acertos;
    unsigned char *numeros;
};

void
pegaAposta(struct numeros_jogados *n);
/*
 * Pega os numeros da aposta.
 */

void
mostraAposta(struct numeros_jogados *n);
/*
 * Mostra os numeros da aposta.
 */

int main(int argc, char *argv[])
{
    struct numeros_jogados jogada;
    /* Pega a quantidade de numeros a ser jogados */
    printf("\nDigite a quantidade de numeros a ser jogados:\t");
    scanf("%hu", &jogada.quantidade_numeros);

    /* reserva a memoria para os numeros */
    jogada.numeros = malloc(sizeof(*jogada.numeros)*jogada.quantidade_numeros);
    /* Testa se foi possivel reservar memoria para os numeros */
    if (jogada.numeros == NULL) {
        /* ERRO! */
        perror("Nao foi possivel reservar memoria!");
        return(1);
    }

    /* Pega os numeros da aposta */
    pegaAposta(&jogada);

    /* Mostra os numeros da aposta */
    mostraAposta(&jogada);

    /* Apaga a memoria reservada */
    free(jogada.numeros);
    jogada.numeros = NULL;
    return(0);
}

void
pegaAposta(struct numeros_jogados *n)
{
    int contador;
    printf("\nInforme %hu numeros da aposta", n->quantidade_numeros);
    for (contador = 0; contador < n->quantidade_numeros; contador++) {
        printf("\n[%i]=", contador+1);
        scanf("%hhu%*c", &n->numeros[contador]);    /* %*c para retirar o enter do buffer de teclado */
    }
}

void
mostraAposta(struct numeros_jogados *n)
{
    int contador;
    printf("\nNumeros da aposta");
    for (contador = 0; contador < n->quantidade_numeros; contador++) {
        printf("\n[%i]=%hhu", contador+1, n->numeros[contador]);
    }

    printf("\nPressione enter para continuar...");
    getchar();      /* Pausa o programa */
}

 

Se você estiver fazendo algo como uma mega sena, eu recomendo usar um algoritmo como o fisher yates para embaralhar os números.

Fisher yates wikipedia

 

Meu exemplo no replit:SorteioDeNumeros

 

  • Curtir 1
Link para o post
Compartilhar em outros sites

Olá
 

Não entendi porque quer usar alocação dinâmica nesse contexto e desse jeito. Não parece haver razão. Imagino que seja algo do enunciado.

 

Sobre o programa, parece muito complicado escrever assim.

 

Sugiro usar nomes mais significativos e escrever comentários. No mínimo para descrever os argumentos e valores de retorno. 
 

    int compara_aposta(int *aposta,int *sorteio,int *val_certos, int na, int ns);


5 parâmetros mais um int de retorno parece muita coisa.
 

    void ler_aposta(int *aposta,int n)


Por outro lado porque void? Instintivamente se espera que uma função com esse nome retorne uma aposta. Porque passar um ponteiro para receber a aposta e não simplesmente retornar a aposta?
 

Esse é talvez o paradigma mais comum em C, uma linguagem que foi escrita para escrever sistemas (1 sistema, na verdade, segundo os criadores :)  ). A noção de fábrica, de factory function.
 

Vou tentar mostrar alguma coisa assim a seguir.


Ainda sobre seu programa
 

  • use comentários
     
  • nunca use variáveis globais, muito menos essas com nomes meigos como
     
  • declare variáveis de controle de um for no próprio comando. Levou quase uma década para arrumarem isso na linguagem, mas já faz mais de 40 anos.
     
  • main() deve ser a primeira função de seu programa, mesmo que seja só para você a ler. Se possível deixe main() em um arquivo separado, pela'simples razão de poder usar várias main() para testar suas funções rapidinho. ;) 
     
  • TESTE o retorno de scanf(). É muito ingênuo seguir adiante se não leu p0rr@ nenhuma. Leia o manual. 


Escreva em torno dos dados.

É muito mais fácil. Mais legível, mais seguro e seu programa pode rodar certo na primeira vez.
 

Que são os dados?
 

O sorteio e a aposta. Um jogo é isso: são sorteados uns números. E aí vem talvez um vetor de apostas, e cada aposta tem até 20 números.
 

O que pode ser um sorteio? 

quina.thumb.png.a9fcca70e570bc7451fc04388935cc3b.png

Um número de sorteio cai bem. E não parece novidade. E o conjunto de números, que pode ou não estar ordenado. Considere o sorteio da caixa econômica por exemplo: as bolinhas são sorteadas e depois podem ser colocadas em ordem. Os caras pegam as apostas e conferem.
 

 

Veja esse exemplo de dados

 

typedef struct
{
    int     concurso;
    int     N; // quantos
    int*    num; // quais 

}   Sorteio;

typedef struct
{
    int     id; // o numero da aposta
    int     N; // quantos numeros
    int*    num;
    
}   Aposta;

Sorteio*        sorteio_valores(int N); // retorna um sorteio com N numeros
Aposta*         ler_aposta(int S); // retorna uma aposta para o sorteio S

// confere() retorna uma Aposta com os numenos que a aposta A acertou no sorteio S
// o simples: confere os numeros e retorna uma nova Aposta onde so tem os certos
Aposta*         confere(Aposta* A, Sorteio* S); 

// fim

 

E talvez veja como escrevendo assim a mecânica fica até mais clara, antes mesmo de escrever qualquer código.

 

Como seria um jogo desses? Um sorteio e um conjunto de apostas.

 

 

Como criar um sorteio e conferir um sorteio?

 

Usando essas estruturas algo assim deve funcionar:
 

#include "cef.h"

int main(void)
{
    Sorteio* quina = sorteio_valores(5); // um sorteio da quina
    quina->concurso = 0406;
    quina->N = 5;

    // mostra o sorteio
    printf("Sorteio %d: ", quina->concurso );
    for(int i=0;i<quina->N; i+=1) printf( "%4d", quina->num[i]);
    printf("\n\n");

    Aposta* aposta[30]; // 30 apostas para testar
    for( int i=0; i<30; i+=1)
    {   // faz os jogos
        aposta[i] = ler_aposta(quina->concurso);
    }

    // confere as 30 apostas e mostra assim
    /*
    Aposta Acertos     Numeros
     xxxx    NN        xx xx xx xx xx
     xxxx    NN        nao acertou numero algum
     xxxx    NN        xx xx xx xx xx
     ...
    */

    printf("    Aposta Acertos     Numeros\n"); // titulo
    for( int i=0; i<30; i+=1)
    {
        Aposta* res = confere( aposta[i], quina );
        printf("     %4d    %2d        ", res->id, res->N);
        if ( res->N == 0 )
        {
            printf(" nao acertou numero algum\n");
        }
        else
        {
            for ( int i=0; i<res->N; i+=1) printf( "%4d", res->num[i]);
            printf("\n");
        };  // if()
        free(res); // so um exemplo. Nao vai usar mais o resultado
    };  // for()

    // libera o que foi alocado
    free(quina->num); // apaga o vetor de numeros
    free(quina); // apaga o sorteio
    for( int i=0;i<30;i+=1)
    {
        free(aposta[i]->num);
        free(aposta[i]);  
    };
    return 0; // nada mais
}

 

Isso acima faz um sorteio. Podiam ser 20 ou 400 nuemros e devolve o Sorteio. Tudo arrumadinho.

 

O vetor de apostas é só um exemplo: pode ser claro uma aposta só lida do teclado, mas sinceramente não recomendo fazer isso desde o início, já que é o máximo de chato ficar digitando numeros de aposta para testar o programa a cada vez...

 

Depois a rotina que confere retorna uma aposta só com números que a aposta acertou. O simples,m porque já vem com o contador e os números arrumadinhos

 

Depois libera a memória na ordem contrário à que usou para alocar e aí encerra o programa

 

Pense nisso

 

  • Obrigado 1
  • Amei 1
Link para o post
Compartilhar em outros sites

Crie uma conta ou entre para comentar

Você precisa ser um usuário para fazer um comentário

Criar uma conta

Crie uma nova conta em nossa comunidade. É fácil!

Crie uma nova conta

Entrar

Já tem uma conta? Faça o login.

Entrar agora

Sobre o Clube do Hardware

No ar desde 1996, o Clube do Hardware é uma das maiores, mais antigas e mais respeitadas comunidades sobre tecnologia do Brasil. Leia mais

Direitos autorais

Não permitimos a cópia ou reprodução do conteúdo do nosso site, fórum, newsletters e redes sociais, mesmo citando-se a fonte. Leia mais

×
×
  • Criar novo...

Redes-Wi-Fi-capa-3d-newsletter.png

EBOOK GRÁTIS!

CLIQUE AQUI E BAIXE AGORA MESMO!