Pour le problème, une solution en une ligne avec différentes variantes a été proposée :
def solve(string):
    s = ''.join([ch for ch in string if ch in '()'])
    return len(max(s.split(')'), key=len))


Solution fonctionnelle ? Non.
Si on donne à cette fonction la chaîne (()(())), la bonne réponse (profondeur) est : 3, mais la fonction retourne 2. La logique du "nombre de parenthèses ouvrantes consécutives" échoue sur toute structure imbriquée qui n'est pas la première branche.

☝🏻 Comment résoudre correctement
Une solution ennuyeuse mais fonctionnelle avec une complexité O(n) implique un simple compteur. On parcourt la chaîne, on incrémente le compteur pour (, on le décrémente pour ) et à chaque étape on met à jour le maximum global.

def max_depth(s: str) -> int:
    current_depth = 0
    max_depth = 0
    
    for char in s:
        if char == '(':
            current_depth += 1
            max_depth = max(max_depth, current_depth)
        elif char == ')':
            current_depth -= 1
            # Validation de la correction (optionnelle)
            if current_depth < 0:
                return -1 
                
    return max_depth if current_depth == 0 else -1


Variante pour les esthètes (fonctionnelle) :

Si on tient absolument à une seule ligne, on peut utiliser accumulate. On mappe les parenthèses en 1 et -1, on calcule les sommes préfixes (accumulate) et on prend le maximum.

from itertools import accumulate

def solve_poly(s: str) -> int:
    # Transforme '(' en 1, ')' en -1, le reste en 0
    depths = accumulate(1 if c == '(' else -1 if c == ')' else 0 for c in s)
    return max(depths, default=0)


#algosobes