MC102 - Algoritmos e Programação de Computadores
MC102 Horários Plano de
desenvolvimento Cronograma Oferecimentos
anteriores

Gabarito da Prova2

Q01  Q02  Q03  Q04  Q05  Q06  Q07  Q08  Q09  Q10  Q11  Q12  Q13 

Q01 (0.6)

Considere a definição de lista e indique para cada operação abaixo o seu resultado ou a ocorrência de um erro: 
lista = [0, 3, 6]
lista + 5                 
lista + [5]                 
[lista, 5]                 
[lista] + [5]                 

[0, 3, 6, 5]  [0, 3, 6, [5]]  [[0, 3, 6], [5]]
[[0, 3, 6], 5]  Erro!

Gabarito:

lista = [0, 3, 6]
lista + 5 Erro! ✓
lista + [5] [0, 3, 6, 5] ✓
[lista, 5] [[0, 3, 6], 5] ✓
[lista] + [5] [[0, 3, 6], 5] ✓

Pontuação: pesos iguais para todos os itens.

Outras alternativas:

(50% => 0.30) 
lista = [0, 3, 6]
lista + 5 [0, 3, 6, 5] ×
lista + [5] Erro! ×
[lista, 5] [[0, 3, 6], 5] ✓
[lista] + [5] [[0, 3, 6], 5] ✓

(50% => 0.30) 
lista = [0, 3, 6]
lista + 5 Erro! ✓
lista + [5] [0, 3, 6, 5] ✓
[lista, 5] [[0, 3, 6], [5]] ×
[lista] + [5] [[0, 3, 6], [5]] ×

(25% => 0.15) 
lista = [0, 3, 6]
lista + 5 [0, 3, 6, 5] ×
lista + [5] [0, 3, 6, 5] ✓
[lista, 5] Erro! ×
[lista] + [5] [[0, 3, 6], [5]] ×

(0% => 0.00) 
lista = [0, 3, 6]
lista + 5 [0, 3, 6, 5] ×
lista + [5] [0, 3, 6, [5]] ×
[lista, 5] Erro! ×
[lista] + [5] [[0, 3, 6], [5]] ×

Q02 (0.6)

Considere a definição de tupla e indique para cada operação abaixo o seu resultado ou a ocorrência de um erro: 
tupla = (1, 2, 3)
tupla + 4                 
tupla + (4)                 
tupla + (4,)                 
(tupla, 4)                 

(1, 2, 3, 4)  (1, 2, 3, (4))  ((1, 2, 3), 4)
((1, 2, 3), (4))  Erro!

Gabarito:

tupla = (1, 2, 3)
tupla + 4 Erro! ✓
tupla + (4) Erro! ✓
tupla + (4,) (1, 2, 3, 4) ✓
(tupla, 4) ((1, 2, 3), 4) ✓

Pontuação: pesos iguais para todos os itens.

Outras alternativas:

(50% => 0.30) 
tupla = (1, 2, 3)
tupla + 4 Erro! ✓
tupla + (4) (1, 2, 3, 4) ×
tupla + (4,) Erro! ×
(tupla, 4) ((1, 2, 3), 4) ✓

(50% => 0.30) 
tupla = (1, 2, 3)
tupla + 4 Erro! ✓
tupla + (4) ((1, 2, 3), (4)) ×
tupla + (4,) (1, 2, 3, 4) ✓
(tupla, 4) (1, 2, 3, 4) ×

(0% => 0.00) 
tupla = (1, 2, 3)
tupla + 4 (1, 2, 3, 4) ×
tupla + (4) ((1, 2, 3), (4)) ×
tupla + (4,) Erro! ×
(tupla, 4) (1, 2, 3, 4) ×

Q03 (0.6)

Considere a definição inicial de lista_de_tuplas e indique para cada linha de código abaixo se ocorrerá um erro ou se a operação será bem sucedida. 
lista_de_tuplas = [("A", 1), ("B", 2)]
lista_de_tuplas[0] = ("A", 1)      
lista_de_tuplas[2] = ("C", 3)      
lista_de_tuplas[0] = ["A", 1]      
lista_de_tuplas[0][1] = "A"      

Sucesso!  Erro!

Gabarito:

lista_de_tuplas = [("A", 1), ("B", 2)]
lista_de_tuplas[0] = ("A", 1) Sucesso! ✓
lista_de_tuplas[2] = ("C", 3) Erro! ✓
lista_de_tuplas[0] = ["A", 1] Sucesso! ✓
lista_de_tuplas[0][1] = "A" Erro! ✓

Pontuação: pesos iguais para todos os itens.

Outras alternativas:

(50% => 0.30) 
lista_de_tuplas = [("A", 1), ("B", 2)]
lista_de_tuplas[0] = ("A", 1) Sucesso! ✓
lista_de_tuplas[2] = ("C", 3) Sucesso! ×
lista_de_tuplas[0] = ["A", 1] Erro! ×
lista_de_tuplas[0][1] = "A" Erro! ✓

(50% => 0.30) 
lista_de_tuplas = [("A", 1), ("B", 2)]
lista_de_tuplas[0] = ("A", 1) Erro! ×
lista_de_tuplas[2] = ("C", 3) Erro! ✓
lista_de_tuplas[0] = ["A", 1] Sucesso! ✓
lista_de_tuplas[0][1] = "A" Sucesso! ×

(0% => 0.00) 
lista_de_tuplas = [("A", 1), ("B", 2)]
lista_de_tuplas[0] = ("A", 1) Erro! ×
lista_de_tuplas[2] = ("C", 3) Sucesso! ×
lista_de_tuplas[0] = ["A", 1] Erro! ×
lista_de_tuplas[0][1] = "A" Sucesso! ×

Q04 (0.6)

Considere a definição inicial de dicio e indique para cada atribuição ou operação abaixo se ocorrerá um erro ou se a execução será bem sucedida. 
dicio = {"Python": 120, "C": 110}
dicio["Python"] = 100      
dicio["Ada"] = 10      
dicio["Python"] > dicio["C"]      
dicio["Python"] > dicio["Fortran"]      

Sucesso!  Erro!

Gabarito:

dicio = {"Python": 120, "C": 110}
dicio["Python"] = 100 Sucesso! ✓
dicio["Ada"] = 10 Sucesso! ✓
dicio["Python"] > dicio["C"] Sucesso! ✓
dicio["Python"] > dicio["Fortran"] Erro! ✓

Pontuação: pesos iguais para todos os itens.

Outras alternativas:

(75% => 0.45) 
dicio = {"Python": 120, "C": 110}
dicio["Python"] = 100 Sucesso! ✓
dicio["Ada"] = 10 Sucesso! ✓
dicio["Python"] > dicio["C"] Erro! ×
dicio["Python"] > dicio["Fortran"] Erro! ✓

(25% => 0.15) 
dicio = {"Python": 120, "C": 110}
dicio["Python"] = 100 Erro! ×
dicio["Ada"] = 10 Erro! ×
dicio["Python"] > dicio["C"] Sucesso! ✓
dicio["Python"] > dicio["Fortran"] Sucesso! ×

(25% => 0.15) 
dicio = {"Python": 120, "C": 110}
dicio["Python"] = 100 Erro! ×
dicio["Ada"] = 10 Sucesso! ✓
dicio["Python"] > dicio["C"] Erro! ×
dicio["Python"] > dicio["Fortran"] Sucesso! ×

Q05 (0.8)

Considere os trechos de código a seguir e indique para cada um deles se ocorrerá um erro ou se a execução será bem sucedida. 
def soma(a, b) :
  return a + b + c

c = soma(3, 5)
       
def soma(a, b) :
  return a + b

r = soma(3, 5, 10)
      

Sucesso!  Erro!

Gabarito:

def soma(a, b) :
  return a + b + c

c = soma(3, 5)
 Erro! ✓ 
def soma(a, b) :
  return a + b

r = soma(3, 5, 10)
 Erro! ✓

Pontuação: pesos iguais para os dois itens.

Outras alternativas:

(0% => 0.00) 
def soma(a, b) :
  return a + b + c

c = soma(3, 5)
 Sucesso! × 
def soma(a, b) :
  return a + b

r = soma(3, 5, 10)
 Sucesso! ×

(50% => 0.40) 
def soma(a, b) :
  return a + b + c

c = soma(3, 5)
 Erro! ✓ 
def soma(a, b) :
  return a + b

r = soma(3, 5, 10)
 Sucesso! ×

(50% => 0.40) 
def soma(a, b) :
  return a + b + c

c = soma(3, 5)
 Sucesso! × 
def soma(a, b) :
  return a + b

r = soma(3, 5, 10)
 Erro! ✓

Q06 (0.8)

Complete o programa abaixo de maneira que seja escrito o valor absoluto de a - b. 
def subtrai(x, y):
  r = x - y
  return r

a = int(input())
b = int(input())
if a >= b:
                   
else:
                   
print(r)

subtrai(a, b)  subtrai(b, a)  r = subtrai(a, b)
r = subtrai(b, a)

Gabarito:

def subtrai(x, y):
  r = x - y
  return r

a = int(input())
b = int(input())
if a >= b:
  r = subtrai(a, b) ✓
else:
  r = subtrai(b, a) ✓
print(r)

Pontuação: pesos iguais para os dois itens.

Outras alternativas:

(0% => 0.00) 
def subtrai(x, y):
  r = x - y
  return r

a = int(input())
b = int(input())
if a >= b:
  subtrai(b, a) ×
else:
  subtrai(a, b) ×
print(r)

(0% => 0.00) 
def subtrai(x, y):
  r = x - y
  return r

a = int(input())
b = int(input())
if a >= b:
  subtrai(a, b) ×
else:
  subtrai(b, a) ×
print(r)

(0% => 0.00) 
def subtrai(x, y):
  r = x - y
  return r

a = int(input())
b = int(input())
if a >= b:
  r = subtrai(b, a) ×
else:
  r = subtrai(a, b) ×
print(r)

Q07 (0.8)

Analise a função misterio e indique os valores a serem escritos na saída ou a ocorrência de um erro. 
def misterio(A) :
   for i in range(len(A) - 1) :
       A[i] = A[i + 1]
A = [[0, 2], [2, 4], [4, 8]]
misterio(A)
print(A)
                          
B = [[0, 2], [2, 4], [4, 8]]
C = B
misterio(C)
print(B)
                         

[[0, 2], [2, 4], [4, 8]]  [[2, 4], [4, 8], [4, 8]]
[[2, 2], [4, 4], [8, 8]]  Erro!

Gabarito:

A = [[0, 2], [2, 4], [4, 8]]
misterio(A)
print(A)
 [[2, 4], [4, 8], [4, 8]] ✓ 
B = [[0, 2], [2, 4], [4, 8]]
C = B
misterio(C)
print(B)
 [[2, 4], [4, 8], [4, 8]] ✓

Pontuação: pesos iguais para os dois itens.

Outras alternativas:

(50% => 0.40) 
A = [[0, 2], [2, 4], [4, 8]]
misterio(A)
print(A)
 [[2, 4], [4, 8], [4, 8]] ✓ 
B = [[0, 2], [2, 4], [4, 8]]
C = B
misterio(C)
print(B)
 [[0, 2], [2, 4], [4, 8]] ×

(0% => 0.00) 
A = [[0, 2], [2, 4], [4, 8]]
misterio(A)
print(A)
 [[2, 2], [4, 4], [8, 8]] × 
B = [[0, 2], [2, 4], [4, 8]]
C = B
misterio(C)
print(B)
 [[0, 2], [2, 4], [4, 8]] ×

(0% => 0.00) 
A = [[0, 2], [2, 4], [4, 8]]
misterio(A)
print(A)
 Erro! × 
B = [[0, 2], [2, 4], [4, 8]]
C = B
misterio(C)
print(B)
 Erro! ×

Estrutura de Dados para Campeonatos de Futebol

Uma partida de um jogo de futebol pode ser descrita por uma tupla da seguinte forma: 
partida = (time_casa, gols_casa, time_visitante, gols_visitante)

Uma lista de tuplas no formato acima pode descrever um campeonato com n partidas: 
campeonato = [(time_casa, gols_casa, time_visitante, gols_visitante)0,
              (time_casa, gols_casa, time_visitante, gols_visitante)1, ...,
              (time_casa, gols_casa, time_visitante, gols_visitante)n-1]

Nas próximas questões, vamos escrever funções que percorrem estruturas como estas para obter informações sobre um campeonato.

Q08 (0.4)

Complete a função abaixo para contar o número de empates em um campeonato. Lembre-se que o campeonato será representado por uma lista de tuplas no formato: 
campeonato = [(time_casa, gols_casa, time_visitante, gols_visitante)0,
              (time_casa, gols_casa, time_visitante, gols_visitante)1, ...,
              (time_casa, gols_casa, time_visitante, gols_visitante)n-1]

def n_empates(campeonato) :
  n = 0
  for p in campeonato :
     if                                      :
        n += 1
  return n

p[0] == p[1]  p[0] == p[2]  p[1] == p[3]
campeonato[p][0] == campeonato[p][2]
campeonato[p][1] == campeonato[p][3]

Gabarito:

def n_empates(campeonato) :
  n = 0
  for p in campeonato :
     if p[1] == p[3] ✓ :
        n += 1
  return n

Pontuação: 100% para escolha da alternativa correta.

Outras alternativas: 0%.

Q09 (0.8)

Complete a função abaixo para retornar apenas a sublista de jogos em que time competiu. Lembre-se que o campeonato será representado por uma lista de tuplas no formato: 
campeonato = [(time_casa, gols_casa, time_visitante, gols_visitante)0,
              (time_casa, gols_casa, time_visitante, gols_visitante)1, ...,
              (time_casa, gols_casa, time_visitante, gols_visitante)n-1]

def partidas_time(campeonato, time) :
    sublista = []
    for p in campeonato :
        if                               :
                             
    return sublista

time in p[0]  p[0] == time and p[2] == time
p[0] == time or p[2] == time
sublista.append(p)
sublista += p

Gabarito:

def partidas_time(campeonato, time) :
    sublista = []
    for p in campeonato :
        if p[0] == time or p[2] == time ✓ :
           sublista.append(p) ✓
    return sublista

Pontuação: pesos iguais para os dois itens.

Outras alternativas:

(50% => 0.40) 
def partidas_time(campeonato, time) :
    sublista = []
    for p in campeonato :
        if p[0] == time or p[2] == time ✓ :
           sublista += p ×
    return sublista

(50% => 0.40) 
def partidas_time(campeonato, time) :
    sublista = []
    for p in campeonato :
        if time in p[0] × :
           sublista.append(p) ✓
    return sublista

(0% => 0.00) 
def partidas_time(campeonato, time) :
    sublista = []
    for p in campeonato :
        if p[0] == time and p[2] == time × :
           sublista += p ×
    return sublista

Q10 (0.8)

Complete a função abaixo para escrever os placares de um campeonato no seguinte formato: 
Jogo 1: 2 x 0
Jogo 2: 1 x 5
...
Lembre-se que o campeonato será representado por uma lista de tuplas: 
camp = [(time_casa, gols_casa, time_visitante, gols_visitante)0,
        (time_casa, gols_casa, time_visitante, gols_visitante)1, ...,
        (time_casa, gols_casa, time_visitante, gols_visitante)n-1]

def escreve_placares(camp) :
  for i in range(len(camp)) :
      print("Jogo: ",     , end="") 
      print(                               )

i  i+1
camp[i][1], "x", camp[i][3]
camp[i+1][1], "x", camp[i+1][3]

Gabarito:

def escreve_placares(camp) :
  for i in range(len(camp)) :
      print("Jogo: ",i+1 ✓, end="") 
      print(camp[i][1], "x", camp[i][3] ✓)

Pontuação: pesos iguais para os dois itens.

Outras alternativas:

(50% => 0.40) 
def escreve_placares(camp) :
  for i in range(len(camp)) :
      print("Jogo: ",i+1 ✓, end="") 
      print(camp[i+1][1], "x", camp[i+1][3] ×)

(50% => 0.40) 
def escreve_placares(camp) :
  for i in range(len(camp)) :
      print("Jogo: ",i ×, end="") 
      print(camp[i][1], "x", camp[i][3] ✓)

(0% => 0.00) 
def escreve_placares(camp) :
  for i in range(len(camp)) :
      print("Jogo: ",i ×, end="") 
      print(camp[i+1][1], "x", camp[i+1][3] ×)

Q11 (0.8)

Complete o código para que o programa produza o desenho ilustrado abaixo. 
*****
***
*


def recursiva(n) :
  if n > 0 :
                     
                     

recursiva(5)

recursiva(n - 1)  recursiva(n - 2)  print(n * "*")

Gabarito:

def recursiva(n) :
  if n > 0 :
     print(n * "*") ✓
     recursiva(n - 2) ✓

recursiva(5)

Pontuação: pesos iguais para os dois itens.

Outras alternativas:

(50% => 0.40) 
def recursiva(n) :
  if n > 0 :
     print(n * "*") ✓
     recursiva(n - 1) ×

recursiva(5)

(0% => 0.00) 
def recursiva(n) :
  if n > 0 :
     recursiva(n - 1) ×
     print(n * "*") ×

recursiva(5)

(0% => 0.00) 
def recursiva(n) :
  if n > 0 :
     recursiva(n - 2) ×
     print(n * "*") ×

recursiva(5)

Q12 (1.2)

Complete o código para que o programa produza o desenho ilustrado abaixo. 
+
++
+
+++
+
++
+


def recursiva(n) :
  if n > 0 :
                     
                     
                     

recursiva(3)

recursiva(n - 1)  print(n * "+")

Gabarito:

def recursiva(n) :
  if n > 0 :
     recursiva(n - 1) ✓
     print(n * "+") ✓
     recursiva(n - 1) ✓

recursiva(3)

Pontuação: pesos iguais para todos os itens.

Outras alternativas:

(33% => 0.40) 
def recursiva(n) :
  if n > 0 :
     recursiva(n - 1) ✓
     recursiva(n - 1) ×
     print(n * "+") ×

recursiva(3)

(33% => 0.40) 
def recursiva(n) :
  if n > 0 :
     print(n * "+") ×
     recursiva(n - 1) ×
     recursiva(n - 1) ✓

recursiva(3)

Q13 (1.2)

Leia o algoritmo de ordenação implementado abaixo. Note que após a operação de troca, devido à chamada à função random.randint(0,3), teremos apenas 25% de probabilidade de termos o conteúdo corrente de lista escrito na saída padrão. Desta forma, a saída ilustrará um subconjunto dos passos feitos ao longo da execução do algoritmo. 
import random

def ordena(lista):
    print("lista =", lista)
    for i in range(len(lista)):
       for j in range(len(lista) - i - 1):
          if lista[j] > lista[j + 1]:
             # troca elementos lista[j] e lista[j + 1]
             lista[j], lista[j + 1] = lista[j + 1], lista[j]
             if random.randint(0,3) == 0 :
                  print("lista =", lista)
Tente entender o comportamento do algoritmo e identificá-lo dentre os estudados neste semestre. Em seguida, analise as linhas abaixo e selecione a única alternativa* que poderia ser uma saída obtida a partir da chamada: 
ordena([9, 3, 7, 5, 6, 4])
*Esta questão está apresentada como múltipla escolha em ambos as versões de prova.

Gabarito:

(100% => 1.20) 
lista = [9, 3, 7, 5, 6, 4]
lista = [3, 7, 5, 9, 6, 4]
lista = [3, 5, 7, 6, 4, 9]
lista = [3, 5, 6, 4, 7, 9]
lista = [3, 5, 4, 6, 7, 9]

(0% => 0.00) 
lista = [9, 3, 7, 5, 6, 4]
lista = [3, 7, 5, 9, 6, 4]
lista = [3, 7, 5, 6, 9, 4]
lista = [3, 5, 6, 7, 9, 4]
lista = [3, 4, 5, 6, 7, 9]

(0% => 0.00) 
lista = [9, 3, 7, 5, 6, 4]
lista = [3, 9, 7, 5, 6, 4]
lista = [3, 7, 9, 5, 6, 4]
lista = [3, 5, 7, 9, 6, 4]
lista = [3, 5, 6, 7, 9, 4]

(0% => 0.00) 
lista = [9, 3, 7, 5, 6, 4]
lista = [3, 9, 7, 5, 6, 4]
lista = [3, 4, 7, 5, 6, 9]
lista = [3, 4, 5, 7, 6, 9]
lista = [3, 4, 5, 6, 7, 9]
Pontuação total: 10.0