TP_ATIVIDADE_2

Prévia do material em texto

• Pergunta 1 
1 em 1 pontos 
 
Funções são blocos funcionais modulares presentes nas linguagens de programação 
estruturadas. A criação de funções, por exemplo, em C, deve seguir a sintaxe: 
<tipo_de_retorno> nome_da_função (lista_de_parâmetros). Para essa questão, suponha o 
trecho de código a seguir: 
 
int funcao(int a, int *b) 
 { 
 a++; 
 *b = a * 2; 
 return b+5; 
 } 
 
int main() 
{ 
 int x=4,y=8,z; 
 z = funcao(x,&y); 
 printf(“%d %d %d\n”,x,y,z); 
 return 0; 
} 
 
Assinale a alternativa que apresenta os valores impressos pela função “ printf ”: 
 
Resposta Selecionada: 
.4 10 15. 
Resposta Correta: 
.4 10 15. 
Feedback 
da 
resposta: 
Parabéns! Sua resposta foi a correta! Você utilizou, com 
sucesso, os conceitos de passagem de parâmetros por valor e 
por referência. No caso, realmente, devido à passagem por 
valor, a variável “ a”, apesar da alteração internamente à função, 
não influenciará o valor de “ x” - variável de origem. 
 
 
• Pergunta 2 
1 em 1 pontos 
 
Na linguagem C/C++, encontramos alguns comandos capazes de modificar o fluxo de 
execução de um programa: “ return ” (retorno de uma função), “ break ” (finaliza, por 
exemplo, um laço de repetição) e “ continue ” que volta para a linha que contém a definição 
do laço de repetição (por exemplo, a linha que contém a palavra “ for ”). Para essa questão, 
suponha que seja necessário implementar uma função hipotética que, passados como 
parâmetros os valores de “ início ” e de “ final ” de uma contagem, imprima os elementos 
de acordo com o seguinte conjunto de regras: não imprimir os números ímpares; caso seja 
encontrado um valor múltiplo de 5, sair de laço de repetição; caso seja encontrado o valor 
48, sair da função. Para tanto, analise o código a seguir: 
 
 
#include <stdio.h> 
 
void func(int inicio, int final) 
{ 
 int i=inicio; 
 for(; i<final; i++) 
 { 
 if(i%2) ____; 
 printf("%d ",i); 
 if(!(i%5)) ____; 
 if(i==48) 
 
 { 
 printf("\nSaindo da funcao pois encontrou 48.\n"); 
 ____; 
 } 
 } 
 if(i==final) printf("\nsaiu do laco pelo limite da contagem\n"); 
 else printf("\nsaiu do laco pois encontrou um multiplo de 5\n"); 
} 
 
int main() 
{ 
 printf("Execucao 1:\n"); 
 func(6,15); 
 printf("Execucao 2:\n"); 
 func(46,55); 
 printf("Execucao 3:\n"); 
 func(36,39); 
 return 0; 
} 
 
Assinale a opção abaixo que contenha a ordem correta de aparição dos comandos 
“ return ”, “ break ” e “ continue ”: 
Resposta Selecionada: 
. continue ; break ; return . 
Resposta Correta: 
. continue ; break ; return . 
Feedback 
da 
resposta: 
Parabéns! Sua resposta foi a correta! Realmente, para pular os 
ímpares, deve-se incrementar o contador de contagem e voltar 
ao início do laço de repetição, usando, para tal, o “ continue”. Por 
sua vez, a finalização do laço (quando for múltiplo de 5) é 
conseguido pelo comando “ break”. Por fim, para encerrar 
totalmente a função, ao se deparar com o valor 48, utiliza-se o 
comando “ return”. 
 
 
• Pergunta 3 
1 em 1 pontos 
 
Em funções recursivas, a posição da chamada recursiva em relação às demais linhas de 
seu código influencia o resultado. Dependendo da posição, a recursividade é dita como pré-
ordem (quando o processamento antecede a chamada recursiva); ordem simétrica (quando 
o processamento encontra-se entre duas chamadas recursivas) ou, finalmente, pós-ordem 
(processamento após as chamadas recursivas). Para essa questão, suponha o código a 
seguir: 
 
#include <stdio.h> 
 
void Recursao1(int i) 
 { 
 if(i>=5) return; 
 printf("%d ",i); 
 Recursao1(i+1); 
 } 
 
void Recursao2(int i) 
 { 
 if(i>=5) return; 
 Recursao2(i+1); 
 printf("%d ",i); 
 } 
 
 
int main() 
{ 
 printf("Recursao1\n"); 
 Recursao1(0); 
 printf("\n\nRecursao2\n"); 
 Recursao2(0); 
 return 0; 
} 
 
Assinale a opção que você julgue ser a correta: 
Resposta 
Selecionada: 
 
.A função “ Recursao1” segue uma recursão pré-ordem – logo o 
seu resultado é “ 0 1 2 3 4”. Por sua vez, a função “ Recursao2” é 
pós-ordem, por consequência, o seu resultado é: “ 4 3 2 1 0” . 
Resposta 
Correta: 
 
.A função “Recursao1” segue uma recursão pré-ordem – logo o 
seu resultado é “0 1 2 3 4”. Por sua vez, a função “Recursao2” é 
pós-ordem, por consequência, o seu resultado é: “4 3 2 1 0” . 
Feedback 
da 
resposta: 
Parabéns! Sua resposta foi a correta! Você observou 
corretamente a ordem de chamada e impressão do resultado. 
Na pré-ordem, a impressão acontece antes da chamada, por 
consequência, a impressão é realizada, neste caso, na ordem 
crescente. Na pós-ordem, a impressão acontece na ordem 
descrescente pois a recursão caminha por todos os níveis da 
contagem e imprime o resultado na volta das chamadas 
recursivas. 
 
 
• Pergunta 4 
1 em 1 pontos 
 
Para essa questão, suponha o seguinte enunciado. “A resistência de uma liga metálica se 
dá pelos percentuais de utilização de carbono misturados a outros elementos, 
essencialmente o ferro. Suponha a necessidade de se implementar uma função que, dada 
uma métrica de resistência (tipo de resistência – suponha que existam disponíveis 10 níveis 
de resistência) e um volume de ferro (em toneladas) calcule e retorne o percentual e a 
massa (em toneladas) de carbono a ser utilizada na liga metálica”. Para esse enunciado foi 
implementada uma função cuja chamada ocorrerá na forma: 
 
. . . 
float massaCarbono; 
massaCabono = CalculaQtdCarbono(tipo_resist,massaFerro, &percentual_carbono); 
. . . 
 
Assinale a opção abaixo que represente a interface mais apropriada para a questão: 
 
Resposta Selecionada: 
. float CalculaQtdCarbono(unsigned char, float, float *); . 
Resposta Correta: 
. float CalculaQtdCarbono(unsigned char, float, float *); . 
Feedback 
da 
resposta: 
Parabéns! Sua resposta foi a correta! Você interpretou 
corretamente o enunciado! Realmente, a função deve retornar 
dois valores: a massa de carbono (colocado como float em 
razão dos valores fracionários) e o percentual de carbono 
(passado como referência, como float, na lista de parâmetros da 
 
função). Foi utilizado o “ unsigned int” para o tipo da liga em 
função de uma escala com poucos valores (por exemplo, de 1 a 
10). 
 
• Pergunta 5 
1 em 1 pontos 
 
Quando se implementa uma fução, devemos seguir a sintaxe da linguagem de 
programação utilizada e, também, realzar a definição de sua interface de acordo com as 
nossas necessidades. Para essa questão, suponha o trecho de código a seguir: 
 
#include <stdio.h> //arquivo header para a funcao printf() 
#include <stdlib.h> //arquivo header para as funcoes srand() e rand() 
#include <time.h> //arquivo header para a funcao time() 
 
___ func1(int ___x, ___ a) 
{ 
 ___x=rand()%a; 
 return ___x*(rand()%5); 
} 
 
int main() 
{ 
 int aleat,ret; 
 int a=10; 
 srand(time(NULL)); //iniciacao do gerador de numeros aleatorios 
 for(int i=0; i<10;i++) 
 { 
 ret=func1(__aleat,a); 
 printf("valor aleatorio gerado %d: %d (limitado %d) - ret funcao: %d.\n", 
 i,aleat,a,ret); 
 } 
 return 0; 
} 
 
Escolha a afirmativa que contém o resultado da impressão pela função “ printf ” e os 
trechos a serem inseridos nas lacunas: 
 
Resposta Selecionada: 
. int ; * ; deixar em branco ; * ; * ; & . 
Resposta Correta: 
.int ; * ; deixar em branco ; * ; * ; & . 
Feedback 
da 
resposta: 
Parabéns! Sua resposta foi a correta! Você observou bem o fato 
de que a variável “ aleat”, dentro da função “ main()” não foi 
instanciada e que a referida instanciação ocorre dentro da 
função “ func1”. Desta forma, é necessário que ela seja passada 
como referência. Associando esse tipo de passagem, os demais 
preenchimentos são consequência. 
 
 
• Pergunta 6 
1 em 1 pontos 
 
Os compiladores C/C++, para realizar a verificação de consistência de uso das funções, faz 
uso dos arquivos de cabeçalhos ( headers ). Nestes arquivos, por exemplo,o protótipo das 
funções são declarados. Desta forma, o compilador verifica se as chamadas 
implementadas estão compatíveis com as definições das funções. Para essa questão, 
suponha a existência de dois arquivos: um contendo o arquivo header e outro contendo a 
implementação em C . 
 
 
(A) Arquivo header : 
 
#ifndef _ARQHEADER 
#define _ARQHEADER 
 
int func1(int *, int); 
float func2(float, char []); 
void func3(int *, int *, float); 
int func4(char[],int, char); 
 
#endif 
 
(B) Arquivo de implementação 
 
int main() 
{ 
 int a,b,c; 
 float f1,f2; 
 char str[20],carac; 
 c=func1(a,b); //Linha 1 
 f2=func2(f1,str[0]); //Linha 2 
 c=func3(&a, &b, f1); //Linha 3 
 c=func4(str,a,carac); //Linha 4 
 func1(&c,a); //Linha 5 
 return 0; 
} 
 
Analisando a parte de implementação com o arquivo header, assinale a alternativa que 
contém os possíveis erros que seriam acusados pelo compilador: 
Resposta 
Selecionada: 
 
.Na linha 1, o parâmetro “ a” não está sendo passado por 
referência (falta o “ &”); na linha 2, está sendo passado o 
caracter da posição 0 e não toda a string 
“ str”; na linha 3, está sendo atribuído um valor à variável “ c” 
por intermédio de uma função que nada retorna ( func3); as 
demais linhas estão corretas. 
Resposta 
Correta: 
 
.Na linha 1, o parâmetro “a” não está sendo passado por 
referência (falta o “&”); na linha 2, está sendo passado o 
caracter da posição 0 e não toda a string 
“str”; na linha 3, está sendo atribuído um valor à variável “c” 
por intermédio de uma função que nada retorna (func3); as 
demais linhas estão corretas. 
Feedback 
da 
resposta: 
Parabéns! Sua resposta foi a correta! Você fez a 
correspondência correta dos protótipos das funções (interfaces) 
definidos no arquivo de cabeçalhos nas chamadas inseridas no 
programa principal. Você observou bem que, apesar de uma 
função retornar um valor, não é obrigatório fazer uso do retono 
no momento da chamada da função (como está codificada a 
linha 5). 
 
 
• Pergunta 7 
1 em 1 pontos 
 
Em algumas situações, como inversão de vetores, surge a necessidade de implementar 
uma função que realiza a troca de dois elementos entre si, ou seja, o elemento “ vet[i] ” 
 
recebe o valor de “ vet[j] ” e “ vet[j] ” recebe o valor de “ vet[i] ”. Sendo assim, pode-se 
codificar uma função que realizará exatamente essa permuta. Para essa questão, 
considere o código apresentado a seguir: 
 
 
#include <stdio.h> 
#include <string.h> 
 
void swap(char __c1, char __c2) 
{ 
 char tmp; 
 tmp = __c1; 
 __c1 = __c2; 
 __c2 = tmp; 
} 
 
void Ordena(char str[]) 
{ 
 for(int i=0; i < strlen(str)-1; i++) 
 for(int j=i+1; j < strlen(str); j++) 
 if(str[i]>str[j]) swap(__str[i],__str[j]); 
} 
 
int main() 
{ 
 char str[11]="icbjdgfeah"; 
 printf("Vetor original: %s\n",str); 
 Ordena(str); 
 printf("Vetor ordenado: %s\n",str); 
 return 0; 
} 
 
Assinale a opção abaixo que contenha os elementos para preencher as lacunas (nas 
opções abaixo, o símbolo ”_” significa deixar a lacuna sem preenchimento): 
Resposta Selecionada: 
. * ; * ; * ; * ; * ; * ; & ; & . 
Resposta Correta: 
. * ; * ; * ; * ; * ; * ; & ; & . 
Feedback 
da 
resposta: 
Parabéns! Sua resposta foi a correta! Você observou que, 
apesar da função “ swap” manipular elementos do vetor, foram 
passadas posições específicas, ou seja, foram passados apenas 
caracteres. Sendo assim, é necessário passar as referências 
dos itens “ str[i]” e “ str[j]” para que as alterações realizadas 
dentro da função “ swap” tenham validade na função “ Ordena”. 
 
 
• Pergunta 8 
1 em 1 pontos 
 
Com a recursividade, os laços de repetição são substituídos pelas 
chamadas recursivas. Esse tipo de implementação tem os seus estudos 
aprofundados na área da computação denominada como matemática 
discreta. Para essa questão, pense em uma solução recursiva, 
implementada em C, para resolver a expressão 2 n. Dentre as alternativas a 
seguir, escolha aquela que tiver uma codificação que corresponda à 
solução. 
 
Escolha a opção correta: 
 
Resposta 
Selecionada: 
 
. int dois_a_n(int n) { if(n == 0) return 1; return 2*dois_a_n(n-
1); } 
 . 
Resposta Correta: 
. int dois_a_n(int n) { if(n == 0) return 1; return 2*dois_a_n(n-
1); } 
 . 
Feedback da 
resposta: 
Parabéns! Sua resposta foi a correta! Você observou a relação 
entre a condição de parada e a variação do parâmetro passado. 
Como a condição de parada é 0, os parâmetros devem ser 
passados de forma descrescente. 
 
 
• Pergunta 9 
1 em 1 pontos 
 
Na interface das funções, podemos encontrar as variáveis passadas por 
valor e as variáveis passadas por referência. Para essa questão, analise as 
afirmativas abaixo: 
 
I – Na passagem por valor, as modificações realizadas internamente à 
função não impactam sobre o valor da variável na origem da chamada da 
função. 
II – Na passagem por referência, qualquer alteração dentro da função, 
automaticamente altera o valor da variável na origem pois ambas possuem 
o mesmo endereço de memória. 
III – No código: “ func(int a , float *b)”, a variável “ a” é passada por referência 
enquanto que a variável “ b” é passada por valor. 
IV – Para realizar modificações ou acessar o conteúdo de variáveis 
passadas por referência, deve-se usar variável precedida pelo sinal “ &” 
para indicar o seu conteúdo. Por exemplo, na função “ func(int a , float *b)”, 
para se instanciar a variável “ b”, dentro do código, usaremos, por exemplo: 
“ &b = 5;”. 
 
Escolha a alternativa abaixo que você julgue ser a correta: 
 
Resposta Selecionada: 
.Apenas as afirmativas II e II estão corretas. 
Resposta Correta: 
.Apenas as afirmativas II e II estão corretas. 
Feedback 
da 
resposta: 
Parabéns! Sua resposta foi a correta! Realmente, a passagem 
de parâmetros por referência, a posição de memória é a mesma 
da variável origem, o que proporciona que ambas as variáveis 
estarão sempre sincronizadas. O acesso às variáveis passadas 
por referência, no caso do função da afirmativa IV, é feito 
mediante o uso do símbolo “*” (por exemplo, “ &b = 5;”). 
 
 
• Pergunta 10 
1 em 1 pontos 
 
Quando se implementa uma fução, devemos seguir a sintaxe da linguagem de 
programação utilizada e, também, realizar a definição de sua interface de acordo com as 
nossas necessidades. Para essa questão, suponha o trecho de código a seguir para 
 
procurar uma sequência dentro de uma cadeia de DNA: 
 
#include <stdio.h> 
#include <string.h> 
 
___ ProcuraDNA(char ___dna[],char ___seq[],int ___ret[]) 
{ 
 int indice=0; 
 for(int i=0; i<strlen(dna); i++) 
 if(!strncmp(&(dna[i]),seq,3)) ret[indice++]=i; 
 ret[indice]=-1; //apenas para marcar o último item adicionado 
} 
 
int main() 
{ 
 int i=0, pos[19]; 
 char str[19] = "GATGATCATGTCGTACATC", //uma sequencia de DNA qualquer 
 seq_proc[4] = "ATG"; //Adenina, Timina, Guanina – uma cadeia exemplo 
 ProcuraDNA(str,seq_proc,pos); 
 printf("posicoes:"); 
 while(pos[i]!=-1) 
 { 
 printf("%d ",pos[i]); 
 i++; 
 } 
 return 0; 
} 
 
Escolha a afirmativa que contém o resultado da impressão pela função “ printf ” e os 
trechos a serem inseridos nas lacunas: 
Resposta 
Selecionada: 
 
. void ; deixar em branco ; deixar em branco ; deixar em 
branco . 
Resposta Correta: 
.void ; deixar em branco ; deixar em branco ; deixar em 
branco . 
Feedback 
da resposta: 
Parabéns! Sua resposta foi a correta! Você se atentou bem ao 
fato de que vetores, de forma como as strings, quando 
passadas como parâmetros, já denotam passagem por 
referência. Sendo assim, os símbolos “*” e “&” não são 
necessários.