Considere que um Técnico Programador escreveu um programa pa...
Uma pilha é uma estrutura de dados que admite remoção de elementos e inserção de novos objetos. Mais especificamente, uma pilha (= stack) é uma estrutura sujeita à seguinte regra de operação: sempre que houver uma remoção, o elemento removido é o que está na estrutura há menos tempo.
Em outras palavras, o primeiro objeto a ser inserido na pilha é o último a ser removido. Essa política é conhecida pela sigla LIFO (= Last-In-First-Out).
Fonte: https://www.ime.usp.br/~pf/algoritmos/aulas/pilha.html
Inserindo na pilha os digitos de um número e retirando em seguida vou ter o numero invertido, mas não entendi para que serve essa parte:
" multiplicados pelo valor posicional correto e somados "
O algoritmo faz uso de uma pilha (stack) sim, mas não basta retirar os valores a partir do topo da pilha pois o resultado esperado é um número inteiro e não uma string (de dígitos) invertida. É uma questão complexa! Vou colocar o algoritmo (Java) para que possamos entender melhor isso.
// Java program to reverse the number
// using a stack
import java.util.Stack;
public class GFG
{
// Stack to maintain order of digits
static Stack st= new Stack<>();
// Function to push digits into stack
static void push_digits(int number)
{
while(number != 0)
{
st.push(number % 10);
number = number / 10;
}
}
// Function to reverse the number
static int reverse_number(int number)
{
// Function call to push number's
// digits to stack
push_digits(number);
int reverse = 0;
int i = 1;
// Popping the digits and forming
// the reversed number
while (!st.isEmpty())
{
reverse = reverse + (st.peek() * i);
st.pop();
i = i * 10;
}
// Return the reversed number formed
return reverse;
}
// Driver program to test above function
public static void main(String[] args)
{
int number = 39997;
System.out.println(reverse_number(number));
}
}
A parte da questão que diz: "multiplicados pelo valor posicional correto e somados, obtendo-se o número invertido" é vista no algoritmo dentro do while: reverse = reverse + (st.peek() * i);
Pilha = LIFO -> Last in, first out (último a entrar, primeiro a sair)
Fila = FIFO -> Fisrt in, first out (primeiro a entrar, primeiro a sair)
Vamos utilizar um número com apenas 03 dígitos para simplificar
Para se inverter o um número, primeiramente armazena-se este em uma pilha: ex: 123456 armazenado dígito a dígito fica 1,2,3
Como na pilha o último a entrar é o primeiro a sair, a ordem de retirada será 3,2,1
Multiplicar pelo valor posicional significa multiplicar o dígito das centenas por 100, das dezenas por 10 e das unidades por 1:
3*100+2*10+1*1 = 321
Portanto a estrutura deve ser uma pilha, alternativa C
Força Guerreiro!!!!!!