Escreva um algoritmo que leia um número indeterminado de valores inteiros. O valor 0 (zero) finaliza a entrada de dados. Para cada valor lido, determinar se ele é um número par ou ímpar. Se o número for par, então incluí-lo na FILA PAR; caso contrário, incluí-lo na FILA ÍMPAR. Após o término da entrada de dados, retirar um elemento de cada fila alternadamente (iniciando-se pela FILA ÍMPAR) até que ambas as filas estejam vazias. Se o elemento retirado de uma das filas for um valor positivo, então incluí-lo em uma PILHA; caso contrário, remover um elemento da PILHA. Finalmente, escrever o conteúdo da pilha.
Passo 1
Entender o que o enunciado pede: ler uma sequência de inteiros terminada em 0, classificar cada valor em fila par ou ímpar, depois consumir essas filas alternadamente (começando pela ímpar) e usar os valores retirados para empilhar (se positivo) ou desempilhar (se não positivo), entregando ao final o conteúdo da pilha.
Passo 2
Identificar que vamos precisar de três estruturas: uma FILA PARA números pares, uma FILA PARA números ímpares e uma PILHA.
Passo 3
Montar a fase de leitura e classificação: um laço que lê valores enquanto o número for diferente de zero; em cada iteração, usarmos o operador módulo para decidir se é par (resto zero) ou ímpar (resto diferente de zero) e, em seguida, enfileirar no local adequado.
Passo 4
Projetar a fase de esvaziamento: usar uma variável de controle (por exemplo, um booleano ou string) que indica qual fila deve ser atendida na iteração (começando por ímpar). Enquanto pelo menos uma das filas não estiver vazia, alternamos a fila de onde retiramos.
Passo 5
Para cada valor retirado da fila escolhida, testar se é positivo. Se for, empilhar esse valor. Caso contrário (zero ou negativo), tentar desempilhar um elemento da pilha (verificando antes se não está vazia). Depois disso, alternar o controle para a outra fila na próxima iteração.
Passo 6
Ao final desse processo, teremos o conteúdo final da pilha. Basta então percorrê-la (por exemplo, desempilhando tudo ou iterando do topo ao fundo) para exibir os elementos na tela.
Resposta
Algoritmo GerenciaFilasEPilha
// Inicialização
criar filaPar vazia
criar filaImpar vazia
criar pilha vazia
// Inicialização
criar filaPar vazia
criar filaImpar vazia
criar pilha vazia
// Fase 1: Leitura e classificação
repetir
escrever("Digite um inteiro (0 para terminar): ")
ler n
se n = 0 então
pare
fim se
se n % 2 = 0 então
enfileirar(filaPar, n)
senão
enfileirar(filaImpar, n)
fim se
até falso
// Fase 2: Processamento alternado
definir vez = "impar"
enquanto não vazia(filaPar) ou não vazia(filaImpar) faça
se vez = "impar" e não vazia(filaImpar) então
x ← desenfileirar(filaImpar)
senão se vez = "par" e não vazia(filaPar) então
x ← desenfileirar(filaPar)
senão se não vazia(filaImpar) então
x ← desenfileirar(filaImpar)
senão
x ← desenfileirar(filaPar)
fim se
se x > 0 então
empilhar(pilha, x)
senão
se não vazia(pilha) então
desempilhar(pilha)
fim se
fim se
// alterna vez para a próxima iteração
se vez = "impar" então
vez ← "par"
senão
vez ← "impar"
fim se
fim enquanto
// Fase 3: Impressão da pilha
escrever("Conteúdo da pilha (do topo para o fundo):")
enquanto não vazia(pilha) faça
y ← desempilhar(pilha)
escrever(y)
fim enquanto
Fimalgoritmo