problema com programa de trafego aéreo em c

[RAFAEL BARRETO]

O objetivo deste trabalho é simular os padrões de aterrissagem e decolagem em um

aeroporto. Suponha um aeroporto que possui três pistas, numeradas como 1, 2 e 3. Existe uma

“prateleiras" de espera para aterrissagem, e uma para decolagem.

A cada unidade de tempo, de zero a três aeronaves podem chegar nas filas de decolagem e

de zero a três aeronaves podem chegar nas prateleiras. A cada unidade de tempo, cada pista pode

ser usada para um pouso ou uma decolagem. A prioridade, inicialmente, é para aterrissagem.

Utilize inteiros pares sucessivos de ID dos aviões chegando na fila de decolagem e ímpares

para a filas d aterrissagem. A cada unidade de tempo, assuma que os aviões entram nas filas antes

que aterrissagens ou decolagens ocorram. Projete um algoritmo que não permita o crescimento

excessivo das filas de aterrissagem ou decolagem. Coloque os aviões sempre no final das filas.

A saída do programa deverá indicar o que ocorre a cada unidade de tempo. Periodicamente

imprima:

a) o conteúdo de cada fila;

os aviões que estão decolando/aterrissando em cada uma das 3 pistas;

Obs.: A entrada deve ser criada utilizando-se um gerador de números aleatórios.

typedef struct {

int aviao;

}tipoitem;

typedef struct{

tipoitem itens [maxtam];

int inicio, fim;

}tipopista;

void pista_vazia (tipopista *pista)

{

pista->inicio=0;

pista->fim=0;

}

int pistavazia (tipopista pista)

{

return (pista.inicio==pista.fim);

}

void enfileira_aviao_para_pousar (tipopista *pista, tipoitem dados)

{

pista->itens[pista->fim]=dados;

pista->fim++;

}

void imprime_pista (tipopista pistax)

{

int i;

printf ("\n\n\n\t\t\t ___________________________");

printf ("\n\t\t\t|______ PISTA DE POUSO______| \n ");

for (i=pistax.inicio; i<pistax.fim; i++)

printf (" %d - ", pistax.itens.aviao);

}

int pouso ( tipopista *pista,int pos, tipoitem *dados)

{

int aux;

*dados = pista->itens[pos];

for (aux=pos; aux<pista->fim; aux++)

pista->itens[aux-1]=pista->itens[aux];

pista->fim--;

}

int numeros_de_pouso ( tipopista pista)

{

return (pista.fim);

}

// PISTA DO AEROPORTO PARA DECOLAGEM

typedef struct{

int avioes;

}tipoaeroporto;

typedef struct {

tipoaeroporto item [tamanho];

int primeiro, ultimo;

}tipopistadedecolagem;

void faz_pista_de_decolagem (tipopistadedecolagem *lista)

{

lista->primeiro=0;

lista->ultimo=0;

}

int pista_de_decolagem (tipopistadedecolagem lista)

{

return (lista.primeiro==lista.ultimo);

}

void avioes_para_decolagem (tipopistadedecolagem *lista, tipoaeroporto info)

{

lista->item[lista->ultimo]=info;

lista->ultimo++;

}

void imprime_decolagem (tipopistadedecolagem listay)

{

int j;

printf ("\n\n\n\t\t\t ___________________________");

printf ("\n\t\t\t|_____PISTA DE DECOLAGEM____| \n ");

for (j=listay.primeiro; j<listay.ultimo; j++)

printf (" %d - ", listay.item[j].avioes);

}

int pista_de_decolagem ( tipopistadedecolagem *lista, int posicao, tipoaeroporto *info)

{

int aux2;

*info = lista->item[posicao];

for (aux2=posicao; aux2<lista->ultimo; aux2++)

lista->item[aux2-1]=lista->item[aux2];

lista->ultimo--;

}

int numeros_de_decolagem (tipopistadedecolagem lista)

{

return (lista.ultimo);

}

int main(int argc, char *argv[])

{

tipoitem pista;

tipopista pistas;

tipoaeroporto decola;

tipopistadedecolagem decolagem;

int op,x,pos=0,posicao=0;

int conta_decolagem_na_pista_um=0, conta_decolagem_na_pista_dois=0;

int pista_um, pista_dois,pista_tres;

faz_pista_de_decolagem (&decolagem);

pista_vazia (&pistas);

srand ((unsigned )time(NULL));

while (op!=-1)

{

system ("cls");

printf ("\n\t\t\t###############################");

printf ("\n\t\t\t# CONTROLE DE TRAFEGO AEREO #");

printf ("\n\t\t\t###############################");

printf ("\n\t\t ____________________________________________");

printf ("\n\t\t| TECLE 1 PARA CONTINUAR OU -1 PARA SAIR |");

printf ("\n\t\t|_________________________________________ ___|\n");

printf ("\n\n\n\n\t\t\t\t SUA OPCAO --------> ");

scanf ("%d", &op);

system ("cls");

switch (op)

{

case 1:

while ((x=rand())>3);

if (x%2==1)

{

pista.aviao=x;

enfileira_aviao_para_pousar(&pistas, pista);

}

if (x%2==0)

{

decola.avioes=x;

avioes_para_decolagem (&decolagem, decola);

}

pista_um ;

imprime_decolagem (decolagem);

imprime_pista (pistas);

printf ("\n\n\n\n\n %d ", x);

printf ("\n\n %d DECOLAGEM NA PISTA UM ", conta_decolagem_na_pista_um);

printf ("\n\n %d DECOLAGEM NA PISTA DOIS ", conta_decolagem_na_pista_dois);

break;

}

getch();

}

}

minha duvida é em como saber se as pistas estão vazia ou não...

como fazer as condições para aterrizar, ou pousar nas pistas vazias...

quem puder dar uma ideia agradeço...

abraços

[nickarcos]

Amigo, você conseguiu concluir o código? Pois eu necessito desse código funcionando.

Agradeço colaboração de quem puder ajudar.

[Josemar Guia]

ola tudo bom preciso de saber de chegaste de conseguir a solução para algoritmo?

 

[Boko Moko]

acho que devemos começar pelo algoritmo genérico e depois implementar.

Primeiro, uma rotina para gerar novos aviões. Ela vai gerar de 0 a 3 números pares. É a fila de pouso.

Em seguida ela enfileira cada um desses aviões numa pista para pouso. Para isso é preciso fazer um "round robin". Como são 3 pistas, numere-as de 1 a 3 (1, 2 e 3). Então se aparecerem 2 aviões para pousar, a terceira pista fica livre para decolagem.

 

Quando terminar os pousos (ou seja, vai tirando da fila de pousos para 1,2,3, depois 1,2,3 de novo e assim por diante ou seja, (x-1) %3 + 1;

 

 

Adicione aviões a fila de decolagem, agora com números ímpares. Tira quantos aviões da fila quantas forem as pistas disponíveis e depois volta para a primeira pista.

 

Quando a fila de pousos ficar vazia, está na hora de tratar a fila de decolagens. Ou seja, vai tirando de