Linux slogan
Visite também: BR-Linux.org · Dicas-L · SoftwareLivre.org · UnderLinux



» Screenshot
» Login
Login:
Senha:
Linux login

Se você ainda não possui uma conta, clique aqui.

Esqueci minha senha


Comunidades

Comunidade Linux Home Participar da comunidade Linux Participar Fórum Linux Fórum Membros LinuxMembros RSS do fórum

<< Primeira | Anterior Próxima | Última >>

Simulação da Mega Sena

[1] Enviado em 05/10/2011 - 20:01h Simulação da Mega Sena
Linux user: Joás Gonçalves Alexandre
joasgoncalves

(usa Outra)


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.nome, vetObj[j].nome) > 0)
{
aux = vetObj;
vetObj = vetObj[j];
vetObj[j] = aux;
}
else if ( (strcmp(vetObj.nome, vetObj[j].nome) == 0)
&&(vetObj.preco > vetObj[j].preco))
{
aux = vetObj;
vetObj = vetObj[j];
vetObj[j] = aux;
};
};
return (vetObj);
} /* fim da operação ordenaLista */
//==============================================================================


 

  


  
<< Primeira | Anterior Próxima | Última >>
Responsável pelo site: Fábio Berbert de Paula - Conteúdo distribuído sob licença GNU FDL
Site hospedado por:

Viva o Linux

A maior comunidade Linux da América Latina! Artigos, dicas, tutoriais, fórum, scripts e muito mais. Ideal para quem busca auto-ajuda em Linux.