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

[Luc4s M0ur4]

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.

[kgin]

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

 

[arfneto]

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? 

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