Simulação da Mega Sena

joasgoncalves
(usa Outra)

Enviado em 05/10/2011 - 20:01h

Galera estou tentando fazer um programinha de simulação de mega sena mais sou muito fraco em C. alguem pode me ajudar. é trabalho de faculdade. o programa tem que baseado no TAD lista.

Desenvolver um sistema de simulação de sorteio e apresentação de resultados de uma loteria de números (Mega Sena), com as seguintes especificações: o sorteio da Mega Sena consiste em 6 números não repetidos sorteados no universo de 1-60. Os números serão sorteados e guardados em uma lista linear, obrigatoriamente implementada com Encadeamento (alocação dinâmica de memória). Guia da solução:

1) Utilizar o arquivo denominado “TAD-Lista-encad.c” apresentado pelo professor como prova de conceito do TAD Lista Encadeada, e nele implementar a estrutura de dados do sorteio da lista (consiste em um campo numérico para guardar a ordem do sorteio [1-6] e um campo numérico para guardar o número sorteado [entre 1 e 60]), e as operações sobre a Lista;

2) Criar um arquivo denominado “MegaMain.c”, onde será colocada diretiva para incluir o arquivo “TADLista-encad.c” e implementadas as funcionalidades do sistema de sorteio:
1. Sorteio dos números: sortear os seis números da Mega Sena, guardando-os na Lista, juntamente com seu número de ordem de sorteio. Para o sorteio, usar as funções srand() e rand() da linguagem C, obtendo um número aleatório entre 1 e 60. Antes de incluir na Lista cada número sorteado, pesquisar nesta se este número já não foi sorteado anteriormente. Caso afirmativo, repetir o sorteio até que seja gerado um número não repetido e só então incluí-lo na Lista;
2. Apresentação dos números sorteados: depois de efetuado o sorteio, apresentar os números sorteados na ordem do sorteio e na ordem crescente dos números sorteados;
3. Função “Marmelada”: permite excluir um dos números sorteados e gerar novo sorteio para este, verificando duplicidade com os outros sorteados e guardando-o na posição adequada da Lista.


eu tenho esse TAD lista, mais não sei por onde começar.


*/

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

/*==============================================================================
Estruturas do Tipo Abstrato de Dados LISTA
================================================================================*/

typedef struct {
char nome[26];
float preco;
int qtestoq;
}Remedio;

typedef struct Cel * Ponteiro;
typedef struct Cel {
Remedio obj;
Ponteiro prox;
}Celula;

typedef struct {
Ponteiro inicio, fim;
int tam;
}Lista;

//==============================================================================
// Prototipos das funções que implementam as Operações da Lista
//==============================================================================
void criaLista (Lista *lista);
int vazia (Lista *lista);
void insere(Remedio objt, Lista *lista, int *codErro);
void exclui(Remedio *objt, Lista *lista, int *codErro);
Remedio* buscaNome(Remedio objt, Lista *lista);
Remedio* ordenaLista(Lista *lst);

//==============================================================================
// Implementação das Operações do Tipo Abstrato de Dados Lista
//==============================================================================

void criaLista (Lista *lista)
{
lista->inicio = NULL;
lista->fim = lista->inicio;
lista->tam = 0;
} /* fim da operação criaLista */
//==============================================================================
int vazia (Lista *lista)
{
return (lista->inicio == NULL);
} /* fim da operação vazia */
//==============================================================================
void insere(Remedio objt, Lista *lst, int *codErro)
// Insere o Remedio objt no final da Lista
// Condição de Erro = 20 - Memória cheia
{
Ponteiro Paux = (Ponteiro)malloc(sizeof (Celula)); /* Passo1 */
if (Paux == NULL) { /* overflow de memória */
*codErro = 20;
return;
}
Paux->obj = objt; /* Passo2 */
Paux->prox = NULL; /* Passo3 */
if (vazia(lst)) /* Passo4 */
lst->inicio = Paux;
else lst->fim->prox = Paux;
lst->fim = Paux; /* Passo5 */
lst->tam++; /* Passo6 */

} /* fim da operação insere */
//==============================================================================
void exclui(Remedio *objt, Lista *lst, int *codErro)
// Localiza e Exclui Remedio objt da lista
// Condição de Erro = 10 - Lista vazia
// Condição de Erro = 40 - Remedio não encontrado
{
if (vazia(lst)) {
*codErro = 10; return; /* Lista vazia! */
}
Ponteiro Paux1, Paux = lst->inicio;
if(strcmp(Paux->obj.nome, objt->nome) == 0) {
lst->inicio = lst->inicio->prox; /* Passo1 – Exclui 1º elemento */
if(lst->inicio==NULL) lst->fim=NULL; /* Ajusta ponteiro lst->fim */
free (Paux); /* Passo 2 – Exclui 1º elemento*/
}
else { /* Pesquisa Remedio a ser excluído */
while((Paux->prox != NULL)&&(strcmp(Paux->prox->obj.nome,objt->nome)!=0))
Paux = Paux->prox;
if (Paux->prox == NULL) {
*codErro = 40; return; /* Elemento não encontrado */
}
else {
Paux1 = Paux->prox; /* Passo0 – demais elementos */
if(lst->fim==Paux1) lst->fim = Paux; /* Ajusta ponteiro lst->fim */
Paux->prox = Paux->prox->prox; /* Passo1 – demais elementos */
free (Paux1); /* Passo2 – demais elementos */
}
}
lst->tam--; /* Passo3 (comum a todos os elementos) */
} /* fim da operação exclui */
//==============================================================================
Remedio* buscaNome(Remedio objt, Lista *lista)
// Localiza Remedio(s) na lista, pelo Nome.
// Retorna um VETOR com os registros da Lista que batem com a chave
// de pesquisa. Como não se sabe a principio quantos registros serão retornados,
// o VETOR é alocado dinamicamente, à medida em que registros são encontrados.
// Sempre o último elemento do VETOR terá "", que indica fim das informações.
// Caso o primeiro elemento tenha "", significa que nenhum registro foi encontrado.
{
Remedio * vetObj;
int tamanho = 1; // controla o tamanho dinâmico do vetor
vetObj = (Remedio*) malloc(sizeof(Remedio)*tamanho);
strcpy(vetObj[0].nome, "");
Ponteiro p = lista->inicio;
while(p != NULL)
{
if (strcmp(p->obj.nome, objt.nome) == 0) {
tamanho++;
vetObj = (Remedio*) realloc(vetObj,sizeof(Remedio)*tamanho);
vetObj[tamanho-2] = p->obj; // penúltimo elemento recebe registro encontrado
strcpy(vetObj[tamanho-1].nome, ""); // último elemento recebe "" no campo nome
}
p = p->prox;
}
return vetObj;
} /* fim da operação buscaNome */
//==============================================================================

Remedio* ordenaLista(Lista *lst)
// Ordena a lista por Nome do Remedio e para nomes iguais, por Preco;
// Retorna um vetor com nova lista ordenada para o chamador, preservando a
// Lista original, encadeada.
{
Remedio aux, *vetObj;
int i, j = 0;
// cria Vetor e move todos os Objetos da Lista para este
vetObj = (Remedio*) malloc(sizeof(Remedio)*(lst->tam)+1);
Ponteiro p = lst->inicio;
while(p != NULL)
{
vetObj[j] = p->obj;
j++;
p = p->prox ;
}
strcpy(vetObj[lst->tam].nome,""); // coloca "marca" no último elemento
// ordena o Vetor pela chave: Nome
for (i = 0; i < lst->tam - 1; i++)
for (j = i+1; j < lst->tam; j++)
{
if (strcmp(vetObj[i].nome, vetObj[j].nome) > 0)
{
aux = vetObj[i];
vetObj[i] = vetObj[j];
vetObj[j] = aux;
}
else if ( (strcmp(vetObj[i].nome, vetObj[j].nome) == 0)
&&(vetObj[i].preco > vetObj[j].preco))
{
aux = vetObj[i];
vetObj[i] = vetObj[j];
vetObj[j] = aux;
};
};
return (vetObj);
} /* fim da operação ordenaLista */
//==============================================================================