A1 - ​Analise o trecho de código abaixo, explique seu funcionamento e explique por que ele poderia ser considerado uma otimização.

    def funcDOIS(lista,num):
        if num == 0 or num == 1:
            return num
        else:
            if lista[num-1] == None:
                lista[num-1] = funcDOIS(lista,num-1)
            if lista[num-2] == None:
                lista[num-2] = funcDOIS(lista,num-2)

        return lista[num-1] + lista[num-2]

A2 ​- Analise os trechos de código abaixo e explique o seu funcionamento e diferenças:

def em_ordem (self, p):
    if not p is None:
        self.em_ordem (p.esq)
        print(p.valor)
        self.em_ordem (p.dir)

def pre_ordem (self, p):
    if not p is None:
        print(p.valor)
        self.pre_ordem (p.esq)
        self.pre_ordem (p.dir)

def pos_ordem (self, p):
    if not p is None:
        self.pos_ordem (p.esq)
        self.pos_ordem (p.dir)
        print(p.valor)

C1 - ​O código a seguir está errado​. Descubra o que o código deveria fazer, quais são os erros e conserte-o. Altamente recomendado que nessa questão você use o debugger do Eclipse ou alguma outra IDE com um bom debugger.

def conquista(primeira,segunda):
  final = ListaEncadeada()
  i = 0
  j = 0

  while i < len(primeira) or j < len(segunda):

    if primeira[i] <= segunda[j]:
      final.append(primeira[i])
      i += 1

    else:
      final.append(segunda[j])
      j += 1

    if i == len(primeira):
      for elem in range(j, segunda):
        final.append(segunda[j])

    else:
      for elem in range(j, primeira):
        final.append(primeira[j])

  return final

Você tem alguma observação de como o uso de Lista Encadeada poderia ser otimizado para essa função?

Q1 - Implemente um programa que recebe duas matrizes e retorna o resultado da multiplicação da primeira matriz pela transposta da segunda. Obs: Matriz transposta é a matriz que se obtém da troca de linhas por colunas de uma dada matriz.

Q2 - ​Um problema bastante recorrente em diversos problemas de computação e estatística é o de determinar raízes ou zeros de uma função. Um dos métodos mais eficientes para isso é o método de Newton-Raphson. Esse é um método iterativo que, a cada iteração, encontra uma melhor aproximação para o zero da função (https://pt.wikipedia.org/wiki/Método_de_Newton-Raphson). A ideia básica é usar a seguinte fórmula para aproximar valores de x:

onde x_n+1 é o valor de x na (n+1)-ésima iteração, f é a função que se deseja calcular a raiz, e f' é sua primeira derivada. Por questões numéricas da implementação computacional de números reais, é comum aceitar como raiz da função um valor próximo a zero (conforme um parâmetro de tolerância definido pelo usuário). Implemente o método de Newton-Raphson em Python para funções polinomiais. Seu programa deve receber como entrada uma lista de coeficientes do polinômio e a tolerância desejada, e deve imprimir o valor de x e o número de iterações necessárias para determiná-lo.

Q3 - ​Implemente um algoritmo em Python que receba como entrada um conjunto de valores e imprima o conjunto potência desse conjunto.