terça-feira, 8 de dezembro de 2009

Codigo em C - Estacionamento para fins acadêmicos

E ai Galera... meu trabalho do estacionamento ficou interessante pelos detalhes, mas ta cheio de BUGs...

quem quiser dar um bizu ta ai:

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <string.h>
typedef struct ticket
{
    char carro[50];
    char placa[50];
    int move;
    int tick;
    time_t hora_entrada;
    struct ticket *prox;
}nodo;
struct tm *ptr;
int ticket=1;
void imprime_hora(nodo *lista)//funciona
{
     ptr=localtime(&lista->hora_entrada);
     printf(asctime(ptr));
}
void insere(nodo **lista,char *car,char *plac)//funciona
{
     nodo *novo;
     novo=(nodo*)malloc(sizeof(nodo));
     strcpy(novo->carro,car);
     strcpy(novo->placa,plac);
     novo->hora_entrada=time(NULL);
     novo->move=0;
     novo->tick=ticket;
     novo->prox=*lista;
     *lista=novo;
     ticket++;
     printf("\nSEU TICKET COMPROVANTE É  %d\n",novo->tick);
}
void entrada(nodo **lista)//funciona
{
     char car[50],plac[50];
     printf("\n NOME DO CARRO: \t");
     gets(car);
     printf("\n PLACA: \t");
     gets(plac);
     insere(&*lista,car,plac);
}
void imprime(nodo **lista)//funciona
{
     nodo *aux;
     if (*lista==NULL)
     {
         printf("LISTA VAZIA MANEH \n");
     }
     else
     {
         aux=*lista;
         printf("\nCarro: %s",aux->carro);
         printf("\nPlaca: %s",aux->placa);
         printf("\nMovimentacoes: %d",aux->move);
         printf("\nHorario de entrada:");
         imprime_hora(aux);
                
     }
}
int verifica_fila_cheia(nodo **lista)//funciona
{
    int i=0;
    nodo *aux;
    aux=*lista;
    while(aux!=NULL)
    {
        aux=aux->prox;
        i++;
    }
    if(i>=4)
       return 1;
    else
       return 0;
}
void cabecalho()
{
     printf("----------------------------------------------------------------------------\n");
     printf("|                                                                          |\n");
     printf("|\t\t\tBEM VINDO AO STAR PARK I (beta)\t\t\t   |\n");
     printf("|                                                                          |\n");
     printf("----------------------------------------------------------------------------\n");
   
   
}
void desenha(nodo ** l1,nodo ** l2, nodo ** l3,nodo **l4)//funciona
{
    nodo *aux1,*aux2,*aux3,*aux4;
    int i;
    aux1=*l1;
    aux2=*l2;
    aux3=*l3;
    aux4=*l4;
    printf("\t\t\t|---|---|---|---|\n");
    for(i=0;i<4;i++)
    {
        printf("\t\t\t|");
        if(aux1!=NULL)
        {
            printf(" X ");
            aux1=aux1->prox;
        }
        else
        {
            printf("   ");
        }
        printf("|");
        if(aux2!=NULL)
        {
            printf(" X ");
            aux2=aux2->prox;
        }
        else
        {
            printf("   ");
        }
        printf("|");
        if(aux3!=NULL)
        {
            printf(" X ");
            aux3=aux3->prox;
        }
        else
        {
            printf("   ");
        }
        printf("|");
        if(aux4!=NULL)
        {
            printf(" X ");
            aux4=aux4->prox;
        }
        else
        {
            printf("   ");
        }
        printf("|");
        printf("\n");
    }
}

nodo *busca_carro(nodo **lista,int key)
{
     nodo *aux;
     aux=*lista;
     while(aux!=NULL)
     {
        if(aux->tick==key)
           return aux;
        aux=aux->prox;
     }
     return NULL;
}
void insere_manobra(nodo **carro,nodo **pilha_manobra)
{
     nodo *novo;
     novo=(nodo*)malloc(sizeof(nodo));
     strcpy(novo->carro,(*carro)->carro);
     strcpy(novo->placa,(*carro)->placa);
     novo->move=((*carro)->move);
     novo->tick=(*carro)->tick;
     novo->hora_entrada=(*carro)->hora_entrada;
     novo->prox=*pilha_manobra;
     *pilha_manobra=novo;
}
void retorna_estacionamento(nodo **manobra,nodo **lista)
{
     nodo *novo;
     novo=(nodo*)malloc(sizeof(nodo));
     strcpy(novo->carro,(*manobra)->carro);
     strcpy(novo->placa,(*manobra)->placa);
     novo->move=((*manobra)->move+1);
     novo->hora_entrada=(*manobra)->hora_entrada;
     novo->tick=(*manobra)->tick;
     novo->prox=*lista;
     *lista=novo;
     free(*manobra);
}
   
    
void retira(nodo ** saindo,nodo **lista)
{
     nodo *aux,*manobra=NULL;
     aux=*lista;
     if(aux==(*saindo) || ((*lista)->prox)==NULL )
     {
         (*lista)=(*lista)->prox;
         free(*saindo);
     }
     else
     {
         while(aux!=(*saindo))
         {
             insere_manobra(&aux,&manobra);
              aux=aux->prox;
              free((*lista));
              *lista=aux;
         }
         *lista=(*lista)->prox;
         free(*saindo);
         aux=manobra;
         while(aux!=NULL)
         {
             retorna_estacionamento(&manobra,&*lista);
             aux=aux->prox;
         }
     }
}
   
   
       
   
int main ()
{
    int escolha,tic;
    nodo *fila1=NULL,*fila2=NULL,*fila3=NULL,*fila4=NULL,*aux;
    cabecalho();
    do{
       printf("DIGITE A OPCAO DESEJADA:\n");
       printf("\t1-REGISTRAR ENTRADA DE VEICULO;\n\t2-REGISTRAR SAIDA DE UM VEICULO;\n\t3-IMPRIMIR O STATUS DO ESTACIONAMENTO;\n\t4-SAIR;\n\t");
       scanf("%d",&escolha);
       fflush(stdin);
       switch(escolha)
          {
           case 1:
                  if(verifica_fila_cheia(&fila1)==0)
                     entrada(&fila1);
                  else
                  {
                    
                      if(verifica_fila_cheia(&fila2)==0)
                         entrada(&fila2);
                      else
                      {
                        
                          if(verifica_fila_cheia(&fila3)==0)
                             entrada(&fila3);
                          else
                          {
                            
                              if(verifica_fila_cheia(&fila4)==0)
                                 entrada(&fila4);
                              else
                                  printf("O ESTACIONAMENTO ESTA CHEIO... PROCURE OUTRA FILIAL!!!\n");
                          }
                      }
                  }
                  break;
           case 2: printf("Digite o codigo do ticket:");
                   scanf("%d",&tic);
                   aux=busca_carro(&fila1,tic);
                   if(aux!=NULL)
                   {
                       imprime(&aux);
                       retira(&aux,&fila1);
                   }
                   else
                   {
                       aux=busca_carro(&fila2,tic);
                       if(aux!=NULL)
                       {
                           imprime(&aux);
                           retira(&aux,&fila2);
                       }
                       else
                       {
                           aux=busca_carro(&fila3,tic);
                           if(aux!=NULL)
                           {
                               imprime(&aux);
                               retira(&aux,&fila3);
                           }
                           else
                           {
                               aux=busca_carro(&fila4,tic);
                               if(aux!=NULL)
                               {
                                   imprime(&aux);
                                   retira(&aux,&fila4);
                               }
                           }
                       }
                   }
                              
                   if(aux==NULL)
                       printf("CARRO NAO ENCONTRADO\n");
                   break;                     
                    
           case 3: desenha(&fila1,&fila2,&fila3,&fila4);
                   break;
           case 4:printf("OBRIGADO POR UTILIZAR O SISTEMA\n");
                  break;
          }
       }while(escolha!=4);
    system("PAUSE");
    return 0;

}

Exercicio de Inserção ordenada

Bom dia galera... muita gente pediu no email da turma... então vai la o trabalho de inserção ordenada...

abraços...

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

typedef struct elemento
{
   int i;
   struct elemento *prox;
}nodo;
int insere_ordenado(nodo **l, int n)
{
   nodo *aux,*aux2,*no;
   no=(nodo*)malloc(sizeof(nodo));
   no->i=n;
   no->prox=NULL;
   aux=*l;
   if(*l==NULL)
   {
      *l=no;
      return 1;
   }
   else
   {
      if(aux->i > n)
      {
         no->prox=*l;
         *l=no;
         return 1;
      }
      else
      {
         aux2=aux->prox;
         while(aux2!=NULL)
         {
            if(aux->i<=n && n<=aux2->i)
            {
               no->prox=aux2;
               aux->prox=no;
               return 1;
            }
            aux2=aux2->prox;
            aux=aux->prox;
         }
         aux->prox=no;
         return 1;
      }
   }
}
int exclui(nodo ** l,int n)
{
    nodo *aux,*aux2;
    aux=*l;
    if(*l==NULL)
    {
       printf("LISTA VAZIA\n");
       return 0;
    }
    if(aux->i==n)//caso o primeiro da lista seja o escolhido
    {
       aux=*l;
       *l=aux->prox;
       free(aux);
       return 1;
    }
    aux2=aux->prox;
    while(aux2!=NULL)//passa pela lista toda procurando o n
    {
       if(aux2->i==n)
       {
          aux->prox=aux2->prox;
          free(aux2);
          return 1;
       }
       aux2=aux2->prox;
       aux=aux->prox;
    }
    return 0;
}
void imprime(nodo **l)
{
    nodo *aux;
    if(*l==NULL)
    {
       printf("LISTA VAZIA\n");
    }
    else
    {
       aux=*l;
       while(aux!=NULL)
       {
          printf("\t %d",aux->i);
          aux=aux->prox;
       }
       printf("\n");
    }
}
int main()
{
    int escolha, digite;
    nodo *lista=NULL;
    do{
         printf("DIGITE A OPÇÃO DESEJADA: \n 1-INSERIR NUMERO NA LISTA DE FORMA ORDENADA \n 2-EXCLUI NUMERO DIGITADO \n 3-IMPRIME \n 4-SAIR \n");
         scanf("%d",&escolha);
         switch (escolha)
         {
             case 1:printf("Digite um numero a ser colocado na lista \n");
                    scanf("%d",&digite);
                    if(insere_ordenado(&lista,digite)==1)
                       printf("inserido com sucesso!\n");
                    else
                        printf("falhou");
                    break;
             case 2:printf("Digite um numero a ser excluido da lista \n");
                    scanf("%d",&digite);
                    if(exclui(&lista,digite)==1)
                       printf("EXCLUIDO COM SUCESSO!\n");
                    else
                       printf("FALHOU\n");
                    break;
             case 3:imprime(&lista);
                    break;
             case 4:printf("SAINDO\n");
                    system("pause");
                    exit(0);
            default:printf("OPCAO INVALIDA\n");
                    break;
         }                          
       }while(escolha!=0);
    return 0;
}

quinta-feira, 3 de dezembro de 2009

APLICAÇÃO - LISTA CIRCULAR ENCADEADA


Problema de Josephus: Este problema postula um grupo de soldados circundados por uma força inimiga esmagadora. Não há esperanças na vitória sem a chegada de reforços, mas existe somente um cavalo disponível para escapar. Os soldados entram em um acordo para determinar qual deles deverá escapar e trazer ajuda. Eles formam um círculo e um número n é sorteado num chapéu. Um de seus nomes é sorteado também. Começando pelo soldado cujo nome foi sorteado, eles começam a contar ao longo do círculo em sentido horário. Quando a contagem alcança n, esse soldado é retirado do círculo, e a contagem reinicia com o soldado seguinte. O processo continua de maneira que, toda vez que n é alcançado, outro soldado sai do círculo. Todo soldado retirado do círculo não entra mais na contagem. O último soldado que restar deverá montar no cavalo e escapar. Considerando um número n, a ordenação dos soldados no círculo e o soldado a partir da qual começa a contagem, o problema é determinar a seqüência na qual os soldados são eliminados do círculo e o soldado que escapará. A entrada para o programa é o número n, a lista de nomes (devem ser armazenados em uma lista circular encadeada) que será o seqüenciamento do círculo no sentido horário e o nome do soldado onde deve iniciar a contagem. Para indicar o final da entrada de nomes o usuário deve digitar dois pontos (:). O programa deve imprimir os nomes na seqüência em que são eliminados e o nome do soldado que escapará. OBS: Você pode utilizar como nomes para os soldados as letras do alfabeto: soldado A, B, C,  D, etc.


Eu fiz assim:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct circulo
{
  char nome[50];
  struct circulo *prox;
}nodo;
nodo *lista;
void cria_nodo(nodo **aux)
  {
  *aux=(nodo*) malloc(sizeof(nodo));
  }
void insere(nodo **l,char n[50])
{
  nodo *aux,*aux2;
  cria_nodo(&aux);
  strcpy(aux->nome,n);
  aux->prox=NULL;
  if(*l==NULL)
  {
     *l=aux;
  }
  else
  {
     aux2=*l;
     while(aux2->prox!=NULL)
     {
        aux2=aux2->prox;
     }
     aux2->prox=aux;
  }
}
void fim(nodo **l)
{
  nodo *aux;
  aux=*l;
  while(aux->prox!=NULL)
  {
     aux=aux->prox;
  }
  aux->prox=*l;
}

void le()
{
  char nome[50]={"\0"};
  while(nome[0]!=':')
  {
     printf("Digite o nome do soldado: \n");
     gets(nome);
     if(nome[0]!=':')
     {
        insere(&lista,nome);
        nome[0]='\0';
     }
     else
     {
        fim(&lista);
        printf("FIM DA LINHA!\n");
     }
  } 
}
void mata_soldado(nodo **l,int num)
{
  int i;
  nodo *aux,*aux2,*fre;
  aux2=*l;
  aux=aux2->prox;
  while(aux!=aux->prox)
  {
     for(i=1;i<=num;i++)
     {
        if(i==num)
        {
           printf("morreu:");
           puts(aux->nome);
           printf("\n");
           fre=aux;
           aux2->prox=aux->prox;
           aux2=aux2->prox;
           aux=aux->prox;
           aux=aux->prox;
           free(fre);
        }
        else
        {
           aux2=aux;
           aux=aux->prox;
        }
     }
  }
  printf("O soldado sortudo que se salvou foi o %s \n",aux->nome);
  free(aux);
}
int main(int argc, char *argv[])
{
  int n;
  le();
  printf("Digite o número sorteado \n");
  scanf("%d",&n);
  mata_soldado(&lista,n);
  system("PAUSE");   
  return 0;
}




segunda-feira, 16 de novembro de 2009

função que soma duas matrizes esparsas...

void soma(tipo_nodo**l1,tipo_nodo **l2,tipo_nodo **r ,int linhas, int colunas)
{
tipo_nodo *aux1,*aux2;
int l,c,aux;
aux1= *l1;
aux2= *l2;
for(l=0;llin==l && aux1->col==c)//testamos se a posição da matriz que estamos acessando esta na lista
{
if(aux2!=NULL)//se tiver na lista, testamos se existe uma segunda lista caso existir, testamos também se a osição da matriz que estamos acessando esta na segunda lista
{
if(aux2->lin==l && aux2->col==c)
{
aux=aux1->dado + aux2->dado;//fazemos a soma das duas posições
if(aux!=0)
insere(r,aux,l,c);//inserimos numa matriz resposta
aux1=aux1->prox;//toda vez que conseguimos acessar uma posição que tenha na lista, temos que passar para a proxima posição.
aux2=aux2->prox;
}
else//caso a posição da matriz não esteja na segunda lista, consideramos que ela é 0
{
aux=aux1->dado + 0;
insere(r,aux,l,c);
aux1=aux1->prox;
}
}
else
{
aux=aux1->dado + 0;
insere(r,aux,l,c);
aux1=aux1->prox;
}
}
if(aux2!=NULL) //se cair neste if, é porque o primeiro não existe, então somamos a segunda matriz com 0
{
if(aux2->lin==l && aux2->col==c)
{
aux = 0 + aux2->dado;
insere(r,aux,l,c);
aux2=aux2->prox;
}
}

}
else
{
if(aux2!=NULL)
{
if(aux2->lin==l && aux2->col==c)
{
aux = 0 + aux2->dado;
insere(r,aux,l,c);
aux2=aux2->prox;
}
}
}
}
}
}

quarta-feira, 11 de novembro de 2009

função que imprime uma matriz esparsa

void imprime(tipo_nodo **lis,int linhas , int colunas )
{
int l , c ;
tipo_nodo *aux;
aux=*lis;
printf("\n\n\n");
for (l=0;l < linhas;l++)
{
for(c=0;c < colunas;c++)
{
if(aux!=NULL)//este if teve de ser colocado porque se o aux chegar no fim e ele for nulo, ao testar o if abaixo, ele tenta acessar um registro nulo, dando erro de execução
{
if(l==aux- > lin && c==aux- > col)
{
printf("\t %d",aux- > dado);
aux=aux- > prox;
}
else
printf("\t0");//caso não tenha este else, nao aparecem alguns zeros, isso porqueo aux nao é null, entao nao entra no outro if.
}
else
printf("\t0");
}
printf("\n");
}
}

terça-feira, 10 de novembro de 2009

Voltando

E ai galera...

To faz uns dias sem posta nada aqui... mas é por falta de conteúdo mesmo... rsrsrs

bom seguinte... temos um trabalim pra fazer... a tal da matriz esparsa, isso usando uma lista encadeada...
as funções estão meio dificeis de sair, sendo que ta dando muitos erros de execução...

vou postando aqui as funções q eu fiz pra galera da sala ir fazendo ctrl + c , ctrl + v ... rsrsrss

falow

quarta-feira, 21 de outubro de 2009

Codigos

Codigos incompletos...

é o que parece se vc olhar nas postagens... mas o que acontece é que estamos lidando com html, que confunde o codigo do programa com o da formatação da pagina... ai fica parecendo que ta faltando codigo...
Caso alguem tenha uma sugestão... por favor...

Abraços







(Domingo tem atleTIBA)!