Trabalho em c - alguem pode-me ajudar?

S|N · 30 de Abril de 2005

O código está quase completo. As estruturas estão feitas... So faltam os procedimentos para inserir percurso, escrever a info de um percurso e mostrar o tempo de viagem de um percurso. Nao usei apontadores, mas ficava muito grato se alguem me conseguisse por aquilo a funcionar com apontadores.

O inunciado está aqui: http://ctp.di.fct.unl.pt/~alopes/aed/Trabalhos.htm#trab2
Estou desesperado!

O meu mail é : [email protected] HELP please!

S|N · 1 de Maio de 2005

*bumps*

HiGhVoIcE · 1 de Maio de 2005

ninguem vai fazer isso por ti...

S|N · 1 de Maio de 2005

HiGhVoIcE disse:
ninguem vai fazer isso por ti...

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

HiGhVoIcE · 1 de Maio de 2005

mete aí o codigo pa eu dar uma vista de olhos...

S|N · 1 de Maio de 2005

#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");

S|N · 1 de Maio de 2005

Brigado

HiGhVoIcE · 1 de Maio de 2005

primeiro olhar:

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

Parti-me a rir com isto LOL

HiGhVoIcE · 1 de Maio de 2005

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:

HiGhVoIcE · 1 de Maio de 2005

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:

S|N · 1 de Maio de 2005

Brigado Highvoice

Trabalho em c - alguem pode-me ajudar?

S|N

Power Member

S|N

Power Member

HiGhVoIcE

Power Member

S|N

Power Member

HiGhVoIcE

Power Member

S|N

Power Member

S|N

Power Member

HiGhVoIcE

Power Member

HiGhVoIcE

Power Member

HiGhVoIcE

Power Member

S|N

Power Member