Python - Somme minimale de caractères consécutifs

Présentation

En programmation Python, la tâche consistant à trouver la somme minimale de caractères consécutifs dans chaque chaîne peut être un problème courant dans différentes applications. Le but est d'identifier la sous-chaîne qui rapporte la plus petite somme lorsque l'on considère les valeurs ASCII de ses caractères. Cet article explore différentes manières d'aborder les problèmes à l'aide de Python. L'article introduit d'abord l'importance de trouver la somme minimale de caractères consécutifs et sa pertinence dans la résolution de problèmes pratiques. Il souligne l’importance d’algorithmes efficaces pour optimiser les calculs de somme minimale.

Python − Somme minimale de caractères consécutifs

En programmation Python, la tâche de trouver le plus petit caractère contigu complet dans chaque chaîne implique de distinguer la sous-chaîne dans la chaîne qui donne le plus petit tout en considérant les valeurs ASCII de ses caractères. L’objectif est de déterminer la sous-chaîne qui produit globalement la plus petite parmi toutes les sous-chaînes possibles.

Pour résoudre ce problème, nous pouvons utiliser différentes méthodes et approches en Python. Ces méthodes incluent la répétition d'une chaîne et le comptage des parties entières de sous-chaînes consécutives, leur comparaison et le suivi du plus petit entier rencontré. En considérant la valeur ASCII du caractère et en effectuant les calculs appropriés, il est possible de trouver la sous-chaîne qui donne le plus petit entier.

Python fournit des fonctions et fonctionnalités intégrées qui facilitent l'exécution de ces méthodes. Des fonctions comme ord() peuvent être utilisées pour obtenir la valeur ASCII d'un caractère, tandis que les boucles et les instructions conditionnelles nous permettent de parcourir la chaîne et d'effectuer les calculs nécessaires. En utilisant ces fonctionnalités, nous avons pu résoudre le problème avec succès et obtenir la somme minimale requise de caractères consécutifs.

Méthode 1 : Utiliser la force brute

L'approche principale est probablement une stratégie de force brute consistant à répéter toutes les sous-chaînes séquentielles possibles dans une chaîne donnée. Voici les étapes pour résoudre le problème en utilisant cette méthode :

Algorithme

Étape 1 :Initialisez la variable min_sum avec une valeur énorme (par exemple l'infini) pour garder une trace de la somme minimale.

Étape 2 : Utilisez deux boucles imbriquées pour mettre en évidence toutes les sous-chaînes possibles de la chaîne donnée. La boucle externe détermine l'index de début de la sous-chaîne et la boucle interne détermine l'index de fin.

Étape 3 : Utilisez la fonction sum() intégrée de Python ou calculez l'intégralité de la sous-chaîne actuelle en mettant physiquement l'accent sur la sous-chaîne et en incluant la valeur du caractère. p>

Étape 4 : Comparez l'ensemble calculé avec la somme minimale actuelle (min_sum). Si l'intégrité calculée est le minimum, min_sum est promu à l'intégrité minimale inutilisée.

Étape 5 : Répétez les étapes 3 et 4 pour toutes les sous-chaînes.

Étape 6 :Renvoyer la somme minimale finale (min_sum) comme résultat.

Exemple

def minimum_sum_of_consecutive_chars(string):
    min_sum = float('inf')
    length = len(string)

    for i in range(length):
        for j in range(i, length):
            substring = string[i:j+1]
            current_sum = sum(ord(c) for c in substring)
            min_sum = min(min_sum, current_sum)

    return min_sum

    
string = "abcde"
print(minimum_sum_of_consecutive_chars(string))

Sortie

97

Méthode 2 : Utiliser la programmation dynamique

La deuxième méthode utilise la programmation dynamique pour résoudre plus efficacement le problème de la somme minimale de caractères consécutifs. Cette méthode évite les doubles calculs en stockant les résultats des sous-problèmes dans des tables mémoire. Voici les étapes pour mettre en œuvre cette approche :

Algorithme

Étape 1 :Définissez la fonction définie par l'utilisateur. Déterminez la longueur de la chaîne.

Étape 2 :Initialisez le cas de base. Définissez memo[i][i] (composant coin à coin) sur la valeur ASCII du caractère de la liste i dans la chaîne.

Étape 3 : Insistez sur toutes les sous-chaînes de longueur l de 2 à la longueur de la chaîne. Pour chaque sous-chaîne, mettez en surbrillance toutes les listes de départ

Étape 4 : Calculez la somme de la sous-chaîne actuelle et mettez à jour le paragraphe correspondant dans la table mémoire.

Étape 5 : Enfin, retournez le plus petit tout du coin supérieur droit de la feuille mémo.

Exemple

def minimum_sum_of_consecutive_chars(string):
    length = len(string)
    memo = [[0] * length for _ in range(length)]

    for i in range(length):
        memo[i][i] = ord(string[i])

    for l in range(2, length + 1):
        for i in range(length - l + 1):
            j = i + l - 1
            memo[i][j] = memo[i][j - 1] + ord(string[j])

    return min(memo[i][j] for i in range(length) for j in range(i, length))

  
string = "abcde"
print(minimum_sum_of_consecutive_chars(string))

Sortie

97

Méthode 3 : Utiliser la fenêtre coulissante

La troisième méthode, appelée méthode de la fenêtre glissante, optimise la méthode précédente et améliore l'efficacité en éliminant les calculs redondants. Au lieu de parcourir toutes les sous-chaînes possibles, cette approche maintient une fenêtre glissante représentant la sous-chaîne actuellement considérée. Voici les étapes pour mettre en œuvre l'approche de la fenêtre glissante :

Algorithme

Étape 1 :Initialisez deux pointeurs, début et conclusion, au début de la chaîne.

Étape 2 : Initialisez la variable current_sum pour suivre la somme de la fenêtre actuelle.

Étape 3 : Initialisez min_sum et rendez-le infini

Étape 4 : Renvoyer la somme minimale (min_sum) comme résultat.

Exemple

def minimum_sum_of_consecutive_chars(string):
    start = 0
    end = 0
    length = len(string)
    current_sum = ord(string[0])
    min_sum = float('inf')

    while end < length:
        if current_sum < min_sum:
            min_sum = current_sum

        end += 1

        if end < length:
            current_sum += ord(string[end])

        while current_sum >= min_sum and start < end:
            current_sum -= ord(string[start])
            start += 1

    return min_sum

    
string = "abcde"
print(minimum_sum_of_consecutive_chars(string))

Sortie

97

Conclusion

Nous avons examiné trois manières différentes de comprendre le plus petit problème de caractères consécutifs en Python. Nous discutons d'une approche par contrainte de force brute, d'une approche de programmation dynamique et d'une approche par fenêtre glissante. Chaque méthode a ses propres étapes, exécution de code et sortie, démontrant différentes approches algorithmiques du problème. En comprenant ces méthodes, vous pouvez choisir la solution la mieux adaptée à vos besoins spécifiques et optimiser le calcul du nombre minimum de caractères consécutifs en Python.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!