Turmas - 1º Semestre de 2023
Turmas
1º Semestre de 2023

Considere o seguinte programa escrito na sintaxe Java:

public class AppleRed extends Apple
{
   public AppleRed()
   {
      super(Color.red);
   }
}

public class AppleGreen extends Apple
{
   public AppleGreen()
   {
      super(Color.green);
   }
}

Com base no programa apresentado, avalie as asserções a seguir.

1. A classe AppleRed é um Apple e por isso poderia armazenar uma instância do tipo Apple, como por exemplo: AppleRed apple = new Apple();
2. A classe AppleGreen é um Apple e por isso poderia ser armazenada em uma variável do tipo Apple, como por exemplo: Apple apple = new AppleGreen();
3. Como ambas as classes estendem Apple, uma instância de AppleRed pode ser armazenada em variáveis do tipo AppleGreen, como por exemplo: AppleGreen apple = new AppleRed();

A respeito dessas asserções, assinale a alternativa correta.

a. apenas a assertiva I.

b. apenas a assertiva II.

c. apenas a assertiva III.

d. apenas as assertivas I e II.

e. apenas as assertivas I e III.

Considere o seguinte programa escrito na sintaxe Java:

public class MyException extends Exception {
   public MyException() { super(); }
}

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

public class MyClass {
  public int testException(int test) throws MyException {
    if (test == 0) { throw new MyException(); }
    return test;
  }

  public int testRuntime(int test) {
    if (test == 0) { throw new MyRuntime(); }
    return test;
  }
}

Supondo que o usuário deseje utilizar os métodos definidos por MyClass, julgue as assertivas a seguir.

1. Para utilizar o método testRuntime de MyClass, o usuário deverá adicionar a classe MyRuntime a declaração do método que utilizar o método testRuntime.
2. Para utilizar o método testException de MyClass, o usuário deverá adicionar a classe MyException a declaração do método que utilizar o método testException.
3. Para utilizar o método testRuntime de MyClass, o usuário deverá inserir o método testRuntime dentro de um bloco try-catch, em que a exceção MyRuntime é tratada.
4. Para utilizar o método testException de MyClass, o usuário deverá inserir o método testException dentro de um bloco try-catch, em que a exceção MyException é tratada.

A respeito dessas asserções, assinale a alternativa correta.

a. apenas as assertivas I e II.

b. apenas as assertivas I e III.

c. apenas as assertivas II e III.

d. apenas as assertivas II e IV.

e. apenas as assertivas III e IV.

Considere o seguinte programa escrito na sintaxe Java:

public class MyRunnable implements Runnable {
  public void run() {
    System.out.println("run");
    throw new RuntimeException("exception");
  }

  public static void main(String[] args) {
    Thread thread = new Thread(new MyRunnable());
    thread.start();
    System.out.println("end");
  }
}

Agora, considere as seguintes saídas a serem apresentadas ao usuário, na execução de um programa.

1. run
   java.lang.RuntimeException: exception
2. end
   java.lang.RuntimeException: exception
3. end
   run
   java.lang.RuntimeException: exception
4. run
   end
   java.lang.RuntimeException: exception

Quais das saídas apresentadas são plausíveis de serem visualizadas pelo usuário, na execução da classe MyRunnable.

a. apenas as assertivas I e II.

b. apenas as assertivas I e III.

c. apenas as assertivas II e III.

d. apenas as assertivas II e IV.

e. apenas as assertivas III e IV.

(Poscomp, 2005) Julgue as assertivas a seguir sobre os paradigmas de programação.

1. O paradigma da programação funcional é baseado em funções matemáticas e composição de funções.
2. PROLOG é uma linguagem de programação cuja sintaxe é uma versão simplificada do cálculo de predicados e seu método de inferência é uma forma restrita de Resolução.
3. O conceito de Classe foi primeiramente introduzido por Simula67.
4. O paradigma orientado a objeto surgiu em paralelo ao desenvolvimento de Smalltalk.
5. No paradigma declarativo, programas são expressos na forma de lógica simbólica e usam um processo de inferência lógica para produzir resultados.

A respeito dessas asserções, assinale a alternativa correta.

a. apenas as assertivas I, II, III e IV.

b. apenas as assertivas I, II, III e V.

c. apenas as assertivas I, III, IV e V.

d. apenas as assertivas II, III, IV e V.

e. as assertivas I, II, III, IV e V.

(Poscomp, 2008) Os fragmentos de programas abaixo, enumerados 1, 2 e 3 são implementações para o problema de ordenação usando o algoritmo quicksort.

Programa 1:

quicksort([],[]).
quicksort([Head|Tail], Sorted) :- partition(Head, Tail, Left, Right),
                                  quicksort(Left, SortedL),
                                  quicksort(Right, SortedR),
                                  append(SortedL, [Head|SortedR], Sorted).
partition(Pivot, [], [], []).
partition(Pivot, [Head|Tail], [Head|Left], Right) :- 
                                         Head =< Pivot, 
                                         partition(Pivot, Tail, Left, Right).
partition(Pivot, [Head|Tail], Left, [Head|Right]) :- 
                                         Head > Pivot, 
                                         partition(Pivot, Tail, Left, Right).
append([], List, List).
append([Head|List1], List2, [Head|List3] :- append(List1, List2, List3).

Programa 2:

quicksort [] = []
quicksort (head:tail) = let pivot = head
left = [x|x <- tail,x < pivot]
right = [x|x <- tail,x >= pivot]
in quicksort left ++ [pivot] ++ quicksort right

Programa 3:

void quicksort(int a[], int l, int r) {
  int j;
  if(l < r) {
    j = partition(a, l, r);
    quicksort(a, l, j-1);
    quicksort(a, j+1, r);
  }
}
int partition(int a[], int l, int r) {
  int pivot, i, j, t;
  pivot = a[l]; i = 1; j = r+1;
  while(i    do ++i; while(a[i] <= pivot && i <= r);
    do -–j; while(a[j] > pivot);
    if(i      t = a[i]; a[i] = a[j]; a[j] = t;
    }
  }
  t = a[l]; a[l] = a[j]; a[j] = t;
  return j;
}

Assinale a alternativa que enumera os paradigmas das linguagens com as quais os programas 1, 2 e 3 foram respectivamente implementados.

a. Lógico, imperativo e funcional.

b. Imperativo, funcional e lógico.

c. Funcional, lógico e imperativo.

d. Lógico, funcional e imperativo.

e. Imperativo, lógico e funcional.

(Poscomp, 2007) Analise as seguintes afirmativas.

1. Encapsulamento é a capacidade de uma operação atuar de modos diversos em classes diferentes.
2. Polimorfismo é o compartilhamento de atributos e métodos entre classes com base em um relacionamento hierárquico.
3. Herança consiste no processo de ocultação dos detalhes internos de implementação de um objeto.
4. Sobreposição é a redefinição das funções de um método herdado. Os métodos apresentam assinaturas iguais.
5. Em JAVA, todos os métodos numa classe abstrata devem ser declarados como abstratos.

A partir da análise, pode-se concluir que

a. apenas a afirmativa IV está correta.

b. apenas as afirmativas III e IV estão corretas.

c. apenas as afirmativas I, IV e V estão corretas.

d. apenas as afirmativas I, III e V estão corretas.

e. todas as afirmativas são falsas.

Desenvolva uma função ou um conjunto de funções em LISP, que verifique se determinado elemento está presente nos elementos contidos em uma lista, como no exemplo a seguir.

(ocorrencia '6 '(1 2 (3 4 (5 6) 7 8) 9))
T

(ocorrencia '10 '(1 2 (3 4 (5 6) 7 8) 9))
NIL

(defun ocorrencia (elemento lista)
  (cond
    ((null lista) nil)
    ((consp (car lista))
      (or (ocorrencia elemento (car lista))
          (ocorrencia elemento (cdr lista)))
    )
    (t
      (or (equal (car lista) elemento)
          (ocorrencia elemento (cdr lista)))
    )
  )
)

Desenvolva um predicado last(L, X) em PROLOG, que é satisfeito quando o termo X é o último elemento da lista L.

?- last([a, b, c, d], d).
true

?- last([a, b, c, d], c).
false

last([X], X) :- !.
last([_|L], X) :- last(L, X).