SóProvas


ID
2607436
Banca
FCC
Órgão
DPE-AM
Ano
2018
Provas
Disciplina
Algoritmos e Estrutura de Dados
Assuntos

Considere que um Técnico Programador escreveu um programa para ler um número inteiro de 6 dígitos. Após ler o número e se certificar que o mesmo possuía 6 dígitos, os dígitos foram separados. Em seguida, cada um dos dígitos d1, d2, d3, d4, d5 e d6 foram inseridos em uma estrutura de dados. Depois foram retirados um a um da estrutura, multiplicados pelo valor posicional correto e somados, obtendo-se o número invertido. Caso o número de entrada fosse 123456 o resultado seria 654321. A estrutura de dados utilizada foi

Alternativas
Comentários
  • 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!!!!!!