• Revista PROGRAMAR: Já está disponível a edição #53 da revista programar. Faz já o download aqui!

GlobalDot

Pff Ajudem-me! Estruturas dinâmicas:Pilhas de arrumação

8 mensagens neste tópico

Boa Tarde. Tenho um projecto a realizar! Alguem que me ajude sff.

O Projecto é:

Introdução.

Para optimizar a arrumação de caixotes num armazém, mantendo as condições de segurança e de estabilidade das pilhas de caixotes, procura-se implementar um programa capaz de guardar a localização dos caixotes, assim como indicar se um determinado caixote pode ser arrumado e em que pilha.

Na constituição de cada pilha existem regras que é necessário atender:

• Nenhum caixote pode ficar em cima de outro tenha uma base inferior;

• O peso dos caixotes que estão por cima de um dado caixote não pode ultrapassar o valor máximo suportado por ele;

• A altura total da pilha não pode ultrapassar a altura máxima convencionada para as pilhas (que é de 6,5m).

Quanto à dimensão dos caixotes, que são de cúbicos (ou seja, com altura, largura e comprimento iguais), existem três tipos: de 50cm, 75cm e de 100cm de lado. Em relação ao seu peso e ao peso máximo suportado, não existindo qualquer padrão, situam-se entre os 10Kg e 60Kg de peso e os 150Kg e 200Kg de peso máximo suportado.

Quanto às pilhas, existem, no máximo, 2 para arrumar caixotes e uma outra pilha auxiliar que só pode ser usada quando se está a retirar caixotes ou a reorganizar as pilhas.

Em memória deve ser implementada uma estrutura de dados baseada em listas ligadas de manipulação em pilha, obedecendo ao seguinte

Os dados da estrutura de memória são:

Caixote

Número de série do caixote

Número da pilha em que está

Lado

Peso

Peso suportado

Note que o número da pilha deve ser alterado sempre que o caixote mude de pilha.

Objectivo do trabalho.

Pretende-se que seja implementado um programa que permita criar e manipular os dados referentes a um sistema de gestão de arrumação de caixotes.

Desenvolvimento.

Crie a estrutura de dados capaz de guardar em memória a informação descrita acima, bem como para a aceder e a manipular.

1. Adicionar caixotes (respeitando as regras descritas acima) – os dados sobre o caixote são introduzidos pelo utilizador e depois de validados, o caixote é arrumado na primeira pilha que respeite as regras, preenchendo-se nessa altura o campo com o número do pilha onde foi arrumado.

No caso de não ser possível arrumar o caixote, deverá surgir um aviso ao utilizador

2. Remover caixotes (sabendo o seu número de série) – o número de série do caixote é pedido ao utilizador, e depois de se verificar se o caixote existe nalguma das pilhas, esse caixote é retirado, respeitando as regras.

No caso de não ser possível retirar o caixote ou de ele não existir, deverá surgir um aviso ao utilizador.

3. Mostrar a constituição de cada uma das pilhas – é pedido o número da pilha a listar (1, 2 ou 0 para visualizar as duas pilhas) e depois é mostrado o número de série dos caixotes aí arrumados.

4. Mostrar a localização e características de um caixote – é pedido o número de série do caixote e depois de se verificar que existe é mostrado em que pilha e em que posição é que ele se encontra nessa pilha, assim como todas as suas características.

5. Reorganizar as pilhas – nesta opção pretende-se optimizar a arrumação dos caixotes, ou seja, os caixotes de maior base e os que suportam mais peso devem ficar arrumados no fundo da pilha. No entanto, neste processo de reorganização, as regras mencionadas na Introdução deste enunciado têm, igualmente, de ser respeitadas.

Isto foi o que fiz:

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

struct tagCaixa
{
int nSerie;
int Num_pilha;
int lado;
int peso;
int peso_sup;
struct tagCaixa* pNext;
};

void menu ();
int main (void)
{
struct tagCaixa *pilha1, *pilha2, *pHead;
int opc, peso, lado, pSuporte, nSerie=0;
struct tagCaixa box;
struct tagCaixa* pBottom1;
struct tagCaixa* pNew;

do{

menu();
printf("Escolha a opcao que pretende efectuar:\n");
scanf("%d", &opc);

switch(opc)
{

case 1:
printf ("Introduza o lado [50, 75 ou 100]: ");
scanf("%d", &lado);

if (lado == 50 || lado == 75 || lado == 100)
{
  printf ("Introduza o peso [entre 10 e 60kg]: ");
  scanf ("%d", &peso);
}
else
  printf ("O Lado dos Caixote esta incorrecto!\n\n");
break;

  if (peso>=10 && peso<=60) 
  {
   printf ("Introduza o maximo peso suportado pelo o caixote [entre 150 e 200]: ", pSuporte);
   scanf ("%d", &pSuporte);
  }
  else
   printf ("O Peso do Caixote esta incorrecto!\n\n");
  break;

   if (pSuporte>=150 && pSuporte<=200)
   {
    nSerie++;
    printf ("O Numero de Serie do Novo Caixote e *\%d/*\a\n\n\n", nSerie);
   }
   else
    printf ("O Peso Suportado pelo o Caixote esta incorrecto\n\n");
   break;

pNew = (struct tagCaixa*) malloc (sizeof(struct tagCaixa));
if (pBottom1==NULL)
{
  pBottom1=pNew;
  pBottom1->pNext=pNew;
}
pNew -> lado = lado;
pNew -> peso = peso;
pNew -> peso_sup = pSuporte;
pNew -> nSerie = nSerie;
pNew -> pNext = pNew;

break;

case 2:
printf("Introduza o Numero de Serie do caixote que deseja Remover:\n");
scanf ("%c", &opc); 
box.nSerie++;
box.nSerie;
free(box);

break;

case 3:

break;

case 4:

break;
case 5:
break;

default:
  printf("Opcao invalida!!!");
}
}while (opc !=0);

return 0;
}

void menu ()
{
printf("---------------------MENU----------------------\n");
printf("|          1 -> Adicionar caixotes            |\n");
printf("|          2 -> Remover caixotes              |\n");
printf("|          3 -> Constituicco de cada pilha    |\n");
printf("|          4 -> Reorganizar as Pilhas         |\n");
printf("|          5 -> Sair                          |\n");
printf("-----------------------------------------------\n");
}

0

Partilhar esta mensagem


Link para a mensagem
Partilhar noutros sites

Acho que vais ter mais sucesso se disseres explicitamente qual é a tua dúvida ou onde está o erro. É que nem qualquer um tem paciência para ler esse texto todo. Já agora usa o GeSHi para identar o código. :P

0

Partilhar esta mensagem


Link para a mensagem
Partilhar noutros sites

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

struct tagCaixa
{
int nSerie;
int Num_pilha;
int lado;
int peso;
int peso_sup;
struct tagCaixa* pNext;
};

void menu ();
int main (void)
{
struct tagCaixa *pilha1, *pilha2, *pHead;
int opc, peso, lado, pSuporte, nSerie=0;
struct tagCaixa box;
struct tagCaixa* pBottom1;
struct tagCaixa* pNew;

do{

menu();
printf("Escolha a opcao que pretende efectuar:\n");
scanf("%d", &opc);

switch(opc)
{

case 1:
printf ("Introduza o lado [50, 75 ou 100]: ");
scanf("%d", &lado);

if (lado == 50 || lado == 75 || lado == 100)
{
  printf ("Introduza o peso [entre 10 e 60kg]: ");
  scanf ("%d", &peso);
}
else
  printf ("O Lado dos Caixote esta incorrecto!\n\n");
break;

  if (peso>=10 && peso<=60) 
  {
   printf ("Introduza o maximo peso suportado pelo o caixote [entre 150 e 200]: ", pSuporte);
   scanf ("%d", &pSuporte);
  }
  else
   printf ("O Peso do Caixote esta incorrecto!\n\n");
  break;

   if (pSuporte>=150 && pSuporte<=200)
   {
    nSerie++;
    printf ("O Numero de Serie do Novo Caixote e *\%d/*\a\n\n\n", nSerie);
   }
   else
    printf ("O Peso Suportado pelo o Caixote esta incorrecto\n\n");
   break;

pNew = (struct tagCaixa*) malloc (sizeof(struct tagCaixa));
if (pBottom1==NULL)
{
  pBottom1=pNew;
  pBottom1->pNext=pNew;
}
pNew -> lado = lado;
pNew -> peso = peso;
pNew -> peso_sup = pSuporte;
pNew -> nSerie = nSerie;
pNew -> pNext = pNew;

break;

case 2:
printf("Introduza o Numero de Serie do caixote que deseja Remover:\n");
scanf ("%c", &opc); 
box.nSerie++;
box.nSerie;
free(box);

break;

case 3:

break;

case 4:

break;
case 5:
break;

default:
  printf("Opcao invalida!!!");
}
}while (opc !=0);

return 0;
}

void menu ()
{
printf("---------------------MENU----------------------\n");
printf("|          1 -> Adicionar caixotes            |\n");
printf("|          2 -> Remover caixotes              |\n");
printf("|          3 -> Constituicco de cada pilha    |\n");
printf("|          4 -> Reorganizar as Pilhas         |\n");
printf("|          5 -> Sair                          |\n");
printf("-----------------------------------------------\n");
}

No case um tenho que ver se a caixa debaixo suporta o peso e tmb tenho que ver se a pilha esta cheia.

No case dois nao sei como fazer!!

Os outros ainda nao pensei!

0

Partilhar esta mensagem


Link para a mensagem
Partilhar noutros sites

Ora bem, isto parece-me uma variante das Torres de Hanoi onde existe mais do que uma variável. Enquanto que nas torres de Hanoi tu só podes colocar um disco sobre outro maior, aqui além da dimensão tens o peso. Não me parece que a solução recursiva normalmente utilizada nas torres de hanoi resolva, mas julgo que se pesquisares encontras uma solução possível de adaptar ao teu problema.

0

Partilhar esta mensagem


Link para a mensagem
Partilhar noutros sites

Este é o terceiro tópico que encontro com o mesmo título. Usem-no para continuar a discusão, os outros serão apagados.

0

Partilhar esta mensagem


Link para a mensagem
Partilhar noutros sites

pois mas a um problema so aprendi ate o malloc!!!

o k é aprender ate o malloc?

0

Partilhar esta mensagem


Link para a mensagem
Partilhar noutros sites

pois mas a um problema so aprendi ate o malloc!!!

o k é aprender ate o malloc?

Devia ter sido no livro que ele se guiou ou nas aulas dele...

PS: Convém olhar para as datas antes de responder a um tópico de 4 meses... :thumbsup:

0

Partilhar esta mensagem


Link para a mensagem
Partilhar noutros sites

Crie uma conta ou ligue-se para comentar

Só membros podem comentar

Criar nova conta

Registe para ter uma conta na nossa comunidade. É fácil!


Registar nova conta

Entra

Já tem conta? Inicie sessão aqui.


Entrar Agora