Questão 19: Crie uma função substituir_maior_que_limite(lista, limite) que receba uma lista e um limite. A função deve modificar a lista (ou retornar uma nova) onde todos os números maiores que limite são substituídos pelo próprio limite.

Passo 1

O enunciado pede uma função chamada substituir_maior_que_limite que receba dois parâmetros: uma lista e um limite. A função deve “substituir” — isto é, trocar — todos os elementos da lista que forem maiores que o limite pelo próprio valor do limite. Informações relevantes dadas (assumidas porque a questão foi formulada corretamente):
  • A função recebe uma lista (vamos assumir que a lista contém números: inteiros ou reais).
  • A função recebe um valor chamado limite (também numérico).
  • Para cada elemento da lista, se ele for maior que o limite, deve ser substituído pelo limite; caso contrário, deve permanecer igual.
  • A questão permite modificar a lista original ou retornar uma nova lista; farei uma solução clara para os dois comportamentos e explicarei como escolher.

Passo 2

Ideia fundamental (explicando passo a passo): para cada posição da lista precisamos comparar o elemento com o limite e, se for maior, atribuir o limite naquela posição. Em Python há duas formas naturais:
  • Modificar a lista no lugar (in-place): iteramos pelos índices e alteramos lista[i] quando necessário. Vantagem: usa pouca memória extra; desvantagem: altera o objeto passado como argumento.
  • Criar uma nova lista (não modifica a original): construímos uma nova lista onde cada valor é o mínimo entre o elemento e o limite. Vantagem: original preservada; desvantagem: usa espaço adicional.
Vou primeiro mostrar a versão que modifica a lista original e retorna a lista modificada (prática comum e clara). Depois mostro uma versão que retorna uma nova lista sem modificar a original.

Passo 3

Vamos à versão que modifica a lista in-place (linha a linha explicada). Código completo abaixo; em seguida explico cada linha.
def substituir_maior_que_limite(lista, limite):
    """
    Modifica a lista passada: todos os números maiores que 'limite' são
    substituídos por 'limite'. Retorna a própria lista modificada.
    """
    for i in range(len(lista)):
        if lista[i] > limite:
            lista[i] = limite
    return lista
Explicação linha a linha:
  • def substituir_maior_que_limite(lista, limite): define a função com os dois parâmetros exigidos.
  • O docstring explica o comportamento: modifica a lista e retorna-a (útil para permitir encadeamento ou inspeção).
  • for i in range(len(lista)): itera pelos índices de 0 até o último índice. Usamos índices porque vamos atribuir lista[i] = ....
  • if lista[i] > limite: compara o elemento atual com o limite. Se for maior, entra no bloco.
  • lista[i] = limite faz a substituição no próprio lugar da lista.
  • return lista devolve a lista modificada; isso é opcional (a alteração já foi feita), mas é conveniente.

Passo 4

Agora a versão que cria e retorna uma nova lista (não altera a original). A maneira mais pythonica é usar list comprehension com uma expressão condicional ou usar min(x, limite):
def substituir_maior_que_limite_nova(lista, limite):
    """
    Retorna uma nova lista onde cada elemento é no máximo 'limite'.
    A lista original NÃO é modificada.
    """
    return [x if x <= limite else limite for x in lista]
    # alternativa equivalente: return [min(x, limite) for x in lista]
Explicação:
  • A expressão [x if x <= limite else limite for x in lista] percorre cada x em lista e coloca x na nova lista se x <= limite, caso contrário coloca limite.
  • min(x, limite) faz a mesma coisa: o menor entre x e limite será x quando x <= limite e será limite quando x > limite.

Passo 5

Complexidade e quando usar cada versão:
  • Tempo: ambas as versões percorrem a lista uma vez, então tempo O(n) onde n é len(lista).
  • Espaço: versão in-place usa O(1) espaço extra; versão que cria nova lista usa O(n) espaço adicional.
  • Use in-place quando quiser economizar memória ou explicitamente alterar o objeto passado. Use a versão que retorna nova lista quando precisar preservar a lista original.

Passo 6

Exemplos práticos (mostro entrada e saída para ambas versões):
Exemplo 1 (in-place):
a = [1, 5, 10, 3]
substituir_maior_que_limite(a, 6)   # retorna [1, 5, 6, 3]
# e agora a == [1, 5, 6, 3]
Exemplo 2 (nova lista):
b = [2, 8, 7]
c = substituir_maior_que_limite_nova(b, 6)  # c == [2, 6, 6]
# e b permanece [2, 8, 7]
Observações sobre casos-limite:
  • Lista vazia funciona normalmente (retorna lista vazia).
  • Números negativos e floats funcionam — comparação > entre números é válida.
  • Se a lista contiver elementos não numéricos (strings, None, etc.), a comparação x > limite vai gerar TypeError. Se quiser uma função robusta que ignore ou trate não-numéricos, posso mostrar uma versão com verificação.

Passo 7

Versão “defensiva” que ignora elementos não comparáveis (opcional):
def substituir_maior_que_limite_segura(lista, limite):
    """
    Modifica a lista, mas se algum elemento não puder ser comparado com 'limite',
    deixa-o como está (não tenta substituir).
    """
    for i in range(len(lista)):
        try:
            if lista[i] > limite:
                lista[i] = limite
        except TypeError:
            # elemento não comparável: deixamos como está
            pass
    return lista

Passo 8

Resumo e sugestão prática: se na sua prova o enunciado não exige preservar a lista, use a versão simples e clara que modifica in-place (primeira apresentada). Ela é fácil de escrever sem erro e tem complexidade mínima. Se precisar preservar a entrada, use a versão com list comprehension.
Vai dar tudo certo — pratique escrevendo ambas algumas vezes e testando com diferentes listas. Força, você consegue!

Resposta

def substituir_maior_que_limite(lista, limite):
    """
    Modifica a lista passada: todos os números maiores que 'limite' são
    substituídos por 'limite'. Retorna a própria lista modificada.
    """
    for i in range(len(lista)):
        if lista[i] > limite:
            lista[i] = limite
    return lista

Exercícios relacionados