Unidade 2 Atividade

Prévia do material em texto

PERGUNTA 1
1. 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:
	
	
	.Apenas as afirmativas II e II estão corretas.
	
	
	.Apenas a afirmativa III é falsa.
	
	
	.Apenas as afirmativas III e IV são corretas.
	
	
	.Todas as afirmativas são corretas.
	
	
	. Apenas a afirmativa IV é falsa.
1 pontos   
PERGUNTA 2
1. 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:
	
	
	.int
;  * ;  deixar em branco ; * ; deixar em branco ; & .
	
	
	.int ;  * ;  deixar em branco ; * ; * ; & .
	
	
	.int
;  * ; *  ; * ; * ; & .
	
	
	.int
;  deixar em branco ;  deixar em branco ; deixar em branco ; deixar em branco
; deixar em branco.
	
	
	.int
;  * ;  deixar em branco ; * ; * ; deixar em branco .
1 pontos   
PERGUNTA 3
1. Na computação, existem várias formas de representação numérica, dentre as quais, podemos citar as representações decimal, hexadecimal, octal e binária. Para realizar a conversão, por exemplo, de um valor formatado na base decimal para uma base K , basta realizar divisões sucessivas por K e coletar o último quociente e todos os restos das divisões em ordem inversa. 
Suponha a necessidade de criar uma função recursiva para a conversão de um número na base decimal para a representação binária (base 2). Para essa questão, suponha o trecho a seguir:
 
#include <stdio.h>
 
void Dec2Bin(int n)
{ 
  if(__) printf("%d",n);
  else
    {
      ___;
      ___;
    }
}
 
int main()
{
 
  Dec2Bin(14);
  return 0;
}
 
Assinale a opção abaixo que contenha os trechos de código para preencher as lacunas:
	
	
	.  n<2 ; printf("%d",n/2) ; Dec2Bin(n % 2) .
	
	
	.  n==0 ; Dec2Bin(n / 2) ; printf("%d",n%2) .
	
	
	.  n<2 ; Dec2Bin(n % 2) ; printf("%d",n/2) .
	
	
	.  n<2 ; printf("%d",n%2) ; Dec2Bin(n / 2) .
	
	
	.  n<2 ; Dec2Bin(n / 2) ; printf("%d",n%2) .
1 pontos   
PERGUNTA 4
1. 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 preencher as lacunas (o caracter “_” significa para deixar a lacuna vazia):
	
	
	.  __  ;  __  ; int ; rand()%6 .
	
	
	.  __  ;  __  ; int ; (rand()%6)+1 .
	
	
	.   *  ;   *  ; int ; (rand()%6)+1 .
	
	
	.   *  ;   *  ; int ; rand()%6 .
	
	
	.  __  ;  __  ; int ; rand() .
1 pontos   
PERGUNTA 5
1. 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):
	
	
	. * ; * ; * ; * ; * ; * ; & ; & .
	
	
	. * ; * ; * ; * ; * ; * ; _ ; _ .
	
	
	. * ; * ; _ ; _ ; _ ; _ ; & ; & .
	
	
	. _ ; _ ; _ ; _ ; _ ; _ ; _ ; _ .
	
	
	. & ; & ; * ; * ; * ; * ; & ; & .
1 pontos   
PERGUNTA 6
1. 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 ”:
	
	
	.4    10    15.
	
	
	.5    10    15.
	
	
	.4     16   21.
	
	
	.5     16   21.
	
	
	.4     16   15. 
1 pontos   
PERGUNTA 7
1. 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:
	
	
	.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” .
	
	
	.A função “Recursao1” segue uma recursão pré-ordem – logo o seu resultado é “4 3 2 1 0”. Por sua vez, a função “Recursao2” é pós-ordem, por consequência, oseu resultado é: “0 1 2 3 4” .
	
	
	.A função “Recursao1” segue uma recursão pós-ordem – logo o seu resultado é “4 3 2 1 0”. Por sua vez, a função “Recursao2” é pré-ordem, por consequência, o seu resultado é: “0 1 2 3 4” .
	
	
	.A função “Recursao1” segue uma recursão pós-ordem – logo o seu resultado é “0 1 2 3 4”. Por sua vez, a função “Recursao2” é pré-ordem, por consequência, o seu resultado é: “4 3 2 1 0” .
	
	
	.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 eu resultado é o mesmo da função “Recursao1” .
1 pontos   
PERGUNTA 8
1. 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:
	
	
	.  float CalculaIRPF(float *, float);  .
	
	
	.  float CalculaIRPF(float, float *);  .
	
	
	.  int CalculaIRPF(float, float *);  .
	
	
	.  float CalculaIRPF(float *, float *);  .
	
	
	.  float CalculaIRPF(float, float);  .
1 pontos   
PERGUNTA 9
1. 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 ”:
	
	
	. break ; return ; continue .
	
	
	. continue ; return ; break .
	
	
	. return ; break ; continue .
	
	
	. break ; continue ; return .
	
	
	. continue ; break ; return .
1 pontos   
PERGUNTA 10
1. 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:
	
	
	. float CalculaQtdCarbono(unsigned char, float, float); .
	
	
	. float CalculaQtdCarbono(unsigned char, float, float *); .
	
	
	. float CalculaQtdCarbono(float, float, float); .
	
	
	. float CalculaQtdCarbono(float, float, float *); .
	
	
	. float CalculaQtdCarbono(unsigned char, float, int *); .
1 pontos   
Clique em Enviar para enviar. Clique em Salvar todas as respostas para salvar todas as respostas.