MC102 - Algoritmos e Programação de Computadores

MC102 Horários Plano de
desenvolvimento Cronograma Oferecimentos
anteriores

Gabarito do Exame

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

Q01 (0.4)

Indique o valor, acompanhado de seu respectivo tipo entre parênteses, de cada uma das expressões abaixo:

Expressão	Valor (Tipo)
2 + 3
2.5 + 2.5
2 + int(3.0)
15 // 3

5 (int) 5.0 (float)

Gabarito:

Expressão	Valor (Tipo)
2 + 3	5 (int) ✓
2.5 + 2.5	5.0 (float) ✓
2 + int(3.0)	5 (int) ✓
15 // 3	5 (int) ✓

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

Outras alternativas:

(75% => 0.30)

Expressão	Valor (Tipo)
2 + 3	5 (int) ✓
2.5 + 2.5	5.0 (float) ✓
2 + int(3.0)	5.0 (float) ×
15 // 3	5 (int) ✓

(75% => 0.30)

Expressão	Valor (Tipo)
2 + 3	5 (int) ✓
2.5 + 2.5	5.0 (float) ✓
2 + int(3.0)	5 (int) ✓
15 // 3	5.0 (float) ×

(25% => 0.10)

Expressão	Valor (Tipo)
2 + 3	5.0 (float) ×
2.5 + 2.5	5.0 (float) ✓
2 + int(3.0)	5.0 (float) ×
15 // 3	5.0 (float) ×

(25% => 0.10)

Expressão	Valor (Tipo)
2 + 3	5 (int) ✓
2.5 + 2.5	5 (int) ×
2 + int(3.0)	5.0 (float) ×
15 // 3	5.0 (float) ×

Q02 (0.4)

Indique o valor, acompanhado de seu respectivo tipo entre parênteses, de cada uma das expressões abaixo:

Expressão	Valor (Tipo)
3 / 3
4 % 3
3.0 % 3
3.0 // -3

-1 (int) 0 (int) 1 (int)
-1.0 (float) 0.0 (float) 1.0 (float)

Gabarito:

Expressão	Valor (Tipo)
3 / 3	1.0 (float) ✓
4 % 3	1 (int) ✓
3.0 % 3	0.0 (float) ✓
3.0 // -3	-1.0 (float) ✓

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

Outras alternativas:

(75% => 0.30)

Expressão	Valor (Tipo)
3 / 3	1 (int) ×
4 % 3	1 (int) ✓
3.0 % 3	0.0 (float) ✓
3.0 // -3	-1.0 (float) ✓

(25% => 0.10)

Expressão	Valor (Tipo)
3 / 3	1 (int) ×
4 % 3	1 (int) ✓
3.0 % 3	1.0 (float) ×
3.0 // -3	0.0 (float) ×

(25% => 0.10)

Expressão	Valor (Tipo)
3 / 3	1.0 (float) ✓
4 % 3	1.0 (float) ×
3.0 % 3	1.0 (float) ×
3.0 // -3	1.0 (float) ×

(25% => 0.10)

Expressão	Valor (Tipo)
3 / 3	1.0 (float) ✓
4 % 3	1.0 (float) ×
3.0 % 3	1.0 (float) ×
3.0 // -3	1.0 (float) ×

Q03 (0.4)

Indique o valor, acompanhado de seu respectivo tipo entre parênteses, de cada uma das expressões abaixo:

Expressão	Valor (Tipo)
float(3) == int(3.0)
str(3) == str(3.0)
True == "True"
str(not True)

True (bool) False (bool)
"True" (str) "False" (str)

Gabarito:

Expressão	Valor (Tipo)
float(3) == int(3.0)	True (bool) ✓
str(3) == str(3.0)	False (bool) ✓
True == "True"	False (bool) ✓
str(not True)	"False" (str) ✓

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

Outras alternativas:

(75% => 0.30)

Expressão	Valor (Tipo)
float(3) == int(3.0)	True (bool) ✓
str(3) == str(3.0)	False (bool) ✓
True == "True"	"True" (str) ×
str(not True)	"False" (str) ✓

(50% => 0.20)

Expressão	Valor (Tipo)
float(3) == int(3.0)	True (bool) ✓
str(3) == str(3.0)	True (bool) ×
True == "True"	False (bool) ✓
str(not True)	False (bool) ×

(50% => 0.20)

Expressão	Valor (Tipo)
float(3) == int(3.0)	False (bool) ×
str(3) == str(3.0)	False (bool) ✓
True == "True"	"True" (str) ×
str(not True)	"False" (str) ✓

(25% => 0.10)

Expressão	Valor (Tipo)
float(3) == int(3.0)	False (bool) ×
str(3) == str(3.0)	False (bool) ✓
True == "True"	"True" (str) ×
str(not True)	False (bool) ×

Q04 (0.4)

Para cada uma das expressões abaixo, indique o seu valor ou a ocorrência de um erro.

Expressão	Valor
5 + 2 * 2 == 14
(2 < 3) == (2 < 5)
"2 < 3" == "2 < 5"
not True and False or 5 > 3

True False Erro!

Gabarito:

Expressão	Valor
5 + 2 * 2 == 14	True ✓
(2 < 3) == (2 < 5)	True ✓
"2 < 3" == "2 < 5"	False ✓
not True and False or 5 > 3	False ✓

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

Outras alternativas:

(75% => 0.30)

Expressão	Valor
5 + 2 * 2 == 14	True ✓
(2 < 3) == (2 < 5)	True ✓
"2 < 3" == "2 < 5"	*Erro!* ×
not True and False or 5 > 3	False ✓

(50% => 0.20)

Expressão	Valor
5 + 2 * 2 == 14	True ✓
(2 < 3) == (2 < 5)	False ×
"2 < 3" == "2 < 5"	False ✓
not True and False or 5 > 3	*Erro!* ×

(50% => 0.20)

Expressão	Valor
5 + 2 * 2 == 14	False ×
(2 < 3) == (2 < 5)	True ✓
"2 < 3" == "2 < 5"	False ✓
not True and False or 5 > 3	True ×

(0% => 0.00)

Expressão	Valor
5 + 2 * 2 == 14	False ×
(2 < 3) == (2 < 5)	False ×
"2 < 3" == "2 < 5"	*Erro!* ×
not True and False or 5 > 3	True ×

Q05 (0.9)

Complete o programa abaixo de maneira que a partir da leitura de três inteiros distintos seja escrita a soma dos dois maiores.

a = int(input())
b = int(input())
c = int(input())

if                 :
  print("A + B =", a + b)
                      :
  print("A + C =", a + c)
else :
  print("B + C:", b + c)

a > b and a > c a > c and b > c a > b b > c c > b
if elif

Gabarito:

a = int(input())
b = int(input())
c = int(input())

if a > c and b > c ✓ :
  print("A + B =", a + b)
elif ✓ a > b ✓ :
  print("A + C =", a + c)
else :
  print("B + C:", b + c)

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

Outras alternativas:

(66% => 0.59)

a = int(input())
b = int(input())
c = int(input())

if a > c and b > c ✓ :
  print("A + B =", a + b)
elif ✓ c > b × :
  print("A + C =", a + c)
else :
  print("B + C:", b + c)

(33% => 0.30)

a = int(input())
b = int(input())
c = int(input())

if a > c and b > c ✓ :
  print("A + B =", a + b)
if × c > b × :
  print("A + C =", a + c)
else :
  print("B + C:", b + c)

(33% => 0.30)

a = int(input())
b = int(input())
c = int(input())

if a > b and a > c × :
  print("A + B =", a + b)
elif ✓ b > c × :
  print("A + C =", a + c)
else :
  print("B + C:", b + c)

(0% => 0.00)

a = int(input())
b = int(input())
c = int(input())

if a > b and a > c × :
  print("A + B =", a + b)
if × b > c × :
  print("A + C =", a + c)
else :
  print("B + C:", b + c)

Q06 (0.8)

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

@@@@@@@@@
*@@@@@@@*
**@@@@@**
***@@@***
****@****

for i in           :
    print(i * "*", end="")
    print(           * "@", end="")
    print(i * "*")

range(5) range(1,5) range(1,6)
(10 - i) (10 - 2*i) (9 - 2*i)

Gabarito:

for i in range(5) ✓:
    print(i * "*", end="")
    print((9 - 2*i) ✓ * "@", end="")
    print(i * "*")

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

Outras alternativas:

(50% => 0.40)

for i in range(1,5) ×:
    print(i * "*", end="")
    print((9 - 2*i) ✓ * "@", end="")
    print(i * "*")

(0% => 0.00)

for i in range(1,5) ×:
    print(i * "*", end="")
    print((10 - 2*i) × * "@", end="")
    print(i * "*")

(0% => 0.00)

for i in range(1,6) ×:
    print(i * "*", end="")
    print((10 - 2*i) × * "@", end="")
    print(i * "*")

(0% => 0.00)

for i in range(1,6) ×:
    print(i * "*", end="")
    print((10 - i) × * "@", end="")
    print(i * "*")

Q07 (0.8)

Complete o código para que o programa produza a saída abaixo. Note que o uso do comando format() irá garantir que todos os números sejam escritos com dois dígitos.

01 02 03 04 05 06 07 08 09 10 
02 02 03 04 05 06 07 08 09 10 
03 03 03 04 05 06 07 08 09 10 
04 04 04 04 05 06 07 08 09 10 
05 05 05 05 05 06 07 08 09 10 
06 06 06 06 06 06 07 08 09 10 
07 07 07 07 07 07 07 08 09 10 
08 08 08 08 08 08 08 08 09 10 
09 09 09 09 09 09 09 09 09 10 
10 10 10 10 10 10 10 10 10 10

for i in range(1, 11) :
   for j in                :
       print(format(i, "02d"), end=" ")
   for j in                :
       print(format(j, "02d"), end=" ") 
   print()

range(i) range(1,i) range(i, 11)
range(i+1, 10) range(i+1, 11)

Gabarito:

for i in range(1, 11) :
   for j in range(i) ✓ :
       print(format(i, "02d"), end=" ")
   for j in range(i+1, 11) ✓ :
       print(format(j, "02d"), end=" ") 
   print()

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

Outras alternativas:

(50% => 0.40)

for i in range(1, 11) :
   for j in range(1,i) × :
       print(format(i, "02d"), end=" ")
   for j in range(i+1, 11) ✓ :
       print(format(j, "02d"), end=" ") 
   print()

(50% => 0.40)

for i in range(1, 11) :
   for j in range(i) ✓ :
       print(format(i, "02d"), end=" ")
   for j in range(i, 11) × :
       print(format(j, "02d"), end=" ") 
   print()

(0% => 0.00)

for i in range(1, 11) :
   for j in range(1,i) × :
       print(format(i, "02d"), end=" ")
   for j in range(i+1, 10) × :
       print(format(j, "02d"), end=" ") 
   print()

(0% => 0.00)

for i in range(1, 11) :
   for j in range(1,i) × :
       print(format(i, "02d"), end=" ")
   for j in range(i, 11) × :
       print(format(j, "02d"), end=" ") 
   print()

Q08 (0.6)

Considere a seguinte definição de uma variável do tipo string e indique o valor das operações abaixo ou a ocorrência de um erro:

p = "Algoritmo"

p[0]
p[-1]
p[-9]
p[:]
p[:4]
p[4:]

"A" "o" "Algo" "ritmo" "Algoritmo"
Erro!

Gabarito:

p = "Algoritmo"

p[0]	"A" ✓
p[-1]	"o" ✓
p[-9]	"A" ✓
p[:]	"Algoritmo" ✓
p[:4]	"Algo" ✓
p[4:]	"ritmo" ✓

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

Outras alternativas:

(66% => 0.40)

p = "Algoritmo"

p[0]	"A" ✓
p[-1]	"o" ✓
p[-9]	*Erro!* ×
p[:]	*Erro!* ×
p[:4]	"Algo" ✓
p[4:]	"ritmo" ✓

(66% => 0.40)

p = "Algoritmo"

p[0]	"A" ✓
p[-1]	"o" ✓
p[-9]	*Erro!* ×
p[:]	"A" ×
p[:4]	"Algo" ✓
p[4:]	"ritmo" ✓

(33% => 0.20)

p = "Algoritmo"

p[0]	"A" ✓
p[-1]	"o" ✓
p[-9]	*Erro!* ×
p[:]	*Erro!* ×
p[:4]	"o" ×
p[4:]	"o" ×

(0% => 0.00)

p = "Algoritmo"

p[0]	"Algoritmo" ×
p[-1]	*Erro!* ×
p[-9]	*Erro!* ×
p[:]	"A" ×
p[:4]	*Erro!* ×
p[4:]	"o" ×

Q09 (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, 1, 2]

lista + (3, 4)
lista + [3, 4]
lista[3] = (3, 4)
lista + [(3, 4)]

[0, 1, 2, 3, 4] [0, 1, 2, (3, 4)]
[0, 1, 2, [3, 4]] Erro!

Gabarito:

lista = [0, 1, 2]

lista + (3, 4)	*Erro!* ✓
lista + [3, 4]	[0, 1, 2, 3, 4] ✓
lista[3] = (3, 4)	*Erro!* ✓
lista + [(3, 4)]	[0, 1, 2, (3, 4)] ✓

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

Outras alternativas:

(50% => 0.30)

lista = [0, 1, 2]

lista + (3, 4)	*Erro!* ✓
lista + [3, 4]	[0, 1, 2, 3, 4] ✓
lista[3] = (3, 4)	[0, 1, 2, (3, 4)] ×
lista + [(3, 4)]	[0, 1, 2, [3, 4]] ×

(50% => 0.30)

lista = [0, 1, 2]

lista + (3, 4)	[0, 1, 2, (3, 4)] ×
lista + [3, 4]	[0, 1, 2, [3, 4]] ×
lista[3] = (3, 4)	*Erro!* ✓
lista + [(3, 4)]	[0, 1, 2, (3, 4)] ✓

(0% => 0.00)

lista = [0, 1, 2]

lista + (3, 4)	[0, 1, 2, (3, 4)] ×
lista + [3, 4]	[0, 1, 2, [3, 4]] ×
lista[3] = (3, 4)	[0, 1, 2, (3, 4)] ×
lista + [(3, 4)]	*Erro!* ×

Q10 (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 = {"A": 0, "B": 1}

dicio["C"] = "3"
dicio["A" + "B"] = dicio["A"] + dicio["B"]
dicio["D"] == 4
dicio["A"] > dicio["B"]

Sucesso! Erro!

Gabarito:

dicio = {"A": 0, "B": 1}

dicio["C"] = "3"	*Sucesso!* ✓
dicio["A" + "B"] = dicio["A"] + dicio["B"]	*Sucesso!* ✓
dicio["D"] == 4	*Erro!* ✓
dicio["A"] > dicio["B"]	*Sucesso!* ✓

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

Outras alternativas:

(75% => 0.45)

dicio = {"A": 0, "B": 1}

dicio["C"] = "3"	*Sucesso!* ✓
dicio["A" + "B"] = dicio["A"] + dicio["B"]	*Erro!* ×
dicio["D"] == 4	*Erro!* ✓
dicio["A"] > dicio["B"]	*Sucesso!* ✓

(50% => 0.30)

dicio = {"A": 0, "B": 1}

dicio["C"] = "3"	*Erro!* ×
dicio["A" + "B"] = dicio["A"] + dicio["B"]	*Erro!* ×
dicio["D"] == 4	*Erro!* ✓
dicio["A"] > dicio["B"]	*Sucesso!* ✓

(25% => 0.15)

dicio = {"A": 0, "B": 1}

dicio["C"] = "3"	*Erro!* ×
dicio["A" + "B"] = dicio["A"] + dicio["B"]	*Sucesso!* ✓
dicio["D"] == 4	*Sucesso!* ×
dicio["A"] > dicio["B"]	*Erro!* ×

Q11 (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] + 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, 6], [6, 12], [4, 8]]
[[0, 2, 2, 4], [2, 4, 4, 8], [4, 8]] Erro!

Gabarito:

A = [[0, 2], [2, 4], [4, 8]] misterio(A) print(A)	[[0, 2, 2, 4], [2, 4, 4, 8], [4, 8]] ✓
B = [[0, 2], [2, 4], [4, 8]] C = B misterio(C) print(B)	[[0, 2, 2, 4], [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)	[[0, 2, 2, 4], [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, 6], [6, 12], [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)	*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)₀,
              (time_casa, gols_casa, time_visitante, gols_visitante)₁, ...,
              (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.

Q12 (0.6)

Complete a função abaixo para contar o número total de gols em um campeonato. Lembre-se que o campeonato será representado por uma lista de tuplas no formato:

camp = [(time_casa, gols_casa, time_visitante, gols_visitante)₀,
           (time_casa, gols_casa, time_visitante, gols_visitante)₁, ...,
           (time_casa, gols_casa, time_visitante, gols_visitante)_n-1]

def n_gols(camp) :
  n = 0
  for p in camp :
     n +=                        
  return n

p[0] + p[2] p[1] + p[3]
camp[p][0] + camp[p][2] camp[p][1] + camp[p][3]

Gabarito:

def n_gols(camp) :
  n = 0
  for p in camp :
     n += p[1] + p[3] ✓
  return n

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

Outras alternativas: 0%.

Q13 (0.8)

Complete a função abaixo para retornar apenas a sublista de jogos em que houve empate. Lembre-se que o campeonato será representado por uma lista de tuplas no formato:

camp = [(time_casa, gols_casa, time_visitante, gols_visitante)₀,
           (time_casa, gols_casa, time_visitante, gols_visitante)₁, ...,
           (time_casa, gols_casa, time_visitante, gols_visitante)_n-1]

def empates(camp, time) :
    sublista = []
    for p in camp :
        if                          :
                                
    return sublista

p[1] == p[3] camp[p][1] == camp[p][3]
sublista.append(p) sublista += [camp[p]]

Gabarito:

def empates(camp, time) :
    sublista = []
    for p in camp :
        if p[1] == p[3] ✓ :
           sublista.append(p) ✓
    return sublista

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

Outras alternativas:

(50% => 0.40)

def empates(camp, time) :
    sublista = []
    for p in camp :
        if p[1] == p[3] ✓ :
           sublista += [camp[p]] ×
    return sublista

(50% => 0.40)

def empates(camp, time) :
    sublista = []
    for p in camp :
        if camp[p][1] == camp[p][3] × :
           sublista.append(p) ✓
    return sublista

(0% => 0.00)

def empates(camp, time) :
    sublista = []
    for p in camp :
        if camp[p][1] == camp[p][3] × :
           sublista += [camp[p]] ×
    return sublista

Q14 (0.9)

Complete o código para que a chamada recursiva(1) produza o desenho ilustrado abaixo.

*
**
***
****


def recursiva(n) :
  if       :
                     
                     

recursiva(1)

n > 0 n < 5
print(n * "*") recursiva(n - 1)
recursiva(n + 1)

Gabarito:

def recursiva(n) :
  if n < 5 ✓ :
     print(n * "*") ✓
     recursiva(n + 1) ✓

recursiva(1)

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

Outras alternativas:

(33% => 0.30)

def recursiva(n) :
  if n < 5 ✓ :
     recursiva(n + 1) ×
     print(n * "*") ×

recursiva(1)

(33% => 0.30)

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

recursiva(1)

(0% => 0.00)

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

recursiva(1)

Q15 (1.0)

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([8, 2, 5, 4, 1, 3])

^*Esta questão está apresentada como múltipla escolha em ambas as versões do exame.

Gabarito:

(100% => 1.00)

lista = [8, 2, 5, 4, 1, 3]
lista = [2, 5, 8, 4, 1, 3]
lista = [2, 5, 4, 1, 8, 3]
lista = [2, 4, 5, 1, 3, 8]
lista = [2, 1, 3, 4, 5, 8]

(0% => 0.00)

lista = [8, 2, 5, 4, 1, 3]
lista = [2, 5, 4, 8, 1, 3]
lista = [2, 5, 4, 1, 3, 8]
lista = [2, 4, 1, 5, 8, 3]
lista = [2, 1, 3, 4, 8, 5]

(0% => 0.00)

lista = [8, 2, 5, 4, 1, 3]
lista = [2, 8, 5, 4, 1, 3]
lista = [2, 5, 8, 4, 1, 3]
lista = [2, 4, 5, 8, 1, 3]
lista = [1, 2, 4, 5, 8, 3]

(0% => 0.00)

lista = [8, 2, 5, 4, 1, 3]
lista = [1, 2, 5, 4, 8, 3]
lista = [1, 2, 3, 4, 8, 5]
lista = [1, 2, 3, 4, 8, 5]
lista = [1, 2, 3, 4, 5, 8]

Pontuação total: 10.0