Av2 - Algoritmos e Programação Estruturada

Prévia do material em texto

Av2 - Algoritmos e Programação Estruturada
1)
 É comum utilizarmos ponteiros com funções. Um caso importante de ponteiros com funções é na alocação de memória dinâmica. A função malloc ( ) pertencente a biblioteca <stdlib.h> é usada para alocar memória dinamicamente. Entender o tipo de retorno dessa função é muito importante, principalmente para seu avanço, quando você começar a estudar estruturas de dados.
 
Observe atentamente o programa que demonstra o uso de funções:
 
	#include<stdio.h>
#include<stdlib.h>
int* alocar(){
return malloc(200);
}
int main(){
int *memoria;
memoria = alocar();
if(memoria != NULL){
printf("Endereço de memória alocada = %x",memoria);
}
else{
printf("Memória não alocada");
}
return 0;
}
 Conforme demonstrado no programa apresentado a função malloc ( ) irá reservar um espaço de memória dinamicamente, a função malloc ( ) pode retornar dois valores e são eles:
Alternativas:
b) int  ou um ponteiro genérico (ponteiro genérico é do tipo void)
2)
“Muitos problemas têm a seguinte propriedade: cada instância do problema contém uma instância menor do mesmo problema. Diz-se que esses problemas têm estrutura recursiva. Para resolver tal problema, pode-se aplicar o seguinte método: se a instância em questão for pequena, resolva-a diretamente; senão, reduza-a a uma instância menor do mesmo problema, aplique o método à instância menor, volte à instância original. A aplicação desse método produz um algoritmo recursivo.” (FEOFILOFF, 2017, p. 1). Baseado nesse conceito, avalie as asserções a seguir:
 
 I -  Recursividade significa indicar quando um problema maior pode ser dividido em instâncias menores do mesmo problema.
PORQUE
 II - A técnica de recursividade pode substituir o uso de estruturas de repetição tornando o código mais elegante.
A respeito dessas asserções, assinale a alternativa correta:
Alternativas:
a)As asserções I e II são proposições verdadeiras, e a II é uma justificativa da I.
3)
Recursividade é uma técnica sofisticada em programação, na qual uma função chama a si mesma criando várias instâncias (chamadas recursivas). Embora seja uma técnica que proporciona um código mais limpo e facilita a manutenção, seu uso deve levar em consideração a quantidade de memória necessária para a execução do programa. Nesse contexto, avalie as asserções a seguir:
 
I. A cada chamada recursiva é alocado recursos na memória para a função, se a função for muito grande poderá ocorrer um acúmulo de memória.
PORQUE
 II. É preciso avaliar o custo-benefício em se ter um código mais sofisticado em detrimento de uma estrutura de repetição, pois a segunda opção gasta menos memória.
A respeito dessas asserções, assinale a alternativa correta:
Alternativas:
d)A asserção I é uma proposição falsa, e a II é uma proposição verdadeira.
4)
A estrutura de Fila é do tipo FIFO (First in, First out), ou seja, o primeiro elemento que entra na fila é o primeiro elemento a ser removido, assim, todo primeiro elemento que entra na fila por uma extremidade, saíra primeiro pela outra extremidade.
 
Um aluno afirmou que a estrutura de Fila é muito similar a uma fila de espera de um caixa eletrônico em um banco ou até mesmo uma fila para passar as compras em um mercado.
 
Considerando o contexto apresentado, avalie as seguintes asserções e a relação proposta entre elas.
 
I. Um função que podemos implementar na Fila, é a de verificação se a Fila está vazia ou não. No trecho de remoção de um elemento da Fila, já realizamos a chamada a esta função, e ela pode ser implementada com o trecho de código a seguir:
int fila_vazia (Fila* f)
{
    return (f -> n == 0);
}
 
PORQUE
 
II. É impossível remover um elemento de uma Fila vazia.
Agora assinale a alternativa correta.
Alternativas:
b)as asserções I e II são proposições verdadeiras, mas a II não é o motivo que justificativa da implementação da I.
5)
A seguir é apresentado o código da função "clonar(p)", capaz de criar e retornar uma nova pilha idêntica a uma pilha "p" já existente.
 
struct Pilha* clonar(struct Pilha* p) {
assert(p != NULL);
struct Pilha* clone = criar();
struct Pilha* aux = criar();
 
while(vazia(p) == false) {
empilhar(aux, desempilhar(p));
}
 
while(vazia(aux) == false) {
int elemento =____________;
____________;
empilhar(p, elemento);
}
 
____________
return clone;
}
Assinale a alternativa que preenche corretamente as lacuna do código da função "clonar":
Alternativas:
c)desempilhar(aux) / empilhar(clone, elemento) / liberar(aux).