SolveConPython

Nivel: Principiante
Tema: Listas, validación de entradas, bucles, casos borde, tests con pytest
Objetivo: Implementar tu propia versión de “máximo” sin usar max(), manejando listas vacías y entradas inválidas de forma segura.

Enunciado

Crea una función llamada encontrar_maximo(lista) que:

1. Reciba un valor lista.
2. Si lista es None, devuelva None.
3. Si lista no es una lista (list), lance TypeError.
4. Si la lista está vacía, devuelva None.
5. Devuelva el valor máximo contenido en la lista.
6. No uses la función integrada max().

Para este reto, asume que la lista contiene valores comparables entre sí (por ejemplo, todos números).

Ejemplos

• encontrar_maximo([1, 3, 2]) → 3
• encontrar_maximo([-5, -1, -10]) → -1
• encontrar_maximo([]) → None
• encontrar_maximo(None) → None
• encontrar_maximo("123") → TypeError

Pistas

1. Empieza suponiendo que el primer elemento es el máximo.
2. Recorre la lista comparando cada valor con el máximo actual.
3. Actualiza el máximo cuando encuentres un valor mayor.
4. Maneja los casos borde antes del bucle.

Solución explicada (paso a paso)

1. Si la entrada es None, no hay máximo posible → None.
2. Si no es una lista, lanzamos TypeError para evitar comportamientos inesperados.
3. Si la lista está vacía, devolvemos None.
4. Inicializamos el máximo con el primer elemento.
5. Recorremos el resto de la lista y actualizamos el máximo cuando corresponde.
6. Al final del recorrido, devolvemos el valor máximo encontrado.

def encontrar_maximo(lista: list | None):
    """
    Encuentra el valor máximo en una lista sin usar max().
    Reglas:
    - None -> None
    - No list -> TypeError
    - Lista vacía -> None
    - Lista con valores -> valor máximo
    """
    if lista is None:
        return None
    if not isinstance(lista, list):
        raise TypeError("El parámetro 'lista' debe ser una lista o None.")
    if len(lista) == 0:
        return None
    maximo = lista[0]
    for valor in lista[1:]:
        if valor > maximo:
            maximo = valor
    return maximo

import pytest
from reto_03_encontrar_maximo import encontrar_maximo
def test_lista_normal():
    assert encontrar_maximo([1, 3, 2]) == 3
def test_numeros_negativos():
    assert encontrar_maximo([-5, -1, -10]) == -1
def test_lista_con_un_elemento():
    assert encontrar_maximo([7]) == 7
def test_lista_vacia():
    assert encontrar_maximo([]) is None
def test_none_devuelve_none():
    assert encontrar_maximo(None) is None
def test_tipo_incorrecto_lanza_typeerror():
    with pytest.raises(TypeError):
        encontrar_maximo("123")

Ejecuta:

• pytest -q

Variantes para subir de nivel (opcional)

1. Soportar tuplas: aceptar list o tuple
2. Validar tipos internos: lanzar error si hay valores no comparables
3. Devolver índice y valor: (indice, valor_maximo)
4. Implementar mínimo y máximo en una sola pasada

Lo que aprendiste

• Cómo recorrer listas y mantener un estado
• Cómo manejar casos borde de forma explícita
• Por qué evitar funciones “mágicas” al aprender fundamentos
• Cómo validar comportamiento con tests automatizados

Accede al código completo y a los tests en GitHub para ejecutar y modificar la solución localmente.

Continúa con Reto #4 — Frecuencia de caracteres en una cadena para seguir practicando lógica con strings y diccionarios.