Atividade A2 - Técnicas de Programação

Prévia do material em texto

● Pergunta 1 
● 1 em 1 pontos 
● 
 
 Modularizar um sistema significa dividí-lo em blocos funcionais e, 
estes subdividí-los em funções. É recomendável que as 
funções tenham o seu comportamento bem pontual, ou seja, 
deve ser única a desempenhar uma função específica. Diante 
da questão sobre modularização, assinale com “V” a(s) 
afirmativa(s) abaixo que você julgue como verdadeira(s) e, 
com (F), a(s) falsa(s). 
 
( ) Dificulta o processo de testes pelo fato de que, com a 
modularização, deve-se testar um número muito maior de 
funções . 
( ) Facilita a reutilização do código pois a funcionalidade de 
uma função pode fazer parte de uma outra parte do sistema. 
( ) O programa fica mais organizado, separado por 
funcionalidades. 
( ) A compreensão do código se torna mais exaustiva devido 
ao grande número de chamadas de funções na 
implementação. 
 
Escolha a opção correta: 
 
 
 
 
 
Resposta Selecionada: ​.F ; V ; V ; F 
. 
Resposta Correta: ​.F ; V ; V ; F . 
Feedback
da 
respo
sta: 
Parabéns! Sua resposta foi a correta! 
Realmente, a modularização facilita o 
processo de verificação, testes, 
compreensão e reaproveitamento de 
código pelo fato de que existe uma 
separação funcional do código assim 
como as funções são implementadas de 
forma mais pontuais. 
● 
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); 
 
● 
Pergunta 3 
● 0 em 1 pontos 
● 
 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 
respo
sta: 
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 4 
● 1 em 1 pontos 
● 
 Um valor binário pode ser representado no padrão conhecido como BCD
8421 (​ ​Binary-coded Decimal​ ​– Decimal Codificado em Binário). 
Nesta codificação, os valores 8421 representam o resultado de 2​ ​i​ ​, 
onde ​i​ ​denota a posição do dígito dentro da palavra. Por exemplo, 
1001​ ​(2)​ ​= 1*8 + 0*4 + 0*2 +1*1 = 9​ ​(10)​ ​. Para essa questão, 
suponha o seguinte código recursivo: 
 
#include <stdio.h> 
#include <string.h> 
 
int Bin2Dec(char bin[],int pos,int exp) 
{ 
 if(____) return 0; 
 return (bin[pos]-48)*exp + Bin2Dec(bin,____,____); 
} 
 
int main() 
{ 
 char binario[9]="10011101"; //valor em decimal = 157 
 printf("Valor convertido: %d", Bin2Dec(binario,strlen(binario)-1,1))
 return 0; 
} 
 
Assinale a opção abaixo que contenha os trechos de código para 
preencher as lacunas: 
 
 
 
 
 
Resposta Selecionada: ​. ​pos<0 ; pos-1 ; exp/2 . 
Resposta Correta: ​. ​pos<0 ; pos-1 ; exp*2 . 
Feedback
da 
respo
sta: 
Infelizmente a sua resposta está incorreta. 
Para responder essa questão, observe 
que fica mais fácil processar o vetor que 
corresponde ao número binário da ordem 
do final (última posição) para o início 
(posição 0). Com esse encaminhamento, 
observe, também, a variação do expoente
 
 Para a evocação de uma função, algumas informações deverão 
ser armazenadas, como o endereço da linha que contém a 
evocação (registrador PC – ​Program Counter​ – Contador de 
Programa), para que, quando a função for finalizada, o 
computador saiba voltar ao ponto de chamada. Dentre as 
afirmativa abaixo, assinale com “V” aquela(s) que você julgar 
estar correta e, com “F”, a(s) falsa(s). 
 
( ) As informações para o retorno, em função da evocação da 
função, são empilhadas em uma região da memória principal 
do computador chamada “ ​stack​” (pilha). 
( ) Não precisamos nos preocupar com a quantidade de 
evocações aninhadas (uma função chamando outra e assim 
por diante, em uma ação de profundidade) 
independentemente dos dispositivo para o qual estamos 
implementando nosso código. 
( ) Funções recursivas são aquelas que demandam muito 
recurso da máquina. 
( ) O sistema operacional também empilha as informações 
decorrentes das funções associadas às interrupções do 
computador. 
 
Assinale a alternativa abaixo que contenha a sequência que 
você julgue ser a correta: 
 
 
 
 
Resposta Selecionada: ​.V; F; F; 
V. 
Resposta Correta: ​.V; F; F; V. 
Feedback
da 
respo
sta: 
Parabéns! Sua resposta foi a correta! 
Realmente, o sistema operacional deve 
salvar o endereço da linha na qual ocorreu
a evocação da função para que se possa, 
ao término da função, voltar à linha 
subsequente à chamada. Esse 
salvamento ocorre em uma estrutura de 
pilha ( ​stack​) da memória principal. Essa 
região de pilha pode ser extremamente 
limitada em ambientes com pouca 
memória, tal como nos sistemas 
embarcados. As interrupções da máquina 
● 
Pergunta 5 
● 1 em 1 pontos 
● 
 
são tratadas, superficialmente falando, de 
forma análoga às funções. 
 
 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: ​.410
15. 
Resposta Correta: ​.4 10 15
Feedback
da 
respo
sta: 
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
● 
Pergunta 6 
● 1 em 1 pontos 
● 
 
da alteração internamente à função, não 
influenciará o valor de “ ​x​” - variável de 
origem. 
 
 Gerar números aleatórios tem a sua serventia em diversas situações, 
tais como geração de sequências para testes de softwares, solução 
inicial em problemas de otimização e definição do intervalo de tempo
para o reenvio de informações em redes de computadores. Para o 
teste, imaginemos um cenário onde dois jogares disputam uma 
partida de lançamento de dados – ganha aquele que obtiver maior 
pontuação no dado lançado. Para simular esse cenário, imaginemos 
o código abaixo:#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() 
 
 
void Compara(int __jog1, int __jog2) 
{ 
 if(jog1 > jog2) printf("Jogador 1 vencedor (1=%d x 
2=%d)\n",jog1,jog2); 
 else if (jog1 < jog2) printf("Jogador 2 vencedor!(1=%d x 
2=%d)\n",jog1,jog2); 
 else printf("Empate (%d)\n",jog1); 
} 
 
___ Dado() 
{ 
 return ____; 
} 
 
int main() 
{ 
 srand(time(NULL)); 
 Compara(Dado(),Dado()); 
 return 0; 
} 
 
 
Assinale a opção abaixo que contenha os trechos de código para 
 
● 
Pergunta 7 
● 1 em 1 pontos 
● 
preencher as lacunas (o caracter “_” significa para deixar a lacuna 
vazia): 
 
 
 
 
Resposta Selecionada: ​. __ ; __ ; int ; (rand()%6)+1 . 
Resposta Correta: ​. __ ; __ ; int ; (rand()%6)+1 . 
Feedback
da 
respo
sta: 
Parabéns! Sua resposta foi a correta! 
Realmente nenhuma função requer 
passagem de parâmetros por referência 
pois o único valor retornado é feito através
do retorno da função “ ​Dado()​”. A geração 
do número aleatório segue a forma “ 
(rand()%6)+1​” pois a soma por um impede a 
geração do valor 0 e o resto da divisão 
define o valor limite superior do número 
gerado. 
 
 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: 
 
● 
Pergunta 8 
● 1 em 1 pontos 
● 
 
 
 
 
Resposta 
Selecion
ada: 
 ​.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 
respo
sta: 
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 9 
● 1 em 1 pontos 
● 
 Na definição do protótipo da função, em sua interface, temos que 
definir o tipo de retorno da função e, também, a lista de 
parâmetros. Para essa questão, suponha o trecho de código a
seguir: 
 
#include <stdio.h> 
#include <stdlib.h> 
 
int func(int a, int __b, char __c[]) 
{ 
 a +=++__b; 
 itoa(a,c,10); 
 return a; 
} 
 
int main() 
{ 
 char c[10]; 
 int x=5, y=6; 
 printf("%d %s %d %d",func(x,&y,c),c,x,y); 
} 
 
 
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: ​.12 12 ; * ; ​deixar em branco​ 
* . 
Resposta Correta: ​.12 12 ; * ; ​deixar em branco​ ; * .
Feedback
da 
respo
sta: 
Parabéns! Sua resposta foi a correta! Você 
observou bem o fato de que a chamada 
da função, dentro do programa principal, 
requer uma passagem por valor para a 
variável “x” e uma passagem por 
referência para a variável “y”. Isso implica 
em “ ​int func(int a, int *b, char __c[])​“ e, 
consequentemente, “ ​a +=++(*b);​”. Uma ​string
sempre é passada por referência – sendo 
assim, não necessita o uso de “ ​*​”. 
 
 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​ . 
● 
Pergunta 10 
● 1 em 1 pontos 
● 
 
 
Feedback
da 
respo
sta: 
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. 
 
 Para essa questão, suponha o seguinte enunciado: “O imposto de 
renda incidirá sobre o salário de todos os assalariados de modo que
o desconto seja proporcional ao seu salário e de acordo com as 
faixas de valores”. Para esse enunciado foi implementada uma 
função cuja chamada ocorrerá na forma: 
 
. . . 
float salarioLiquido; 
salarioLiquido = CalculaIRPF(salario_bruto, &imposto_retido); 
. . . 
 
Assinale a opção abaixo que represente a interface mais apropriada
para a questão: 
 
 
 
 
 
Resposta 
Selecionada: 
 ​. ​float CalculaIRPF(float, float *);​ . 
Resposta Correta: ​. ​float CalculaIRPF(float, float *);​ . 
Feedback
da 
respo
sta: 
Parabéns! Sua resposta foi a correta! Você 
interpretou corretamente o enunciado 
observando bem os valores retornados 
pela função. Os valores retornados 
devem ser passados como referência 
usando o símbolo “ ​*​” no protótipo da 
função e “ ​&​” na chamada da função.