Questão 1: Crie uma função listar_quadrados_impares(n) que receba um limite n e retorne uma lista com os quadrados dos números ímpares (ex: 1^{2}, 3^{2}, 5^{2}, \ldots ) que sejam menores que n .
Exemplo: listar_quadrados_impares(50) deve retornar [1, 9, 25, 49].

Passo 1

O enunciado pede que eu crie uma função chamada listar_quadrados_impares(n) que recebe um limite n e retorna uma lista com os quadrados dos números ímpares — isto é, os valores
1^2,\;3^2,\;5^2,\;\ldots
— que sejam menores que n.
Informações importantes dadas:
  • A função recebe um único parâmetro n.
  • Devemos considerar apenas números ímpares.
  • Devemos calcular o quadrado de cada ímpar e incluir na lista somente se esse quadrado for menor que n.
  • Exemplo fornecido: chamar listar_quadrados_impares(50) deve retornar a lista [1, 9, 25, 49].

Passo 2

Entendendo o que é “número ímpar” e como representá-lo:
  • Um inteiro é ímpar quando deixa resto 1 na divisão por 2, ou seja, seu módulo por 2 é 1.
  • Todos os ímpares não-negativos podem ser escritos como 2k+1 com k inteiro e k\ge 0. Exemplos: para k=0 temos 2\cdot 0 + 1 = 1; para k=1 temos 3; etc.
Como é o quadrado de um ímpar:
  • Se um ímpar é 2k+1, seu quadrado é
(2k+1)^2 = 4k^2 + 4k + 1.
Mas não precisamos necessariamente usar essa fórmula explícita para implementar a função — é só para entender a forma dos valores que vamos gerar.

Passo 3

Condição que define se incluímos o quadrado na lista:
  • Queremos todos os quadrados (2k+1)^2 tais que
(2k+1)^2 < n.
  • Isso implica que os ímpares que testamos satisfazem 2k+1 < \sqrt{n}, ou seja, o maior ímpar a testar é menor que \sqrt{n}. Na prática, em código, é mais simples/econômico gerar ímpares e testar se o quadrado é menor que n até que deixem de ser.

Passo 4

Estratégia de implementação (escolha do método):
  • Método simples e direto (fácil de aplicar numa prova sem muita matemática avançada): começar em i=1 (o primeiro ímpar), calcular i^2 e, enquanto i^2 < n, adicionar i^2 à lista e incrementar i para o próximo ímpar usando i \leftarrow i + 2.
  • Vantagens desse método:
    • É muito claro e fácil de implementar.
    • Não exige cálculo prévio de \sqrt{n} nem conversões de tipos.
    • Tem custo proporcional ao número de quadrados menores que n, ou seja, cerca de O(\sqrt{n}) operações — suficiente e eficiente para o objetivo da questão.
  • Alternativa (opcional): usar compreensão de listas com range(1, int(math.sqrt(n))+1, 2); funciona também, mas envolve calcular a raiz quadrada primeiro. Preferi a versão com while por ser direta e segura em relação a arredondamentos.

Passo 5

Detalhes do algoritmo passo a passo (para você repetir na prova):
  1. Inicializar uma lista vazia resultado = [].
  2. Inicializar a variável i = 1 (primeiro ímpar).
  3. Enquanto i * i < n:
    • Calcular quadrado = i * i.
    • Acrescentar quadrado à lista resultado.
    • Avançar para o próximo ímpar com i = i + 2.
  4. Quando o laço terminar, retornar resultado.
Observações úteis para a prova:
  • Se n \le 1, a condição 1^2 < n falha desde o início e a função deve retornar lista vazia.
  • Testes rápidos:
    • Para n=50: geramos 1^2=1, 3^2=9, 5^2=25, 7^2=49; 9^2=81 já não é menor que 50, então paramos — resultado [1,9,25,49].
    • Para n=1: nenhum quadrado é menor que 1 → resultado [].
    • Para n=2: apenas 1^2=1<2 → resultado [1].

Passo 6

Complexidade e comportamento:
  • Número de iterações aproximado: quantos ímpares têm quadrado menor que n? Se i^2 < n então i < \sqrt{n}. Como pulamos de 2 em 2, número de iterações é aproximadamente \frac{\sqrt{n}}{2}. Portanto a complexidade é O(\sqrt{n}).
  • O algoritmo usa espaço extra proporcional à quantidade de quadrados que retornamos (também O(\sqrt{n})).

Resposta

def listar_quadrados_impares(n):
    resultado = []
    i = 1
    while i * i < n:
        resultado.append(i * i)
        i += 2
    return resultado

Exercícios relacionados