

Seu próximo nível começa aqui
Com a Assinatura Ilimitada, você tem tudo que precisa para sua aprovação.
Com a Assinatura Ilimitada, você combina prática, teoria e método em uma única assinatura com tudo que você precisa para sua aprovação.
Considere a expressão a = (x > y)? ((x > z)? x : z): ((y> z)? y : z) na linguagem de programação C++.
Para obter o valor 4 para a variável a, a combinação das variáveis inteiras x, y e z é
x = 6, y = 5, z = 3.
x = 5, y = 4, z = 5.
x = 3, y = 4, z = 2.
x = 6, y = 3, z = 5.
x = 6, y = 4, z = 5.
Considerando os construtores da linguagem de programação C++, é CORRETO afirmar:
A ordem de chamada dos construtores é idêntica à ordem de chamada dos destrutores, quando se trata de classes derivadas.
Os construtores de uma classe básica são herdados por classes derivadas.
Os construtores de uma classe derivada são herdados por classes básicas.
Os construtores de uma classe derivada não podem chamar construtores da classe básica.
Ao instanciar um objeto de uma classe derivada, inicia-se uma cadeia de chamadas de construtor em que o construtor da classe derivada, antes de realizar suas tarefas, invoca o construtor de sua classe básica.
Analise o código C++ abaixo.
#include <iostream>
#include <stack>
#include <queue>
int main(){
_______ std::queue<int> myqueue;
_______ std::stack<int> mystack;
_______ mystack.push(1);
_______ mystack.push(2);
_______ mystack.push(3);
_______ mystack.push(4);
_______ myqueue.push(5);
_______ myqueue.push(6);
_______ myqueue.push(7);
_______ myqueue.push(8);
_______ myqueue.pop();
_______ mystack.pop();
_______ std::cout << myqueue.front() +
mystack.top() << std::endl;
_______ return 0;
}
Considerando os conceitos de pilha e fila, o número a ser impresso após a execução do código C++ acima é:
10
9
8
7
2
O código C abaixo se propõe a informar a média da idade de algumas pessoas com uma precisão de duas casas decimais, dados o número de pessoas (pessoas, com 0<pessoas<10 e suas respectivas idades.
#include <stdio.h>
int main(){
______int pessoas, i, soma, idade;
______double media;
____________scanf("%d", &pessoas);
______soma = 0;
______for(i = 0; i < pessoas; i++){
_________scanf("%d", &idade);
_________soma = soma + idade;
______}
______media = soma/pessoas;
______printf("%.2f", media);
___return 0;
}
A respeito do código acima, é CORRETO afirmar:
O código faz corretamente o que é proposto.
O código interrompe sua execução com um segmentation fault.
O código pode ser corrigido para fazer o que se propõe, caso seja feita uma conversão de tipos no local apropriado.
O código está errado, pois o formato do printf não é apropriado para impressão com precisão de duas casas decimais.
O código está errado, pois a variável idade deveria ser dividida pela variável pessoas dentro do for, ou seja, soma = soma + idade/pessoas;.
Na linguagem de programação C, cadeias de caracteres (ou Strings) são representadas por vetores do tipo char. O código abaixo chama uma função denominada apresentarString, que imprime o conteúdo da String armazenada em vet.
int main() { char vet[100] = "Eu sou uma string!"; apresentarString(vet); return 0; } |
Das opções de implementação da função apresentarString abaixo, a que NÃO é capaz de imprimir a String corretamente (isto é, NÃO é capaz de imprimir: Eu sou uma string!) é:
void apresentarString(char * str){ _ if( *str == '\0' ){ __return; _} _printf("%c", *str); _apresentarString(str++); } |
void apresentarString(char * str){ _int i = 0; _for ( i = 0; str[i] != '\0'; i++ ){ __printf("%c", str[i]); _} } |
_void apresentarString(char * str){ _int i = 0; _while( str[i] != '\0' ){ __printf("%c", str[i]); __i++; __} } |
void apresentarString(char * str){ _int i = 0; _while( *str != '\0' ){ __printf("%c", *str); __str++; _} } |
void apresentarString(char * str){ _if( *str == '\0' ){ __return; _} _printf("%c", *str); _apresentarString(++str); } |
Na linguagem C++, é possível substituir as funções scanf("%d", &x) e printf("%d", y) da linguagem C, respectivamente, por
std::cout >> x e std::cin << y
std::cin >> x e std::cout << y
std::cin << x e std::cout >> y
std::cout << x e std::cin >> y
Dadas as afirmativas acerca das linguagens de programação Java, C++ e Python,
I. Das três linguagens consideradas, Java é a única que não permite sobrecarga de operadores.
II. O nível de dinamismo permitido pela linguagem Python, em termos de polimorfismo, é inferior às linguagens C++ e Java, uma vez que não possui construção equivalente aos Templates (de C++) e Generics (de Java).
III. Na linguagem C++, o padrão é o uso do acoplamento estático; e para optar pelo acoplamento dinâmico, é necessário utilizar a palavra reservada virtual.
IV. Na linguagem Java, o operador final somente pode ser utilizado para qualificar atributos, não podendo ser utilizado para qualificar métodos.
verifica-se que está(ão) correta(s)
II, apenas.
I e III, apenas.
II e IV, apenas.
I, III e IV, apenas.
I, II, III e IV.
#include <stdio.h>
int main(int argc, char** argv) {
int i, j, aux;
int v[] = {10, 8, 6, 4, 2, 9, 7, 5, 3, 1};
for(i = 10 - 1; i >= 1; i--)
for(j = 0; j < i; j++)
if(v[j] > v[j + 1]) {
aux = v[j];
v[j] = v[j + 1];
v[j + 1] = aux;
}
_________ for(i = 0; i < 10; i+)
_______________ printf("%d ", v[i]);
return 0;
}
Considerando o algoritmo acima, implementado na linguagem C, assinale a alternativa correta, quanto à saída produzida do trecho destacado.
1 3 5 7 9 2 4 6 8 10
10 8 6 4 2 9 7 5 3 1
10 9 8 7 6 5 4 3 2 1
1 2 3 4 5 6 7 8 9 10
Um Assistente Tecnológico da PRODATER observou que o programa em C
solicita que o usuário forneça N+1 (ou seja, 6) valores para o vetor vet. Valores negativos e valores repetidos são rejeitados.
utiliza um trecho de código que ordena o vetor vet pelo método da bolha e objetiva levar para as últimas posições os valores maiores.
realiza uma busca nos elementos do vetor fornecidos pelo usuário através do método de pesquisa sequencial, e não exige que o vetor esteja ordenado.
utiliza o método de pesquisa binária e exige que o vetor esteja ordenado, para localizar valores no vetor. Mas se -1 pertencer ao vetor, este elemento não é encontrado.
apresenta erro de compilação, já que não exige que valores negativos sejam impedidos de serem inseridos no vetor e não verifica se a quantidade de elementos é maior que a capacidade do vetor.
Analise o código C++ abaixo.
#include <cstdio>
#include <iostream>
#include <string>
#include <queue>
using namespace std;
int main() {
_______priority_queue< pair<int, string> > pq;
_______pair<int, string> result;
_______pq.push(make_pair(100, "fulano"));
_______pq.push(make_pair(10, "ciclano"));
_______pq.push(make_pair(20, "beltrano"));
_______pq.push(make_pair(100, "geronimo"));
_______while( !pq.empty() ){
_____________result = pq.top();
_____________pq.pop();
_____________printf("(%s: %d)",
___________________((string)result.second).c_str(),
___________________result.first);
_______}
_______return 0;
}
Considerando as filas e suas variações, a saída do código C++ acima é
(ciclano: 10)(beltrano: 20)(fulano: 100)(geronimo: 100)
(beltrano: 20)(ciclano: 10)(fulano: 100)(geronimo: 100)
(geronimo: 100)(fulano: 100)(ciclano: 10)(beltrano: 20)
(geronimo: 100)(fulano: 100)(beltrano: 20)(ciclano: 10)
(geronimo: 100)(fulano: 100)(ciclano: 20)(beltrano: 10)
Na linguagem C, o cabeçalho de biblioteca stdio.h possui definições de subrotinas relativas às operações de entrada/saída padrão. Uma das funções tratadas na biblioteca, associada a esse cabeçalho, é a função:
atoi.
trunc.
scanf.
strcpy.
locatime.
Na linguagem C#, sempre que o operador new falhar ao alocar memória para um objeto, é lançada a exceção
IndexOutOfBoundsException.
InsufficientMemoryException.
NullReferenceException.
OutOfMemoryException.
StackOverflowException.
O comando switch da linguagem de programação C é, na linguagem Visual Basic .NET, semelhante ao comando:
Select Case;
Exit;
For Each;
Goto;
Continue.
Considere o código abaixo, escrito na linguagem de programação C++.
#include <iostream>
usingnamespacestd;
intmain(){
int A = 0, B = 7, C = 4, D = 3;
for (A = 0; A < B; A++)
D = D + 1;
for (A = 0;A <= C; A++)
D = D + 2;
if (D>=20)
cout<< "SISTEMAS OPERACIONAIS";
else
cout<< "REDES DE COMPUTADORES";
}
Assinale a alternativa que apresenta o valor que a variável D apresentará ao final da execução do programa e qual mensagem aparecerá na tela do computador.
D = 15 e “REDES DE COMPUTADORES”.
D = 20 e “SISTEMAS OPERACIONAIS”.
D = 18 e “REDES DE COMPUTADORES”.
D = 20 e “REDES DE COMPUTADORES”.
D = 21 e “SISTEMAS OPERACIONAIS”.
Na linguagem C, considere que as variáveis A e B contenham os valores 60 e 13, cujas respectivas representações binárias são mostradas a seguir.
A = 0011 1100
B = 0000 1101
Nesse caso, as expressões
A&B
A|B
têm por valores, respectivamente:
0011 1101 e 0000 1100;
0011 1100 e 0011 1101;
0000 1101 e 0011 1100;
0000 1100 e 0011 1101;
0000 0000 e 0011 1101.
Considere o trecho de código abaixo, escrito na linguagem de programação C++, que define uma classe chamada Pessoa.
class Pessoa
{
public:
char nome[45];
char sexo;
intanoNascimento;
private
float salario;
private
voidcalcularAumento();
public:
intcalcularIdade (int ano);
}
Sobre a definição acima, assinale a alternativa correta.
O método calcularAumento é público.
O método calcularIdade é público.
O atributo anoNascimento é privado.
O atributo salario é público.
O atributo nome é privado.
A linguagem de programação C# oferece as interfaces IEquatable<T> e IComparable<T> para que objetos possam ser comparados com outros objetos. A diferença entre essas interfaces é que apenas
IComparable<T> é capaz de determinar se os objetos são diferentes.
IComparable<T> permite que seja estabelecida uma relação de ordem entre os objetos.
IComparable<T> pode ser utilizada para comparar objetos de classes diferentes.
IEquatable<T> é capaz de determinar se os objetos são iguais.
IEquatable<T> permite que seja estabelecida uma relação de ordem entre os objetos.
Observe o código em linguagem C abaixo.
#include <stdio.h>
#include <stdlib.h>
int main (void) {
int n, i, j, m;
while(1) {
scanf("%d", &n);
if (n<l) return 0;
int vet [n+l];
vet[0]=0;
vet[l]=0;
for(i = 2; i < = n ; i++) vet [i] = i;
for(i = 2; i < = n ; i++) {
for(j = 2; j < = n ; j++) {
if (vet [i] > 0) m = i * j;
if (m>n) break;
vet [m] = 0;
}
}
printf ("\n");
for(i=2;i<=n;i++) {
if(vet[i]>0) printf("%d,",vet[i]);
} printf ("\n");
}
return 0;
}
Com base no código acima, se for digitado 100 para o valor de n, pode-se afirmar que o programa:
não mostra nada.
é um gerador de números aleatórios que não podem ser previstos.
mostrará todos os números primos entre O e 100.
mostrará todos os números entre O e 100.
mostrará todos os números entre 2 e 100.
Utilizando a linguagem de programação C++, foi definida uma classe Empregado em empregado.hpp. Nessa definição, é encontrada a seguinte linha de comando:
virtualfloatcalculaSalario();
Assinale a alternativa que apresenta a propriedade da orientação a objetos implementada utilizando esse comando e o que essa linha de comando indica.
Polimorfismo e a linha de comando indica que cada classe filha dessa classe vai ter uma implementação opcional desse método, mas conforme a sua necessidade.
Encapsulamento e a linha de comando indica que cada classe filha dessa classe vai ter uma implementação obrigatória desse método, mas conforme a sua necessidade.
Polimorfismo e a linha de comando indica que cada classe filha dessa classe vai ter uma implementação obrigatória desse método, mas conforme a sua necessidade.
Encapsulamento e a linha de comando indica que cada classe filha dessa classe vai ter uma implementação opcional desse método, mas conforme a sua necessidade.
Polimorfismo e a linha de comando indica que cada classe filha dessa classe vai ter uma implementação obrigatória desse método, exatamente como ele foi declarado na classe mãe.
Considere os termos private / protected, usados para especificar os direitos de acesso aos membros de classes escritas na linguagem C++. Na ordem respectiva, esses termos denotam permissões de acesso que se limitam aos membros:
da mesma classe / da mesma classe e de classes derivadas;
da mesma classe / de classes derivadas que sejam protected;
da mesma classe que não sejam public / de classes derivadas que não sejam public;
de classes derivadas que sejam private / da mesma classe;
da mesma classe e de classes derivadas / da mesma classe.