Mundo dos Blocos - Pilha em C

[anderson.moura]

Tenho que fazer um exercício onde inicialmente vou ter n elementos (inserido pelo usuário). O número de elementos vai ser a quantidade de blocos existentes. Se n=5, então tenho os blocos 0, 1, 2, 3, 4.

Primeira dúvida: Se tenho 5 elementos, e posso tirar qualquer uma da sua posição e colocar em qualquer outra posição, então não vou ter uma pilha e sim 5 pilhas???

Segunda dúvida: Já pesquisei muito no pai google, livros, mas não vi nada parecido. Todos os exemplos de pilha que vi, têm-se uma pilha onde se é inserido um elemento ou retirado, ou seja, pega-se apenas o elemento que vai ser inserido e no caso de retirado, sempre o topo da pilha. Meu problema é que tenho que definir o elemento que vou mover e a pilha de referência.

EX:

mover a acima b, onde a=2 e b=0.

mover a acima b, onde a=1 e b=3.

então a saída seria: 2 1

0**3 4

* = espaço vazio.

Então não, sei como fazer essa referência, definir em qual pilha vou jogar o bloco a ser movido, como no exemplo onde o bloco 2 foi movido para cima do bloco 0 na pilha 0 e o bloco 1 foi movido para cima do bloco 3 na pilha 3 e as pilhas 1 e 2 ficaram vazias.

Segue o código que já consegui fazer...

/*Faça um programa que leia um arquivo de entrada, execute todos os
*comandos presentes nesse arquivo e gere um arquivo de saída, no formato
*definido anteriormente no desafio.
*/

/* Definições de movimento:
*Os comandos válidos para o braço de robô manipular os blocos são listados
*a seguir. Usa-se a para indicar o bloco em movimento a e b como bloco de
*referência.
*Mover a acima b: move o bloco a para cima do bloco b retornando
*eventuais blocos que já estiverem sobre a ou b para as suas posições
*originais.
*Mover a topo b: coloca o bloco a no topo do monte onde está o bloco b
*retornando eventuais blocos que já estiverem sobre a às suas posições
*originais.
*Empilhar a acima b: coloca o bloco a juntamente com todos os blocos que
*estiverem sobre ele em cima do bloco b, retornando eventuais blocos que
*já estiverem sobre b as suas posições originais.
*Empilhar a topo b: coloca o bloco a juntamente com todos os blocos que
*estiverem sobre ele no topo do monte onde está o bloco b.
*Encontrar maior: encontra o maior elemento da pilha mais alta e o
*devolve para a posição inicial.
*Sair: termina a execução.
*Qualquer comando no qual a = b ou no qual a e b estejam na mesma pilha
*de blocos é um comando ilegal e deve ser ignorado, não alterando a
*configuração dos blocos.
*RESTRIÇÃO:
*Qualquer comando no qual  a = b ou no qual  a e b estejam na mesma pilha 
*de   blocos   é   um   comando   ilegal   e   deve   ser   ignorado,   não   alterando   a 
*configuração dos blocos.          
*/

#include<stdio.h>
#include<stdlib.h>
#define MAX 5

struct pilha{
       int entrada[MAX]; // numero de blocos
       int mover_acima[1];
       int mover_topo[1];
       int empilhar_acima[1];
       int empilhar_topo[1];
       int encontrar_maior[1]; 
       int topo;
       int temp[MAX];     
       }modificar;

// Funções necessárias para o desafio.

int func_mover_acima();
int func_mover_topo();
int func_empilhar_acima();
int func_empilhar_topo();
int func_inicializa_pilha();
bool func_pilha_vazia();
int func_sair();
int func_menu();

//Inicio do programa.
int main(void)  {
    printf("DESAFIO: MUNDO DOS BLOCOS\n");
    func_menu();
}
//Fim do programa.

int func_menu()       {
     int op;
     printf("\nEscolha o item desejado.\n\n");
     printf("1 - Mover 'a' acima 'b'\n");
     printf("2 - Mover 'a' topo 'b'\n");
     printf("3 - Empilhar 'a' acima 'b'\n");
     printf("4 - Empilhar 'a' topo 'b'\n");
     printf("5 - Encontrar maior\n");
     printf("6 - Sair\n");

     printf("\nItem escolhido: ");
     scanf("%d", &op);

     switch (op) {
            case 1:
                 system("cls");   
                 func_mover_acima();
                 getchar();
                 getchar();
                 break;
            case 2:
                 system("cls");   
                 func_mover_topo();
                 getchar();
                 getchar();
                 break;
            case 3:
                 system("cls");   
                 func_empilhar_acima();
                 getchar();
                 getchar();
                 break;
            case 4:
                 system("cls");   
                 func_empilhar_topo();
                 getchar();
                 getchar();
                 break;
            case 5:
                 printf("Funcao não implementada!!\n");
                 printf("Pressione qualquer tecla para sair");
                 getchar();
                 getchar();
                 break;
            case 6:
                 func_sair();
                 break;
            default:
                 printf("Opcao invalida");
                 }
}


int func_inicializa_pilha()      {
     modificar.topo = -1;
}  

bool func_pilha_vazia()    {
      if(modificar.topo == -1 )  
         return true;  
     else 
         return false;          
} 

int func_mover_acima(){
    int x=0, y=0;
    printf("Mover 'a' acima 'b'\n\n");
    printf("Informe o bloco a ser movimentado: \n");
    for (;x<MAX;x++){
    scanf("%d", modificar.mover_acima[x]);          // guarda bloco a ser movimentado
     if ((x >= 0 and x < MAX)) {
        printf("Informe o bloco de referencia: \n");
        scanf("%d", modificar.mover_acima[y]);        // guarda bloco de referência
          if ((y >=0 and y < MAX)) {
                 if (x==y)  {
                    printf("Blocos são iguai ou estao na mesma pilha\n");
                    printf("Nenhum alteracao será efetuada nos blocos\n");
                    printf("Pressione qualquer tecla para continuar");
                    getchar();
                    }
                  else {
                       printf("Código para empilhar a acima b aqui");
                       }
                       } 
                       } 
                       }

}   



int func_mover_topo(){
    printf("código aqui");
}
int func_empilhar_acima(){
    printf("código aqui");
}
int func_empilhar_topo(){
    printf("código aqui");
}
int func_sair(){
    printf("código aqui");
}




[/CODEBOX]

[Risadão]

Bom dia anderson. Desculpe mas não intendi direito o que você tem que fazer. Só uma coisa: você tem 5 elementos e deve move-los, como você disse, vai ter os blocos 0, 1, 2, 3 e 4. você quer por exemplo pegar o elemento da posição 1 e colocar na posição 3 é isso? Se for isso você não pode usar LISTA? Com lista você consegue isso facilmente implementando algumas funções utilizando ponteiros. Eu já fiz um braço robótico tb mas o meu era controlado pelo pc através da porta paralela e ele possuia movimentos pan tilt e uma "garra" de eletroímã. Também programei em C++ pelo DEV. Desculpe se não ajudei em nada mas... ficou meio confuso o que você quer fazer. Até mais...

[anderson.moura]

Agradeço a ajuda....

Tentando explicar melhor... Preciso fazer isso em forma de pilha e ao invés de inicializar as pilhas normalmente com -1 para informar que está vazia, já devo inicializar as pilhas com blocos indo de 0 a 5 e por exemplo, mover o bloco 1 que vai estar na pilha 1, para cima do bloco 3 que vai estar na pilha três...

Abaixo segue o enunciado completo... Se puder olhar e ajudar, agradeço... =)

http://codepad.org/zlv7Rjbc