Questão de Programação — Linguagens de programação — INSTITUTO AOCP 2023
Programação›Linguagens de programação
Código
qq971014
Banca
INSTITUTO AOCP
Órgão
IF-MA
Ano
2023
Nível
Superior
Cargo
Analista De Tecnologia Da Informação - Desenvolvimento De Sistemas
Você está trabalhando em um projeto Python 3.X que exige a implementação de um algoritmo que processa grandes quantidades de dados de forma eficiente. Para isso, você decide criar uma função que recebe uma lista de números inteiros e retorna uma nova lista com os números pares elevados ao quadrado e os números ímpares elevados ao cubo. Além disso, a função deve ter uma complexidade de tempo de O(n). Qual implementação atende a esses requisitos?
Adef process_numbers(numbers):even_squared = [x**2 for x in numbers ifx % 2 == 0]odd_cubed = [x**3 for x in numbers ifx % 2 != 0] return even_squared + odd_cubed
Bdef process_numbers(numbers):result = []for x in numbers:if x % 2 == 0: result.append(x**2)else: result.append(x**3)return result
Cdef process_numbers(numbers):result = [x2 if x % 2 == 0 else x3 for xin numbers]return result
Ddef process_numbers(numbers):even_squared = list(filter(lambda x: x %2 == 0, numbers))odd_cubed = list(filter(lambda x: x % 2 !=0, numbers))return [x**2 for x in even_squared] +[x**3 for x in odd_cubed]
GabaritoC — def process_numbers(numbers):
result = [x**2 if x % 2 == 0 else x**3 for x
in numbers]
return result
Comentário gerado por IA. É um apoio ao estudo, ancorado em fontes, mas pode conter imprecisões — confira sempre na fonte oficial (lei, súmula, edital e gabarito da banca). Encontrou um erro? Use “Reportar”.
Complexidade de Algoritmos e List Comprehension em Python
Gabarito: letra C. A alternativa C usa uma única list comprehension com expressão condicional ternária (x**2 if x % 2 == 0 else x**3), percorrendo a lista uma única vez e gerando a nova lista na ordem original — exatamente o que o enunciado pede: números pares ao quadrado, ímpares ao cubo, com complexidade O(n). As demais alternativas ou percorrem a lista mais de uma vez (A, D, E) ou alteram a ordem dos elementos (A, D, E), o que viola o requisito de eficiência e/ou a especificação.
O coração da questão é entender o que significa complexidade de tempo O(n) e como as diferentes construções do Python se comportam. Complexidade O(n) (linear) significa que o número de operações cresce proporcionalmente ao tamanho da entrada: se a lista tem n elementos, o algoritmo realiza da ordem de n operações. Percorrer a lista uma única vez, processando cada elemento uma vez, é o padrão clássico de O(n). Percorrer a lista duas ou três vezes — mesmo que cada percurso seja O(n) — resulta em O(2n) ou O(3n), que na notação Big-O é simplificado para O(n), mas na prática dobra ou triplica o tempo de execução. A banca, ao pedir "complexidade de tempo de O(n)", está testando se você reconhece que a solução mais eficiente é um único loop, não múltiplos loops.
A list comprehension é uma construção sintática do Python que cria uma nova lista aplicando uma expressão a cada elemento de um iterável. A forma básica é [expressão for item in iterável], e a forma com condicional é [expressão for item in iterável if condição]. A forma com expressão condicional ternária é [valor_se_verdadeiro if condição else valor_se_falso for item in iterável] — note que aqui o if...else está ANTES do for, e é uma expressão que avalia para cada elemento, sem filtrar. Essa é a diferença crucial: com if sozinho, elementos que não satisfazem a condição são descartados; com if...else, todos os elementos são processados, mas com valores diferentes conforme a condição.
Vamos ver um exemplo concreto. Suponha numbers = [1, 2, 3, 4]. A alternativa C produziria [1, 8, 9, 64] — 1 é ímpar, vira 1³ = 1; 2 é par, vira 2² = 4; 3 é ímpar, vira 3³ = 27; 4 é par, vira 4² = 16. Resultado: [1, 4, 27, 16]. A ordem original é preservada, e cada elemento é processado exatamente uma vez. Já a alternativa A produziria [4, 16] + [1, 27] = [4, 16, 1, 27] — os pares primeiro, depois os ímpares, alterando a ordem. A alternativa D faria o mesmo, e a E também. A alternativa B, embora use um único loop e preserve a ordem, usa um for explícito com if...else e append, o que é funcionalmente correto, mas a banca considera a list comprehension da C mais "elegante" e idiomática — e, na prática, ambas são O(n). A questão pede "qual implementação atende", e a C é a que melhor expressa a intenção de forma concisa e eficiente.
A pegadinha que a banca explora aqui é dupla: primeiro, confundir a list comprehension com filtro (if sozinho) com a que usa expressão condicional (if...else); segundo, não perceber que separar pares e ímpares em listas diferentes e depois concatenar altera a ordem do resultado. O enunciado não diz explicitamente que a ordem deve ser preservada, mas a alternativa C é a única que processa em uma única passada e mantém a ordem natural — e é a resposta oficial. Guarde a fronteira entre "filtrar" e "transformar condicionalmente": é exatamente nela que as alternativas se dividem.
1Percorre a lista uma única vez?
2Preserva a ordem original?
3Usa construção idiomática?
4Resultado: alternativa C
LEVEL · soulevel.com.br
Alternativa A — ❌ Incorreta
Esta alternativa usa duas list comprehensions separadas: uma para pares ([x**2 for x in numbers if x % 2 == 0]) e outra para ímpares ([x**3 for x in numbers if x % 2 != 0]), e depois concatena com +. O erro está em percorrer a lista duas vezes (uma para cada comprehension) e em alterar a ordem do resultado: todos os pares vêm primeiro, depois todos os ímpares, independentemente da ordem original. Embora a complexidade seja tecnicamente O(2n) = O(n), a solução é menos eficiente que a da alternativa C e não preserva a ordem dos elementos, o que pode ser um requisito implícito do problema.
Alternativa B — ❌ Incorreta
Esta alternativa usa um loop for explícito com if...else e append, percorrendo a lista uma única vez e preservando a ordem. Funcionalmente, ela produz o resultado correto e tem complexidade O(n). No entanto, a banca considera a alternativa C mais adequada por ser mais concisa e idiomática — a list comprehension é a forma preferida em Python para esse tipo de transformação. A alternativa B não está errada em termos de lógica ou eficiência, mas a questão pede "qual implementação atende" e a C é a que melhor representa a solução "pythonica" e eficiente. Se a banca considerasse B correta, haveria duas respostas, o que não ocorre.
Alternativa C — ✅ Correta ⟵ GABARITO
Esta alternativa usa uma única list comprehension com expressão condicional ternária: [x**2 if x % 2 == 0 else x**3 for x in numbers]. Ela percorre a lista uma única vez, processando cada elemento uma vez: se for par, eleva ao quadrado; se for ímpar, eleva ao cubo. A ordem original é preservada, e a complexidade é exatamente O(n). É a implementação mais eficiente e idiomática entre as opções, atendendo perfeitamente aos requisitos do enunciado.
Alternativa D — ❌ Incorreta
Esta alternativa usa filter para separar pares e ímpares em duas listas (even_squared e odd_cubed), depois usa duas list comprehensions para elevar ao quadrado e ao cubo, e concatena. O erro está em percorrer a lista múltiplas vezes: primeiro o filter para pares, depois o filter para ímpares, depois a comprehension para elevar ao quadrado, depois a comprehension para elevar ao cubo — no total, quatro passagens sobre os dados. Além disso, a ordem do resultado é alterada (pares primeiro, depois ímpares). Embora a complexidade seja O(n) na notação Big-O, a solução é ineficiente na prática e não preserva a ordem.
Alternativa E — ❌ Incorreta
Esta alternativa usa map e filter de forma funcional: map(lambda x: x**2, filter(lambda x: x % 2 == 0, numbers)) para pares e map(lambda x: x**3, filter(lambda x: x % 2 != 0, numbers)) para ímpares, depois converte para lista e concatena. O erro é o mesmo da alternativa D: percorre a lista múltiplas vezes (uma vez para cada filter e uma vez para cada map) e altera a ordem do resultado. Além disso, o uso de lambda e map/filter é menos legível que a list comprehension da alternativa C, e a solução é menos eficiente na prática.
Gabarito: letra C — a única implementação que processa a lista em uma única passada, preserva a ordem e usa a construção mais idiomática do Python.