1. Este site usa cookies. Ao continuar a usar este site está a concordar com o nosso uso de cookies. Saber Mais.

Trabalho em c - alguem pode-me ajudar?

Discussão em 'Programação' iniciada por S|N, 30 de Abril de 2005. (Respostas: 10; Visualizações: 877)

  1. S|N

    S|N Power Member

    Última edição: 30 de Abril de 2005
  2. S|N

    S|N Power Member

  3. HiGhVoIcE

    HiGhVoIcE Power Member

    ninguem vai fazer isso por ti...
     
  4. S|N

    S|N Power Member

    Não tou a pedir que me façam isto, so tou a pedir que me completem o programa, pq n o consigo completar. hash tables, apontadores.... isto é confuso :S :S
     
  5. HiGhVoIcE

    HiGhVoIcE Power Member

    mete aí o codigo pa eu dar uma vista de olhos...
     
  6. S|N

    S|N Power Member

    #include <stdio.h>
    #include <string.h>
    #define MAX_CHARS 50 /* comprimento máximo de caracteres de um nome */
    #define MAX_PERCURSOS 383 /* 300 percursos no máximo e taxa de ocupação máxima a 80% sugere
    uma tabela com dimensão 375. No entanto, o menor número primo
    maior que 375 é 383 */
    #define MAX_PARAGENS 10
    /*void teste ( int *bla) { *bla = 5 };
    ya
    e pra chamar?
    int main (void) { int a=3; teste(&a); return 0;}*/

    /* * o nome de um percurso é único e efectua-se integralmente no mesmo dia;
    * não existem mais do que 300 percursos;
    * cada percurso tem no máximo 10 paragens;
    * cada nome de percurso ou estação tem no máximo 50 caracteres. */


    typedef struct{
    char nome_percurso[MAX_PERCURSOS][MAX_CHARS];
    char nome_estacao[MAX_PARAGENS][MAX_CHARS];
    mom_paragem paragem[MAX_PARAGENS];
    }percurso;

    typedef struct{
    int horas;
    int minutos;
    }mom_paragem;

    /* ==================================================
    protótipos
    ================================================== */
    void clearHashtable ( percurso table[] );
    void loadHashtable ( FILE *f, percurso table[] );
    int hash ( char s[], int table_size );
    int hashInstall ( char s[], int table_size, char table[][MAX_CHARS] );
    int hashSearch ( char s[], int table_size, char table [][MAX_CHARS] );
    int save2file ( FILE *f, percurso table[] );
    percurso op_inserir_percurso ( void );
    void op_mostrar_percurso (int table_size, char table[][MAX_CHARS], int numbers[] );
    void op_tempo_viagem ( );
    /* ================================================== */

    void main(void)
    carregar_ficheiro();

    do
    {
    printf("\n\n\nO que deseja fazer?\n");
    printf("\t (1)Inserir um novo percurso\n");
    printf("\t (2)Mostrar toda a informação relativa a um percurso\n");
    printf("\t (3)Mostrar o tempo de viagem de um percurso\n");
    printf("\t (4)Sair\n");
    printf("\t>");
    scanf("%d", &comando);

    switch(comando)
    {
    case 1 : op_inserir_percurso(); break;
    case 2 : op_mostrar_percurso(); break;
    case 3 : op_tempo_viagem(); break;
    case 4 : break;
    default: printf("Comando desconhecido\n");
    }
    } while(comando != 4);




    /* inicialização explicita da tabela de dispersão com cadeias de caracteres vazias
    em todas as posições (é a cadeia vazia que determina se determinada posição
    da tabela está ocupada ou não)
    */
    void clearHashtable(percurso table[])
    {
    int i;
    int j; /* MAX_PERCURSOS == MAX_TABLE */
    for (i = 0; i < MAX_PERCURSOS; i++) {
    for ( j = 0 ; j < MAX_PERCURSOS ; j++ ) {
    strcpy( table.nome_percurso[j], "" );
    }
    for ( j = 0 ; j < MAX_PARAGENS ; j++ ) {
    strcpy( table.nome_estacao[j], "" );
    table.paragem[j].horas = 0;
    table.paragem[j].minutos = 0;
    }
    }
    }

    void loadHashtable( FILE *f, percurso table[][MAX_CHARS] )
    {
    char nome[MAX_CHARS];
    int i;
    int position;

    /* leitura a partir do ficheiro ... */
    while (!feof(f)
    {
    fgets ( percurso table, MAX_CHARS+1, f)
    position = hashInstall( nome, MAX_PERCURSOS, table ); /* guarda o nome */
    while
    {
    fgets( nome, MAX_CHARS, f )
    name[strlen(name)-1] = '\0'; /* remove o \n final */
    if ( nome[0] == '*' )
    break
    else
    sscanf ( nome, "%[^#]#%2d%2d\n", percurso.nome_estacao, &paragem.horas, &paragem.minutos );
    }
    }
    }
    int save2file ( FILE *f, percurso table[][MAX_CHARS] )
    {
    int i;
    for( i = 0; i < table[MAX_PERCURSOS]; i++ )
    fprintf( f, "%s#%2d%2d\n", percurso.nome_estacao, &paragem.horas, &paragem.minutos );
    fclose( f );
    }

    /* função de dispersão, tendo em consideração todos os caracteres da cadeia
    Retorna um valor de dispersão no intervalo [0..table_size-1]
    */
    int hash( char s[], int table_size )
    {
    int i, t;
    int n = strlen(s);
    for (i=0, t=0; i < n; i++)
    t += (int) s; /* o "valor" do carácter é o seu código numérico (valor ASCII) */
    return t % table_size;
    }

    /* coloca o nome na tabela de dispersão e retorna essa posição.
    O nome é colocado na 1ª posição livre a partir da posição calculada pela função de dispersão.
    O vector é percorrido circularmente, ou seja, a seguir ao último índice analisa-se o 1º
    pré-condição: existem sempre posições livres
    */
    int hashInstall( char s[], int table_size, char table[][MAX_CHARS] )
    {
    int i;
    for ( i = hash( s, table_size); strlen(table) > 0 ; i = (i+1) % table_size ) ;

    strcpy( table, s );
    return i;
    }

    /* pesquisa um elemento na tabela de dispersão. Se o elemento (cadeia de caracteres)
    estiver na tabela, é devolvida a posição onde se encontra. Caso contrário, devolve -1
    (obs: o zero está a ser utilizado na tabela !)
    */
    int hashSearch( char s[], int table_size, char table [][MAX_CHARS] )
    {
    int i;
    int n = strlen(s);
    printf("\na pesquisar #%s# ... ",s);
    for (i = hash(s, table_size) ; ; i = ( i + 1 ) % table_size)
    {
    printf("\nposicao %d ? ... nessa posicao esta #%s#", i, table);
    if (strlen(table) == 0)
    return -1; /* posição vazia e supostamente estaria nessa posição */
    if (strcmp(table, s) == 0)
    return i; /* encontrou */
    }
    }

    percurso op_inserir_percurso ( void )
    {
    char nome_p[MAX_CHARS];
    char nome_e[][MAX_CHARS];
    int counter = 0;
    int h; /* horas */
    int m; /* minutos */
    int i; /* numero estacoes */
    printf ( "Um nome para o percurso: " );
    scanf ( "%s", nome_p );
    printf ( "Quantas estacoes?" );
    scanf ( "i" );
    while ( i != MAX_ESTACOES && counter != i )
    {
    printf ( "Diga la entao : \n" );
    printf ( "Um nome para a estacao: \n" );
    scanf ( "%s", nome[counter] );
    printf ( "momento de paragem (horas/minutos): " )
    scanf ("%2d%2d", h, m);
    counter++;

    if ( hashSearch ( nome_p[], MAX_PERCURSOS, percurso table [][MAX_CHARS] ) = -1 )
    {
    hashInstall( char nome_p[], int MAX_PERCURSOS, table[][MAX_CHARS] )
    printf ( "\n\n\t\tFeito." );
    return table[][MAX_CHARS];
    break;
    }
    else printf ( "\tTera que tentar outra vez" );
    }
    }

    void op_mostrar_percurso (int table_size, char table[][MAX_CHARS] )
    {
    int i;
    for( i = 0; i < table[MAX_PERCURSOS]; i++ )
    printf( f, "%s#%2d%2d\n", percurso.nome_estacao, &paragem.horas, &paragem.minutos );
    }

    void op_tempo_viagem ( percurso.nome_percurso )
    {
    printf ("insira o nome do precurso\n");
    scanf ( "%s\n" Nome_Percurso); /* variavel por definir*/
    int hashSearch ( Nome_Percurso, MAX_PERCURSOS, table [][MAX_CHARS] ) /* tou a chamar este procedimento que aceita como input a variavel Nome_Precurso que contém o nome do precurso dado pelo utilizador
    e como output as horas e minutos do inicio do precurso, e as horas e minutos do fim do precurso que vão prás variaveis
    H_ini , H_fin , M_ini , M_fin . */
    if M_fin<M_ini
    {H_fin=H_fin-1;
    M_fin=M_fin+60;
    }
    printf ("a duracao da viagem e de:" H_fin-H_ini "horas e" M_fin-M_ini "minutos");
     
  7. S|N

    S|N Power Member

  8. HiGhVoIcE

    HiGhVoIcE Power Member

    primeiro olhar:


























































    printf ( "Diga la entao : \n" );

    Parti-me a rir com isto LOL
     
  9. HiGhVoIcE

    HiGhVoIcE Power Member

    essas funçoes tao uma bela confusão...exemplo de como fazer a inserir percurso...

    uma coisa muito importante: tens que dar nomes pequenos e sucintos pq depois tens um trabalho enorme e complicas bastante a compreensão do codigo...exemplo:
    Código:
    exemplo->blablablablablablabla /* isto n da mt jeito... */
    
    ap->numero /*mais simples e de melhor compreensão */
    
    adiante...

    Código:
    
    typedef struct percur{
      char *nome;
      char *estacao;
      paragem vector[MAX_PARAGENS];
    
      struct percur *next;
    } percurso;
    
    typedef struct{
      int horas;
      int minutos;
    } paragem;
    
    percurso *novo() {
    
      /* inicialização */
    
      percurso *novo;
      char *nome[max_char];
      char *estacao[max_char];
      ...
    
      /* obtençao dos dados */
    
    
      /* guardar os dados */
      
      strcpy(novo->estacao[][], estacao);
      strcpy(novo->nome, nome);
      ...
      return novo;
    }
    
    O meu conselho é criares um vector de 30 posiçoes e pendurares lá listas simplesmente ligadas com o caminho



    Só uma pequena nota:

    Este trabalho é simplesmente MAU!! Tal como está definido, este trabalho é para ser feito com grafos e não com simples vectores/matrizes!! De certeza que arranjavam outra coisa para a aplicação de hash tables e de vetores/matrizes, mas percursos?? no que é que tavam a pensar?? :mad:
     
  10. HiGhVoIcE

    HiGhVoIcE Power Member

    Código:
    typedef struct paragem {
      char *nome;
      int horas;
      int minutos;
    
      estacao *next;
    } estacao;
    
    
    
    int menu(void) {
      int comando;
    
      printf("\n\n\nO que deseja fazer?\n");
      printf("\t (1)Inserir um novo percurso\n");
      printf("\t (2)Mostrar toda a informação relativa a um percurso\n");
      printf("\t (3)Mostrar o tempo de viagem de um percurso\n");
      printf("\t (4)Sair\n");
      printf("\t>");
      scanf("%d", &comando);
    
      return comando;
    }
    
    estacao *novo() {
      estacao *new;
      new = (estacao *) malloc(sizeof(estacao));
      new->nome = (char *) malloc(MAX_NOME*sizeof(char));
    
      return new;
    }
    
    estacao *novo_percurso(void) {
    
      estacao *novo;
      char *nome;
       
    
      ...
    
    
    }
    
    
    int main(void){
    
      int opcao=0;
      int vector[max];
      int n=0;
      
      carregar_ficheiro();
    
      while(opcao != 4) {
        menu;
    
        if (opcao == 1) {
          if (n >= 30) { printf("\nAtingido limite máximo de percursos.\n\n"); }
          else { vector[n] = novo_percurso; n++; }
        }
        if (opcao == 2) {}
        if (opcao == 3) {}
    
    
        if (opcao == 4) { break; }
      }
    
      return 0;
    }
    
    aqui tens uma ajudinha...fikei sem paciencia para o reso... :rolleyes:
     
  11. S|N

    S|N Power Member

    Brigado Highvoice :D
     

Partilhar esta Página