Exercícios de estruturas de dados com respostas

Resposta: B. Um bom programa combina a estrutura de dados certa com o algoritmo certo, pensando em como se comporta quando os dados crescem.

O avançado é sobre projetar: escolher onde e como os dados moram (estrutura) e o passo a passo que age sobre eles (algoritmo), de modo que o programa continue rápido e claro mesmo com muitos dados. Resposta certa é só o ponto de partida.

Estudar a aula: O salto para o avançado: de resolver a projetar

Resposta: B. As operações que a estrutura oferece e como elas se comportam, sem fixar como isso é implementado.

O TAD é um contrato: descreve quais operações existem e como elas se comportam, o que a estrutura faz. Ele deixa de fora o como, ou seja, a implementação. Por isso a mesma interface pode ter várias implementações válidas por dentro.

Estudar a aula: Tipo abstrato de dados: o contrato antes do código

Resposta: B. A estrutura de dados guarda e organiza a informação; o algoritmo é o passo a passo que age sobre ela.

A estrutura de dados responde a pergunta onde e como os dados ficam guardados (pilha, fila, árvore, grafo). O algoritmo responde como agir sobre eles (buscar, ordenar, percorrer). As duas famílias se combinam: cada problema pede a dupla certa.

Estudar a aula: O mapa do avançado: estruturas guardam, algoritmos agem

Resposta: B. O último item a entrar é o primeiro a sair, e só o topo é acessível.

A pilha segue a regra LIFO: o último a entrar é o primeiro a sair. E ela só permite mexer no topo. Retirada de qualquer posição é comportamento de lista, e ordem alfabética não tem nada a ver com a estrutura pilha.

Estudar a aula: O que é uma pilha (LIFO)

Resposta: B. Desempilhar retira o item do topo e altera a pilha; espiar apenas consulta o topo sem removê-lo.

Desempilhar remove o item do topo e o devolve, deixando a pilha com um item a menos. Espiar o topo só mostra quem está por cima, sem alterar a pilha. As duas olham o topo, mas só o desempilhar modifica a estrutura.

Estudar a aula: Empilhar, desempilhar e espiar o topo

Resposta: B. Porque desfazer deve reverter a última ação feita, que é justamente a que está no topo da pilha.

Desfazer sempre reverte a ação mais recente, a última que você fez. Numa pilha, a última ação empilhada está no topo e é a primeira a sair. Por isso a regra LIFO casa perfeitamente com o desfazer, revertendo do mais recente ao mais antigo.

Estudar a aula: A pilha de chamadas e o botão desfazer

Resposta: B. A checagem final, que exige que a pilha esteja vazia; como sobraram dois abre, ela devolve falso.

Em ((, os dois parênteses de abertura são empilhados e nunca há um fechamento para desempilhá-los. Ao fim do laço, a pilha ainda tem dois itens. A checagem final retorne vazia(pilha) percebe que a pilha não está vazia e devolve falso, marcando a expressão como desbalanceada.

Estudar a aula: Parênteses balanceados com uma pilha

Resposta: B. Que o primeiro elemento a entrar é o primeiro a sair, preservando a ordem de chegada.

FIFO quer dizer primeiro a entrar, primeiro a sair. A fila preserva a ordem de chegada: quem entrou antes sai antes, como na fila do banco. É o oposto da pilha, que é LIFO e atende o último que chegou.

Estudar a aula: O que é uma fila: o comportamento FIFO

Resposta: B. Enfileirar adiciona no fim e desenfileirar remove da frente.

Enfileirar coloca no fim (quem chega vai para o final); desenfileirar tira da frente (o mais antigo é atendido). Cada operação em uma ponta. Essa separação é o que preserva a ordem de chegada e mantém o comportamento FIFO.

Estudar a aula: Enfileirar e desenfileirar: as operações da fila

Resposta: B. O elemento de maior prioridade; se houver empate, o que chegou primeiro entre os empatados.

Na fila de prioridade, a importância decide antes da chegada: sai o de maior prioridade. A ordem de chegada entra só como critério de desempate, quando duas prioridades são iguais. Por isso um caso grave passa na frente de um leve que chegou antes.

Estudar a aula: Fila de prioridade: quando furar a fila é justo

Resposta: B. Pilha, porque ela devolve o último elemento que entrou, e o desfazer reverte a ação mais recente.

Desfazer precisa reverter a ação mais recente primeiro, que é o comportamento LIFO da pilha: o último a entrar é o primeiro a sair. Cada ação é empilhada; desfazer desempilha a do topo. A fila faria o contrário, revertendo a ação mais antiga primeiro.

Estudar a aula: Pilha ou fila: escolhendo a estrutura certa

Resposta: B. É a referência para o primeiro nó, o ponto de entrada por onde se alcança toda a corrente.

A cabeça é a referência ao primeiro nó. A partir dela você segue as ligações e alcança os demais. Não é índice (a lista ligada não tem acesso direto) nem é o fim (esse é o nó que aponta para o nada).

Estudar a aula: O nó e a ligação: a corrente de dados

Resposta: B. Porque os nós não ficam encostados na memória; basta religar duas ligações para encaixar o novo nó na corrente.

Os nós vivem espalhados e são amarrados por ligações, não pela posição física. Inserir é só reapontar a ligação do anterior para o novo e a do novo para o seguinte. Nenhum outro nó muda de lugar, por isso o custo não depende do tamanho.

Estudar a aula: Inserir e remover: só religar ponteiros

Resposta: B. O vetor, porque o acesso direto por índice chega a qualquer posição num passo só.

Acesso frequente por posição arbitrária é o forte do vetor: ele calcula onde a posição está e chega num passo. Na lista ligada, cada acesso percorreria a corrente desde a cabeça, o que ficaria caro justamente na operação mais repetida.

Estudar a aula: Lista ligada ou vetor: cada um no seu forte

Resposta: B. Uma segunda ligação em cada nó, apontando para o anterior, o que permite andar nos dois sentidos.

A duplamente ligada acrescenta, em cada nó, uma ligação para o anterior, além da ligação para o próximo. Com ela dá para percorrer a corrente para frente e para trás. Índice é coisa do vetor; o último apontar para o primeiro é a lista circular, outra variação.

Estudar a aula: Listas duplas e circulares: variações da corrente

Resposta: B. Um nó que não tem nenhum filho, na ponta de um ramo.

Folha é o nó que não aponta para nenhum outro abaixo dele; é onde o ramo termina. O nó do topo sem pai é a raiz, não a folha. A ligação entre nós é a aresta, e ter dois filhos não define uma folha.

Estudar a aula: O que é uma árvore: raiz, nós e folhas

Resposta: B. Uma árvore em que cada nó tem no máximo dois filhos, um esquerdo e um direito.

A árvore binária limita cada nó a no máximo dois filhos, identificados pela posição (esquerdo e direito). Um nó pode ter zero, um ou dois, mas nunca mais de dois. É essa restrição, e a posição dos filhos, que a distingue da árvore genérica.

Estudar a aula: Árvore binária: no máximo dois filhos

Resposta: B. Para o filho esquerdo, ignorando a direita.

A regra da BST é menores à esquerda. Se o alvo é menor que o nó atual, ele só pode estar na subárvore esquerda, então a busca desce à esquerda e descarta todo o lado direito. É esse descarte de um ramo inteiro a cada passo que torna a busca rápida.

Estudar a aula: Árvore de busca binária: menores à esquerda, maiores à direita

Resposta: B. Em-ordem (esquerdo, raiz, direito).

O em-ordem visita o filho esquerdo, depois a raiz, depois o direito. Como numa BST o lado esquerdo guarda os menores e o direito os maiores, essa ordem faz os valores saírem do menor ao maior, já ordenados, sem nenhum passo extra de ordenação.

Estudar a aula: Percorrer uma árvore: em-ordem, pré-ordem e pós-ordem

Resposta: B. A árvore é um grafo especial, sem ciclos e com uma raiz; o grafo geral aceita ciclos e não precisa de raiz.

A árvore é um grafo conexo, sem ciclos e com um vértice eleito raiz. O grafo geral é mais livre: aceita ciclos (caminhos que voltam ao início) e não exige raiz. Por isso toda árvore é grafo, mas nem todo grafo é árvore.

Estudar a aula: O que é um grafo: vértices e arestas

Resposta: B. Um grafo com peso, onde cada aresta carrega o preço do trecho.

Como o preço de cada trecho importa para decidir a rota mais barata, cada aresta precisa carregar esse custo. Isso é um grafo com peso: o número na aresta permite somar custos e comparar caminhos para achar o mais barato.

Estudar a aula: Tipos de grafo: dirigido, não dirigido e com peso

Resposta: B. Espaço proporcional a N ao quadrado, porque é uma grade de N por N células, com um valor para cada par de vértices.

A matriz de adjacência é uma grade quadrada de N linhas por N colunas, uma célula para cada par de vértices. Isso dá N ao quadrado células, ocupadas mesmo quando a maioria vale zero. Por isso ela pesa em grafos esparsos e grandes, onde a lista de adjacência economiza.

Estudar a aula: Representar um grafo: lista e matriz de adjacência

Resposta: B. Cada pessoa vira um vértice, cada amizade vira uma aresta, e a resposta é o menor caminho em número de arestas entre as duas pessoas.

Pessoas são os vértices e amizades são as arestas. O número de apertos de mão entre duas pessoas é o comprimento do menor caminho (em arestas) entre elas no grafo, o famoso grau de separação. Modelar assim transforma a pergunta num problema de menor caminho.

Estudar a aula: O mundo como grafo: redes, mapas e rotas

Resposta: B. Uma fila, porque quer visitar os vértices na ordem em que foram descobertos, o que produz a exploração por camadas.

A BFS usa uma fila (FIFO). Como o primeiro a entrar é o primeiro a sair, os vizinhos descobertos antes (os mais próximos) são visitados antes. É justamente isso que faz a busca avançar em camadas e alcançar cada vértice pelo caminho com menos passos.

Estudar a aula: Busca em largura: explorar por camadas

Resposta: B. A própria pilha de chamadas de função: cada chamada empilha o caminho e cada retorno é o backtrack.

Quando a DFS é recursiva, cada chamada para um vizinho empilha um quadro na pilha de chamadas do programa. Esse empilhamento é o registro do caminho de descida. Quando uma chamada termina, o controle volta para a anterior, e esse retorno é exatamente o backtrack acontecendo de graça.

Estudar a aula: Busca em profundidade: ir fundo primeiro

Resposta: B. Para cada vértice descoberto, de qual vértice ele foi alcançado (o predecessor), para reconstruir a rota de trás para frente.

A busca em largura acha a distância de graça, mas para mostrar o caminho é preciso lembrar de onde cada vértice veio. Guardando o predecessor de cada um, você segue do destino até o início por essa trilha e, invertendo, obtém o caminho mais curto completo.

Estudar a aula: Achar o caminho mais curto com a busca em largura

Resposta: B. Porque o ciclo permite voltar a vértices já vistos, e sem a marcação a busca os redescobre indefinidamente, num loop.

Um ciclo cria uma rota que volta a um vértice já visitado. Sem o conjunto de visitados, a busca não percebe que já esteve ali, redescobre os mesmos vizinhos e gira para sempre. A marcação garante que cada vértice seja processado uma única vez, o que faz a busca terminar.

Estudar a aula: Visitados e ciclos: como não andar em círculos

Resposta: B. A combinação, quando duas metades já ordenadas são intercaladas numa lista maior ordenada.

Dividir a lista ao meio não ordena nada; só quebra o problema. O trabalho de ordenar acontece na combinação, quando o algoritmo intercala duas metades já ordenadas comparando seus primeiros elementos. É por isso que, em dividir para conquistar, a fase de juntar costuma ser a mais importante.

Estudar a aula: Dividir para conquistar: quebrar, resolver e juntar

Resposta: B. A profundidade da recursão: quantas chamadas ficam empilhadas ao mesmo tempo, uma esperando a outra.

A altura da árvore é a profundidade da recursão, ou seja, quantas chamadas ficam abertas simultaneamente na pilha de chamadas. O número total de chamadas depende também da largura (quantas chamadas por nível). Uma árvore pode ser alta e fina (profunda mas com poucas chamadas) ou baixa e larga.

Estudar a aula: A árvore de recursão: enxergar o trabalho total

Resposta: B. A última escolha é desfeita e o algoritmo volta para tentar a próxima opção daquele ponto.

Beco sem saída não encerra a busca: o backtracking desfaz apenas a última escolha e retorna ao ponto anterior para tentar a próxima opção. Só quando todas as opções de todos os pontos se esgotam é que a busca termina sem solução. Esse voltar controlado, um passo de cada vez, é a essência da técnica.

Estudar a aula: Backtracking: tentar um caminho e voltar

Resposta: B. Cada chamada ocupa espaço na pilha, então uma profundidade muito grande pode estourá-la, enquanto o laço roda em profundidade constante.

Recursão e laço resolvem o mesmo, mas cada chamada recursiva aberta ocupa memória na pilha de chamadas. Numa repetição linear muito profunda (por exemplo, um milhão de passos), a recursão simples pode estourar a pilha, enquanto o laço mantém o estado em poucas variáveis e roda em profundidade constante. Por isso, para repetição linear longa, o laço é mais seguro.

Estudar a aula: Recursão ou iteração: qual escolher

Resposta: B. Porque o fator log n cresce muito devagar, então a diferença entre as duas curvas aumenta conforme a lista cresce.

As duas curvas quase se encostam em listas pequenas. À medida que n cresce, o termo n ao quadrado dispara enquanto o fator log n mal se mexe. Por isso a vantagem do método eficiente só fica visível, e depois gritante, em listas grandes.

Estudar a aula: Por que O(n log n) ganha de O(n ao quadrado)

Resposta: B. Porque basta comparar os elementos da frente de cada lista e escolher o menor, visitando cada elemento uma única vez.

Como as duas metades já chegam ordenadas, o menor elemento do resultado é sempre um dos dois que estão na frente. Basta comparar essas frentes e avançar o marcador do lado escolhido. Cada elemento entra no resultado uma vez só, então o custo é proporcional ao tamanho total.

Estudar a aula: Merge sort: dividir e intercalar

Resposta: B. Ele já está na posição que ocuparia na lista ordenada e não precisa mais ser movido.

A partição deixa os menores à esquerda e os maiores à direita do pivô. Com isso, nenhum elemento menor pode estar depois dele e nenhum maior antes: o pivô já está no seu lugar definitivo da lista ordenada. Por isso cada partição resolve pelo menos um elemento para sempre.

Estudar a aula: Quick sort: pivô e partição

Resposta: B. Ela mantém a ordem original entre elementos que têm o mesmo valor de chave.

Estabilidade é sobre os empates: numa ordenação estável, dois itens com a mesma chave saem na mesma ordem em que entraram. Isso permite ordenar por uma chave sem destruir uma ordenação anterior. O merge sort é estável; o quick sort comum não é.

Estudar a aula: Escolher o algoritmo certo

Resposta: B. Porque cada chamada abre duas novas e valores como fib de 3 e fib de 2 são recalculados do zero em galhos diferentes, sem que nada seja guardado entre uma chamada e outra.

A função está correta. O desperdício vem de recalcular os mesmos subproblemas: fib de 3 é achado por vários galhos, cada um do zero, porque a função não guarda o que já descobriu. É esse recálculo redundante que explode o número de chamadas.

Estudar a aula: Recalcular à toa: o Fibonacci ingênuo

Resposta: B. Consulta a tabela (cache) para ver se o resultado de n já foi calculado e, se já, devolve o valor guardado sem recalcular.

O ritual da memoização é: antes de calcular, olhar o cache. Se a resposta para n já está lá, devolve na hora. Só quando não está é que a função calcula, anota o resultado na tabela e então devolve. É essa consulta que elimina o recálculo redundante.

Estudar a aula: Memoização: anotar para não recalcular

Resposta: B. Os mesmos subproblemas menores reaparecerem muitas vezes (subproblemas sobrepostos), com a resposta do todo se montando a partir das partes.

A marca é a repetição: quando o problema, ao ser quebrado, esbarra nos mesmos pedaços de novo e de novo, guardar esses pedaços numa tabela corta o trabalho repetido. Junte a isso a subestrutura ótima (o todo montado a partir das partes) e você tem um caso clássico de memo e DP. Só ser recursivo não basta.

Estudar a aula: Subproblemas sobrepostos: a marca que pede a técnica

Resposta: B. A memoização parte do problema grande e desce guardando resultados; a versão de baixo para cima começa pelos casos pequenos e sobe preenchendo uma tabela, sem recursão.

As duas cortam o mesmo desperdício e chegam ao mesmo resultado; mudam a direção. A memoização desce a partir do caso grande e guarda o que acha na volta. A programação dinâmica de baixo para cima começa pelos casos base já conhecidos e vai preenchendo a tabela em direção ao caso maior, com um laço, sem recursão.

Estudar a aula: A ideia da programação dinâmica: de baixo para cima

Resposta: B. Transformar a chave num índice do vetor, para a estrutura ir direto àquela posição.

A função hash é a ponte entre a chave e a posição: recebe a chave (texto, número, o que for) e devolve um índice válido do vetor. Assim, guardar e buscar viram um cálculo direto, sem varrer a coleção.

Estudar a aula: A tabela hash: o dicionário por dentro

Resposta: B. Porque espalha as chaves por posições variadas, mantendo poucos itens por balde e a busca rápida.

Uniformidade significa espalhar as chaves de forma equilibrada, sem amontoar muitas no mesmo balde. Com poucos itens por posição, olhar dentro de um balde é rápido. Se a função concentra tudo em poucos baldes, a busca volta a ficar lenta.

Estudar a aula: A função hash: espalhar bem as chaves

Resposta: B. Uma lista com todos os pares cujas chaves caíram naquele índice.

No encadeamento, cada balde guarda uma lista. Quando duas chaves colidem no mesmo índice, ambas entram na lista daquele balde. Buscar é ir ao balde e percorrer sua lista curta comparando as chaves, sem perder nenhum item.

Estudar a aula: Colisões: quando duas chaves querem o mesmo balde

Resposta: B. Porque a função calcula o índice e a estrutura vai direto ao balde, sem varrer a coleção, então o custo quase não cresce com o tamanho.

O cálculo do índice leva direto ao balde sem olhar os outros itens, então o número de passos quase não depende de quantos pares a tabela guarda. Isso é o tempo constante, O(1) em média. Vale em média porque colisões e lotação podem tornar buscas específicas mais lentas.

Estudar a aula: Por que a busca é quase instantânea

Resposta: B. Um conjunto pequeno de situações possíveis (estados), estando sempre em uma delas, com regras (transições) que mudam de situação quando um evento acontece.

A máquina de estado tem estados (as situações possíveis), está sempre em exatamente um deles e usa transições (regras disparadas por eventos) para mudar de um estado para outro. É esse trio, estado atual mais evento decide o próximo estado, que define o modelo.

Estudar a aula: Estados e transições: a situação que o sistema guarda

Resposta: B. Porque o próximo estado depende do estado atual mais o evento, e não só do evento sozinho.

A regra central da máquina de estado é que o destino de uma transição depende da dupla estado atual e evento. O evento tempo esgotado, aplicado no verde, leva ao amarelo; aplicado no amarelo, leva ao vermelho. O estado atual desambigua o evento.

Estudar a aula: Modelar um semáforo: estado atual mais evento

Resposta: B. Lê-se o texto símbolo por símbolo mudando de estado e, ao fim, verifica-se se parou num estado de aceitação.

No autômato, cada caractere lido dispara uma transição. Quando a leitura termina, olha-se o estado em que a máquina parou: se for um estado de aceitação (final), a entrada casa com o padrão e é válida; caso contrário, é rejeitada. O veredito vem do estado final, não de contar ou somar caracteres.

Estudar a aula: Validar com uma máquina: a entrada como autômato

Resposta: B. As telas são estados (situações onde o jogo permanece) e as ações são eventos que disparam transições entre elas.

As telas são estados: lugares onde o jogo permanece e se comporta de um jeito próprio. As ações do jogador, como apertar pausa ou perder, são eventos que disparam as transições entre as telas. Guardar a tela atual numa variável e reagir só aos eventos válidos ali é o que organiza a lógica da interface.

Estudar a aula: O jogo como máquina de estado: telas e eventos

Resposta: B. Que ele cuida de um assunto só, logo tem um motivo só para mudar.

Responsabilidade única quer dizer que o módulo trata de uma coisa e, por isso, tem um motivo só para ser alterado. Se ele calcula e também desenha a tela, uma mudança de aparência arrisca a conta. Separar dá a cada parte um trabalho, uma fronteira e testes independentes.

Estudar a aula: Dividir o programa em módulos

Resposta: B. Porque, se ninguém de fora depende do como interno, você pode trocar a implementação sem quebrar quem usa a interface.

Quando quem usa depende só da interface, o autor tem liberdade para mudar o interior (deixar mais rápido, corrigir, trocar a estrutura) sem afetar o resto do programa. Essa liberdade some quando a implementação vaza e alguém passa a depender de um detalhe interno.

Estudar a aula: Interface e implementação: usar sem saber o como

Resposta: B. Ele tem baixa coesão: mistura assuntos que não têm relação entre si, o que dificulta entender e mudar.

Data, e-mail e desconto são assuntos diferentes, então juntá-los num módulo só dá baixa coesão: uma gaveta de bagunça sem foco. O certo é separar por assunto, deixando cada módulo focado (alta coesão) e fácil de nomear e de encontrar.

Estudar a aula: Acoplamento e coesão: a saúde de um módulo

Resposta: B. Porque permite escrever um teste que confere, após cada operação, se a promessa continua verdadeira, apontando o bug onde ele nasce.

Com a invariante nomeada, você escreve uma função que a verifica e a chama depois de cada operação nos testes. Se a promessa for quebrada, o bug é flagrado exatamente onde surgiu, em vez de aparecer confuso e distante, como sintoma, mais tarde.

Estudar a aula: Invariantes: a promessa que o código mantém

Resposta: B. Porque um trecho pode alterar o dado no lugar e os outros, que apontam para o mesmo dado, passam a ver a mudança sem terem sido avisados.

Quando vários trechos apontam para o mesmo dado mutável, uma alteração num ponto muda o dado para todos. Quem não fez a alteração continua achando que o valor é o antigo e erra. A causa fica longe do efeito, o que torna o bug penoso de rastrear. Tratar o dado como imutável evita isso, porque qualquer mudança vira um objeto novo e separado.

Estudar a aula: Mutável ou imutável: mudar no lugar ou copiar

Resposta: B. Depender apenas dos argumentos recebidos e não causar nenhum efeito no mundo externo.

Pureza tem duas regras. Primeira: o resultado depende só dos argumentos, sem espiar variável global, relógio ou aleatório. Segunda: nenhum efeito externo, ou seja, não salva, não imprime, não muda nada por fora. Juntas, garantem que a mesma entrada sempre gera a mesma saída, o que a torna previsível e fácil de testar.

Estudar a aula: Função pura a fundo: só entra e sai

Resposta: B. Concentrar a lógica que decide em funções puras (o núcleo) e deixar os efeitos, como salvar e imprimir, numa camada fina em volta que apenas executa.

Isolar na borda é o padrão de núcleo puro com casca impura: a decisão fica em funções puras e testáveis, e os efeitos ficam numa camada fina que só executa o que o núcleo decidiu. Não se trata de eliminar efeitos, que são necessários, mas de mantê-los confinados num lugar pequeno e previsível, longe da lógica.

Estudar a aula: Efeito colateral controlado: isolar na borda

Resposta: B. Porque a condição de corrida precisa de dado compartilhado sendo alterado, e sem mutação nem estado compartilhado não há o que disputar entre as tarefas.

A condição de corrida exige dois ingredientes: dado compartilhado e mutação. Dado imutável pode ser lido por muitas tarefas ao mesmo tempo sem risco, porque ninguém o altera. Função pura não toca em estado externo, então não pisa no dado das outras. Sem dado mutável compartilhado, não há disputa, e o paralelo fica seguro.

Estudar a aula: Previsibilidade e concorrência: rodar em paralelo

Resposta: B. Cada estação é um vértice e cada trecho que liga duas estações vizinhas é uma aresta.

Os pontos de interesse (as estações) são os vértices; as ligações diretas entre eles (os trechos de trilho) são as arestas. Essa modelagem guarda a rede como lista de adjacência e prepara o grafo para o algoritmo de caminho.

Estudar a aula: O projeto: Mapa de Rotas

Resposta: B. Porque explora por camadas com uma fila, então a primeira vez que alcança um ponto é sempre pela rota mais curta em passos.

A fila faz a busca esgotar cada camada de distância antes de avançar para a próxima. Assim, quando um vértice é alcançado pela primeira vez, foi pelo caminho com menos passos; qualquer rota mais longa chegaria mais tarde, quando ele já estivesse visitado.

Estudar a aula: Achar o menor caminho com busca em largura

Resposta: A. Guardando o pai de cada vértice descoberto e seguindo os país do destino até a origem.

Ao descobrir um vizinho, a busca anota de quem ele veio (o pai). No fim, partindo do destino e seguindo pai por pai até a origem, obtém-se a sequência do caminho de trás para frente; invertendo, tem-se a rota completa.

Estudar a aula: Montando o programa completo

Resposta: B. Porque a lógica (decisões, laços, estruturas, algoritmos) é a parte que se transfere entre linguagens; muda só a sintaxe.

O raciocínio algorítmico (como resolver o problema) é o mesmo em qualquer linguagem. O que muda de uma para outra é a sintaxe, a forma de escrever. Por isso, com a lógica sólida, aprender uma linguagem nova vira sobretudo aprender uma nova forma de escrever ideias que você já entende.

Estudar a aula: Do pseudocódigo à linguagem