Turmas - 1º Semestre de 2024
Turmas
1º Semestre de 2024

(ENADE, 2021) O código Java, a seguir, contém a implementação de uma Pilha utilizando a estratégia encadeada.

public class No {
  public int dado;
  public No prox;
  public No(int dado) {
    this.dado = dado;
  }
}
public class PilhaEncadeada {
  private No topo;
  public int pop() {
    if (topo == null)
      return -1;
    No lixo = topo;
    topo = topo.prox;
    lixo.prox = null;
    return lixo.dado;
  }
  public int top() {
    if (topo == null)
      return -1;
    return (topo.dado);
  }
}

Com base no exposto, assinale a opção que possui a implementação correta do método push para essa Pilha.

a.

public void push(int elemento) {
  No novo = new No(elemento);
  if (topo == null)
    topo = novo;
  else
    topo.prox = novo;
}

b.

public void push(int elemento) {
  No novo = new No(elemento);
  topo = novo;
}

c.

public void push(int elemento) {
  topo.dado = elemento;
}

d.

public void push(int elemento) {
  No novo = new No(elemento);
  while (topo != null)
    topo = topo.prox;
  topo.prox = novo;
}

e.

public void push(int elemento) {
  No novo = new No(elemento);
  novo.prox = topo;
  topo = novo;
}

(ENADE, 2023) Uma lista pode ser dividida em duas partes: o primeiro elemento (a cabeça da lista) e os demais elementos (sua cauda). Por exemplo, em uma lista de inteiros [1, 2, 3, 4], a cabeça dessa lista é o valor inteiro 1, enquanto sua cauda é a lista de inteiros [2, 3, 4]. Uma lista vazia é representada por [].

O código a seguir define duas funções descritas em uma linguagem de programação funcional que manipulam listas de inteiros. A função enade recebe uma lista de inteiros e produz uma nova lista de inteiros. A função auxiliar é chamada pela função enade e possui dois parâmetros: um número inteiro e uma lista de inteiros. Essa função produz uma lista de inteiros.

enade :: [Int] -> [Int]
enade [] = []
enade (cabeca:cauda) = auxiliar cabeca (enade cauda)
auxiliar :: Int -> [Int] -> [Int]
auxiliar x [] = [x]
auxiliar x (cabeca:cauda)
  | (x ’mod’ 2 == 0) = x:cabeca:cauda
  | otherwise = cabeca:auxiliar x cauda

Considerando o código apresentado, é correto afirmar que se a função enade for executada recebendo como parâmetro de entrada a lista [1, 2, 3, 4, 5, 6, 7, 8], o resultado será

a. [].

b. [2, 4, 6, 8].

c. [1, 2, 3, 4, 5, 6, 7, 8].

d. [2, 4, 6, 8, 1, 3, 5, 7].

e. [2, 4, 6, 8, 7, 5, 3, 1].

(ENADE, 2021) A linguagem PROLOG pertence ao paradigma da programação lógica, no qual a lógica proposicional e algorítmica pode ser expressa na forma de descritores de fatos e regras de produção de respostas. No contexto da árvore genealógica de uma família, analise a seguinte base de fatos descrita em linguagem Prolog.

paide(francisco, ana).
paide(francisco, maria).
paide(francisco, luiz).
paide(jose, angelica).
paide(jose, luiza).
paide(jose, joaquim).
homem(francisco).
homem(jose).
homem(luiz).
homem(joaquim).
mulher(ana).
mulher(maria).
mulher(angelica).
mulher(luiza).

Qual regra lógica de produção está corretamente escrita para verificar uma das situações lógicas em que duas pessoas são irmãs?

a. saoirmas(X,Y):-paide(P,X), paide(P,Y), X\=Y.

b. saoirmas(X,Y):-paide(P,X), paide(P,Y), X\=Y, mulher(X).

c. saoirmas(X,Y):-paide(P,X), paide(P,Y), mulher(X,Y).

d. saoirmas(X,Y):-paide(P,X), paide(P,Y), X\=Y, mulher(X), mulher(Y).

e. saoirmas(X,Y):-paide(P,X), paide(P,Y), mulher(X), mulher(Y).

(POSCOMP, 2022) De acordo com o diagrama de classes UML a seguir, assinale a alternativa que se relaciona diretamente com o conceito de polimorfismo da programação orientada a objetos.

a. A relação entre as classes Livro e Capitulo.

b. O método ImprimeNome das classes Artefato e Livro.

c. Os atributos numero: Integer e numeroDeFiguras: Integer da classe Capitulo.

d. O atributo autor: String da classe Livro.

e. A cardinalidade da relação entre Livro e Capitulo.

Ao executar o seguinte programa escrito na sintaxe C++, a saída impressa no console será:

class Animal {
  public: void fale() { std::cout << "... "; }
};
class Cao : public Animal {
  public: void fale() { std::cout << "au au "; }
};
class Gato : public Animal {
  public: virtual void fale() { std::cout << "miau "; }
};
class GatoPersa : public Gato {
  public: void fale() { std::cout << "miauuuu "; }
};
class Tigre : public Gato {
  public: void fale() { std::cout << "rrrr "; }
};
int main() {
  Gato *gato = new GatoPersa();
  gato->fale();
  Animal *cao = new Cao();
  cao->fale();
  Gato *tigre = new Tigre();
  tigre->fale();
}

a. ... ... ...

b. miau au au miau

c. miauuuu ... rrrr

d. miauuuu au au rrrr

e. miau ... miau

Na ciência da computação, concorrência é a capacidade de diferentes partes ou unidades de um programa serem executadas fora de ordem ou em ordem parcial, sem afetar o resultado. Isso permite a execução paralela de unidades simultâneas, o que pode melhorar significativamente a velocidade geral de execução em sistemas multiprocessadores e multinúcleos. Em termos mais técnicos, concorrência refere-se à decomposição de um programa em componentes independentes de ordem ou parcialmente ordenados. Considere a função apresentada a seguir, apresentada na linguagem de programação Pascal, que executa de forma recursiva a soma dos elementos de um array, decompondo esse array em partes menores até ser possível realizar a soma de dois elementos, ou retornar o valor do próprio elemento.

function somar(inicio: integer; fim: integer; vetor: array [1..MAX] of integer): integer;
var dif, meio: integer;
begin
  dif := fim - inicio;
  if dif > 1 then
  begin
    meio := dif div 2;
    somar := somar(inicio, inicio + meio, vetor) + somar(inicio + meio + 1, fim, vetor);
  end
  else
  begin
    if dif = 0
      then somar := vetor[inicio]
      else somar := vetor[inicio] + vetor[fim]
  end;
end;

Converta a função apresentada para ser executada de forma concorrente, utilizando a linguagem de programação de sua preferência.

import java.util.Random;

public class Somar extends Thread
{
  private int inicio;
  private int fim;
  private int[] vetor;
  private int resultado;

  public Somar(final int inicio, final int fim, final int[] vetor)
  {
    this.inicio = inicio;
    this.fim = fim;
    this.vetor = vetor;
  }

  public int getResultado()
  {
    return resultado;
  }

  public void run()
  {
    final var dif = fim - inicio;

    if (dif > 1)
    {
      final int meio = dif / 2;

      final var thread1 = new Somar(inicio, inicio + meio, vetor);

      final var thread2 = new Somar(inicio + meio + 1, fim, vetor);

      thread1.start();

      thread2.start();

      try
      {
        thread1.join();

        thread2.join();
      }
      catch (final Exception exception)
      {
        exception.printStackTrace();
      }

      resultado = thread1.getResultado() + thread2.getResultado();
    }
    else
    {
      resultado = (dif == 0) ? vetor[inicio] : vetor[inicio] + vetor[fim];
    }
  }

  public static void main(String[] args)
  {
    final var vetor = new int[20];

    final var random = new Random();

    for (var i = 0; i < 20; i++)
    {
      vetor[i] = random.nextInt(99) + 1;

      System.out.print(vetor[i] + " ");
    }

    System.out.println();

    final var sort = new Somar(0, vetor.length - 1, vetor);

    sort.run();

    System.out.print(sort.getResultado());
  }
}

Em linguagens de programação, o tratamento de exceções é o processo de resposta à ocorrência de exceções – condições anômalas ou excepcionais que requerem processamento especial – durante a execução de um programa. Utilizando a linguagem de programação de sua preferência, implemente:

1. um método que valide seu parâmetro (n), lançando uma das seguintes exceções, conforme o valor do parâmetro:

   • se n for menor ou igual a zero, lançar a exceção AException;

   • se n for maior do que zero e menor ou igual a cem, lançar a exceção BException;

   • se n for maior do que cem e menor do que duzentos, lançar a exceção CException;

   • se n for maior ou igual a duzentos, lançar a exceção DException;

2. um método que utilize o método desenvolvido no item a) e capture de forma unívoca a exceção gerada, apresentando-a ao usuário.

public class Questao07
{
  public void validar(final int n)
  {
    if (n <= 0) throw new AException();

    if (n <= 100) throw new BException();

    if (n < 200) throw new CException();

    throw new DException();
  }

  public static void main(String[] args)
  {
    final var app = new Questao07();

    try
    {
      app.validar(101);
    }
    catch (final Exception exception)
    {
      System.out.println(exception);
    }
  }
}

class AException extends RuntimeException {
  public AException() {
    super();
  }
}

class BException extends RuntimeException {
  public BException() {
    super();
  }
}

class CException extends RuntimeException {
  public CException() {
    super();
  }
}

class DException extends RuntimeException {
  public DException() {
    super();
  }
}

Desenvolva um programa em PROLOG, que apresente a média dos elementos contidos em uma lista e nas suas sublistas, como no exemplo a seguir.

?- media([1, 2, [3, 4, [5, 6], 7, 8], 9], N), write(N), nl.
5

soma([], 0).
soma([CAR|CDR], N) :- soma(CAR, N1), soma(CDR, N2), !, N is N1 + N2.
soma(N, N).

quantidade([], 0).
quantidade([CAR|CDR], N) :- quantidade(CAR, N1), quantidade(CDR, N2), !, N is N1 + N2.
quantidade(_, 1).

media(X, M) :- soma(X, S), quantidade(X, N), M = S / N.