

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.
Interprete o código abaixo, escrito na linguagem de programação C, assinalando o que será apresentado na tela após a execução completa do código:

-15173
30629
407210
-1315
05274
Qual linguagem de alto nível foi utilizada no desenvolvimento do sistema operacional Unix?
Python
C
Assembly
Java
Ruby
Analise o código-fonte abaixo, escrito na linguagem C.
void swap(int *x, int *y)
{
int temp;
temp = *x;
*x = *y;
*y = temp;
}
void main()
{
int num1 = 5, num2 = 10;
swap(&num1, &num2);
}
O uso da função swap no código acima demonstra uma passagem de parâmetros por:
Valor.
Chave.
Ligação.
Referência.
Herança.
Considere o programa em C abaixo.
#include <stdio.h>
#define MAX 5
int main ( ) {
int i=0, vetor [MAX] ;
int *pvetor=NULL;
pvetor = vetor;
for ( ;i<MAX; i++)
*(vetor +i) = i*10;
for (i=0 ;i<MAX;i++)
printf("pvetor[%d] = %d ",i,*(pvetor+i));
return 0;
}
Um Técnico, ao executar o programa acima em condições ideais, obterá como saída
um erro relativo à falta de valor inicial para a variável i no primeiro for
pvetor[0]= 0 pvetor [l]= 10 pvetor[2]= 20 pvetor[3]= 30 pvetor [4]= 40
um erro, pois no primeiro for o comando correto deveria ser: &(pvetor+i) = i+10;
pvetor[0]= 0 pvetor [l]= O pvetor[2]= 0 pvetor[3]= 0 pvetor [4]= 0
pvetor[l]= 10 pvetor[2]= 10 pvetor [3]= 10 pvetor[4]= 10 pvetor[5]= 10
Considere uma lista dinamicamente encadeada, onde cada célula da lista possui a seguinte estrutura codificada na linguagem C:
struct celula {
int info;
struct celula *next;
};
Observe a figura abaixo e o posicionamento das variáveis lista, p e novo que são ponteiros para o struct célula. O ponteiro novo aponta para uma nova célula que deverá ser incluída na lista entre as células 2 e 4. Qual das alternativas abaixo permite incluir a nova célula?

novo->next = p->next; p->next = novo;
novo->next = p; p->next = novo;
p->next = novo; novo->next = p-> next;
novo.next = p.next; p.next = novo;
novo.next = p; p.next = novo;
#include "stdio.h"”
static int fatorial (int num) {
return num <= 1 ? 1 : num * fatorial (num-1);
}
int main (int argc, char *argv[]) {
int var = 0;
scanf ("&d", &var);
printf("&d", fatorial (var));
return 0;
}
A respeito do código apresentado escrito na linguagem C, assinale a alternativa correta.
O código apresenta um exemplo de função aninhada.
Independentemente do valor do parâmetro num, a função fatorial(int) sempre retornará o mesmo valor após a primeira execução, por ser uma função estática.
A exclusão dos parâmetros argc e argv da função main provocaria erro de compilação, uma vez que essa função é o ponto de entrada do programa, e tais parâmetros não podem ser desconsiderados.
Não é possível substituir o corpo da função fatorial(num) por uma estrutura de laços de repetição for ou while sem que haja diferença no resultado apresentado para qualquer valor do parâmetro num.
A função fatorial(int) é implementada de modo recursivo.
Examine o programa em C abaixo.
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#define NUM_ADVOGADOS 3
void advogado(int id) (
printf("Advogado %d: Preparando argumentos\n", id);
usleep(rand() % 2000000 + 1000000); /
printf("Advogado %d: Apresentando o caso ao tribunal\n", id) ;
usleep(rand() % 2000000 + 1000000); /
printf("Advogado %d: Caso resolvido\n", id);
}
int main() {
srand(time(NULL));
for (int i = 1; i <= NUM_ADVOGADOS; i ++) (
if (fork() == 0) (
......I
}
}
/
for (int i = 1; i <= NUM_ADVOGADOS; i ++) (
wait(NULL); /
}
printf("Todos os casos foram resolvidos.\n");
return 0;
}
Considerando que uma das saídas do programa acima, compilado e executado em condições ideais, seja:
Advogado 1: Preparando argumentos
Advogado 3: Preparando argumentos
Advogado 2: Preparando argumentos
Advogado 3: Apresentando o caso ao tribunal
Advogado 2: Apresentando o caso ao tribunal
Advogado 1: Apresentando o caso ao tribunal
Advogado 1: Caso resolvido
Advogado 3: Caso resolvido
Advogado 2: Caso resolvido
Todos os casos foram resolvidos.
A lacuna I deve ser corretamente preenchida com:
advogado(i);
advogado(i); exit(0);
advogado(i+1);
advogado(i+1); break(1);
advogado((fork(i)); exit(1);
Considerando-se o código escrito na linguagem C:

Qual é o resultado da execução do código?
a=1 e b=2
a=1 e b=12
a=10 e b=2
a=10 e b=12
Na linguagem C, como declarar uma variável para uma matriz bidimensional que será alocada dinamicamente?
int** matriz;
int* matriz;
int matriz[][];
int matriz*;
Considerando-se o código escrito na linguagem C:

Qual é o resultado da execução do código?
x=10 e y=10
x=9 e y=10
x=10 e y=9
x=9 e y=9
Considere o código abaixo escrito em linguagem C:
#include <stdio.h> int main() { int A = 1, B = 0, C = 1; int resultado = (A && B) || C; printf("%d\n", resultado); return 0; } |
Que valor será impresso na tela após a execução do programa?
Nulo.
0.
1.
2.
3.
Observe o seguinte código:
1 | #include <iostream> |
2 | using namespace std; |
3 | int main() |
4 | { |
5 | int estM[]={20,15,10,4,15}; |
6 | int estA[]={12,20,0,6,10}; |
7 | int preco[]={1,3,15,5,4}; |
8 | int k, d; |
9 | int cont; |
10 | |
11 | for (k=0;k<5; k++){ |
12 | cont=0; |
13 | for(d=estA[k];d<estM[k];d++){ |
14 | cont++; |
15 | } |
16 | cout<<cont<< " "; |
17 | } |
18 | |
19 | return 0; |
20 | } |
A execução deste código C++ imprimirá na tela
0 0 0 0 0
8 0 10 0 5
8 -5 10 -2 5
-8 5 -10 2 -5
32 35 10 10 25
O que será impresso ao executar o código-fonte abaixo, escrito na linguagem C?
#include <stdio.h>
void main()
{
int num1 = 10, num2 = 4;
printf("%d e %d", num1/num2, num2/num1);
}
2.50000 e 0.40000
2.5 e 0.4
0 e 0.00000
2.0 e 4.0
2 e 0
Qual das linguagens de programação abaixo NÃO é orientada a objetos?
C.
C++.
Java.
Python.
PHP.
Considere o seguinte trecho de código em C:
#include <stdio.h>
void funcao(int a, int b) {
int temp = a;
a=b;
b = temp;
}
int main() {
int x = 10, y = 20;
funcao(x, y);
printf("× = %d, y = %d\n", x, y);
return 0;
}
Qual será a saída desse programa?
x = 10, y = 20.
x = 20, y = 10.
x = 0, y = 0.
O programa apresentará um erro de compilação.
O programa apresentará um erro de segmentation fault.
Considere a seguinte definição de uma estrutura de nó em uma árvore binária em C:
struct node {
int value;
struct node *esquerda;
struct node *direita;
}:
Qual é o resultado da seguinte operação de inserção em uma árvore binária com a raiz apontada pelo ponteiro root?
void insere_no(struct node **root, int value){
if (*root== NULL){
*root = (struct node) malloc(sizeof(struct node)):
(*root)->value = value;
(*root)->esquerda = NULL;
(*root)->direita = NULL;
}else if (valor < (*root)->value){
insere_no(&(*root)->esquerda, value);
}else {
insere_no(&(*root)->direita, value);
}
}
O valor value é inserido como o valor da raiz da árvore, independentemente do valor fornecido na chamada à função insere_no.
O valor value é inserido como o valor da folha mais à esquerda da árvore, independentemente do valor fornecido na chamada à função insere_no.
O valor value é inserido como o valor da folha mais à direita da árvore, independentemente do valor fornecido na chamada a função insere_no.
O valor value é inserido em sua posição correta, de acordo com a ordem de valores estabelecida na árvore binária de busca.
A função não insere o valor value na árvore, pois a recursão seguira indefinidamente.
Assinale a alternativa que corresponde corretamente à complexidade temporal T e à complexidade espacial S do trecho de código abaixo na linguagem de programação C, em notação “big-O”. Considere que a função rand() executa em tempo constante e que não influencia na complexidade espacial.
#include <stdlib.h>
int x = 1;
int y = 1;
void func(int m, int n) {
for (int i = 0; i < m; ++i) {
x += rand();
}
for (int j = 0; j < n; ++j) {
y *= rand();
}
}
T = O(m*n), S = O(1)
T = O(m*n), S = O(m + n)
T = O(m + n), S = O(m + n)
T = O(m + n), S = O(1)
T = O(m), S =O(1)
Observe o seguinte código:
1 | #include <iostream> |
2 | using namespace std; |
3 | |
4 | int f(int x) { |
5 | if((x==1) || (x==0) { |
6 | return(x); |
7 | }else { |
8 | return(f(x-1)+f(x-2)); |
9 | } |
10 | } |
11 | |
12 | int main() |
13 | { |
14 | cout<<f(10); |
15 | return 0; |
16 | } |
A execução deste código C++ imprimirá na tela
1
10
34
55
89
Considere o código em linguagem C apresentado a seguir:
#include <stdio.h>
int main(void) {
int N[20],x,y;
for (x=0; x <= 10; x++){
scanf("%d",&N[x]);
}
for (y=0; y < 10; y++){
if (N[y] > 0){
printf("%d \n",N[y]);
}
}
}
Sobre o funcionamento do código apresentado, é correto afirmar que:
I. Armazena valores em todas as posições do vetor N.
II. Exibe os valores apenas das 10 primeiras posições do vetor N.
III. Exibe apenas valores positivos armazenados no vetor N.
Assinale a alternativa CORRETA:
As afirmações I e II são corretas.
Apenas a afirmação II é correta.
As afirmações I e III são corretas.
As afirmações II e III são corretas.
Nenhuma das afirmações.
Analise o trecho de código abaixo em linguagem C.
#include <stdio.h>
void func(int n) {
if(n == 0) {
return;
}
printf("%d-", n);
func(n-1);
}
int main(int argc, char *argv[]) {
func(5);
return 0;
}
Assinale a alternativa que apresenta corretamente o que é impresso na execução desse código.
5-4-3-2-1
5-4-3-2-1-0
5-4-3-2-1-0-
5-4-3-2-1-
Nenhuma das alternativas anteriores.