Turmas - 1º Semestre de 2025
Turmas
1º Semestre de 2025

Considere o seguinte programa, escrito na sintaxe da linguagem de programação C.

void troca(int a, int b)
{
  int temp = a;
  a = b;
  b = temp;
}

int main()
{
  int list[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
  int i = 5;

  troca(i, list[i]);
}

Com base no programa apresentado, avalie as assertivas a seguir.

1. Caso os parâmetros sejam passados por nome, o valor final da variável list será {1, 2, 3, 4, 5, 5, 7, 8, 9}.
2. Caso os parâmetros sejam passados por valor-resultado, o valor final da variável list será {1, 2, 3, 4, 5, 5, 7, 8, 9}.
3. Caso os parâmetros sejam passados por nome, o valor final da variável list será {1, 2, 3, 4, 5, 6, 5, 8, 9}.
4. Caso os parâmetros sejam passados por referência, o valor final da variável list será {1, 2, 3, 4, 5, 6, 5, 8, 9}.

A respeito dessas assertivas, 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.

Desenvolva uma função ou um conjunto de funções em LISP, que retorne os elementos de uma lista na ordem inversa, como no exemplo a seguir.

(print (inverter-lista '(1 2 3 4 5 6 7 8 9)))
(9 8 7 6 5 4 3 2 1)

(defun inverter-lista (lista)
  (if (null lista)
    nil
    (append (inverter-lista (cdr lista)) (list (car lista)))))

(Poscomp, 2024) Analise a execução a seguir considerando que todos os arquivos de cabeçalho necessários estão inclusos no tempo de compilação e que o programa executa ininterruptamente do início até o seu término.

int lbm = 0;

void * func(void *i)
{
  lbm = lbm + 1;
}

int main (void)
{
  int i;
  pthread_t t[10];

  for (i = 0; i < 10; i++)
  {
    pthread_create(&t[i], NULL, func, NULL);
  }

  for (i = 0; i < 10; i++)
  {
    pthread_join(t[i], NULL);
  }

  printf("%d", lbm);
}

Assinale a alternativa que melhor representa o resultado da execução do programa acima.

a. lbm = 0

b. lbm = 1

c. lbm = 9

d. lbm ≤ 10

e. lbm ≥ 10

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, desde que a mesma tenha suporte a Tratamento de Exceções, implemente 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 um, lançar a exceção AException;
• se n for um número primo, menor do que mil, lançar a exceção BException;
• se n for um número primo, maior do que mil, lançar a exceção CException;
• se n não for um número primo, lançar a exceção DException.

public class Questao04
{
  public void isPrime(final int n)
  {
    if (n < 2)
    {
      throw new AException();
    }

    for (int i = 2; i < n; i++)
    {
      if (n % i == 0)
      {
        throw new DException();
      }
    }

    if (n < 1000)
    {
      throw new BException();
    }
    else
    {
      throw new CException();
    }
  }

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

    int n = 1;

    try
    {
      app.isPrime(n);
    }
    catch (final AException exception)
    {
      System.out.println("Valor inválido!");
    }
    catch (final BException exception)
    {
      System.out.println("Número primo, menor do que 1000!");
    }
    catch (final CException exception)
    {
      System.out.println("Número primo, maior do que 1000!");
    }
    catch (final DException exception)
    {
      System.out.println("Número não é primo!");
    }
  }
}

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();
  }
}

Considere o seguinte programa, escrito na sintaxe da linguagem de programação C.

int a;

void sub1()
{
  printf("%d", a);
}

void sub2(void (*subx)())
{
  a = 1;
  subx();
}

void sub3()
{
  a = 2;
  sub2(sub1);
}

int main()
{
  a = 3;
  sub3();
}

Um aspecto interessante de subprogramas passados como parâmetros é a questão referente ao ambiente de referenciamento correto para executar o subprograma passado. Com base no programa apresentado, avalie as asserções a seguir.

1. Caso seja utilizado a vinculação rasa, o valor impresso será 1.
2. Caso seja utilizado a vinculação profunda, o valor impresso será 3.
3. Caso seja utilizado a vinculação ad hoc, o valor impresso será 1.
4. Caso seja utilizado a vinculação rasa, o valor impresso será 2.

A respeito dessas assertivas, 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.

Um número Tribonacci assemelha-se a um número de Fibonacci, mas em vez de começarmos com dois termos pré-definidos, a sequência é iniciada com três termos pré-determinados, e cada termo posterior é a soma dos três termos precedentes. Os primeiros números de uma pequena sequência Tribonacci são: 0, 0, 1, 1, 2, 4, 7, 13, 24, 44, 81, 149, 274, 504, 927, 1705, 3136, 5768, 10609, 19513, 35890, 66012, 121415, 223317, … Desenvolva um programa em PROLOG, que apresente o enésimo termo da sequência de Tribonacci, como no exemplo a seguir.

?- tribonacci(10, T), write(T), nl. % 44

tribonacci(1, 0) :- !.
tribonacci(2, 0) :- !.
tribonacci(3, 1) :- !.
tribonacci(N, R) :- N1 is N - 1, N2 is N - 2, N3 is N - 3, tribonacci(N1, F1), tribonacci(N2, F2), tribonacci(N3, F3), R is F1 + F2 + F3.

(Poscomp, 2024) Analise o seguinte diagrama de classes da UML (Linguagem de Modelagem Unificada) e assinale a alternativa que contém o(s) elemento(s) polimórfico(s).

a. A relação entre as classes Ponto e Quadro.

b. Os atributos -x e -y da classe Ponto.

c. Os métodos +getX() e +getY() da classe Ponto.

d. Os métodos +print() das classes Ponto e Círculo.

e. O método +setRaio() da classe Círculo.

Desenvolva um tipo de dado abstrato chamada Square para representar um quadrado, ou seja, um quadrilátero regular com quatro lados de mesmo comprimento. A classe possui um único atributo denominado side, do tipo float/double, que representa o lado do quadrado. O construtor da classe recebe como parâmetro o lado do quadrado, cujo valor deve ser maior ou igual a zero. O lado do quadrado pode ser obtido pelo usuário por meio do método getSide(). A classe também apresenta os métodos area(), diagonal() e perimeter(), que retornam a área, a diagonal e o perímetro do quadrado, respectivamente. A área de um quadrado de lado l é obtida pela fórmula l². A diagonal de um quadrado de lado l é obtida pela fórmula √2 * l. O perímetro de um quadrado de lado l é obtido pela fórmula 4 * l. Utilize a linguagem de programação de sua preferência, desde que a mesma tenha suporte para Tipos de Dados Abstratos.

/**
 * Encapsulamento dos atributos do quadrado
 * Arquivo Square.h
 */
typedef struct square Square;

/**
 * Construtor do quadrado
 *
 * @param side o lado do quadrado
 * @return a instância do quadrado
 */
Square* create (double);

/**
 * Destrutor do quadrado
 *
 * @param instance a instância do quadrado
 */
void destroy (Square*);

/**
 * Retornar o lado do quadrado
 *
 * @param instance a instância do quadrado
 * @return o lado do quadrado
 */
double getSide (Square*);

/**
 * Retornar a área do quadrado
 *
 * @param instance a instância do quadrado
 * @return a área do quadrado
 */
double area (Square*);

/**
 * Retornar a diagonal do quadrado
 *
 * @param instance a instância do quadrado
 * @return a diagonal do quadrado
 */
double diagonal (Square*);

/**
 * Retornar o perímetro do quadrado
 *
 * @param instance a instância do quadrado
 * @return o perímetro do quadrado
 */
double perimeter (Square*);

/**
 * #include <math.h>
 * #include <stdlib.h>
 * #include "Square.h"
 *
 * Encapsulamento dos atributos do quadrado
 * Arquivo Square.c
 */
struct square
{
  /**
   * O lado do quadrado
   */
  double side;
};

/**
 * Construtor do quadrado
 *
 * @param side o lado do quadrado
 * @return a instância do quadrado
 */
Square* create (double side)
{
  if (side < 0)
  {
    return NULL;
  }

  Square* instance = (Square*) malloc(sizeof(Square));

  instance->side = side;

  return instance;
}

/**
 * Destrutor do quadrado
 *
 * @param instance a instância do quadrado
 */
void destroy (Square* instance)
{
  free(instance);
}

/**
 * Retornar o lado do quadrado
 *
 * @param instance a instância do quadrado
 * @return o lado do quadrado
 */
double getSide (Square* instance)
{
  return instance->side;
}

/**
 * Retornar a área do quadrado
 *
 * @param instance a instância do quadrado
 * @return a área do quadrado
 */
double area (Square* instance)
{
  return pow(instance->side, 2);
}

/**
 * Retornar a diagonal do quadrado
 *
 * @param instance a instância do quadrado
 * @return a diagonal do quadrado
 */
double diagonal (Square* instance)
{
  return sqrt(2) * instance->side;
}

/**
 * Retornar o perímetro do quadrado
 *
 * @param instance a instância do quadrado
 * @return o perímetro do quadrado
 */
double perimeter (Square* instance)
{
  return 4 * instance->side;
}

/**
 * #include <stdio.h>
 * #include "Square.h"
 *
 * Programa de teste
 * Arquivo main.c
 */
int main()
{
  Square* instance = create(5);

  printf("Lado do quadrado: %f\n", getSide(instance));

  printf("Área do quadrado: %f\n", area(instance));

  printf("Diagonal do quadrado: %f\n", diagonal(instance));

  printf("Perímetro do quadrado: %f\n", perimeter(instance));

  destroy(instance);

  return 0;
}