Exercices de logique et de programmation (solutions) : Approches et Optimisation

Compte tenu de cet exercice : (de codewars.com)

Créez une fonction qui renvoie le carré de chaque chiffre d'un nombre.

Par exemple, lors de la saisie de la fonction, le nombre 702 doit renvoyer 4904, puisque le carré de 7 est 49, le carré de 0 est 0 et le carré de 2 est 4. Si la fonction reçoit un zéro, elle doit renvoyer 0.

Le défi sous-jacent de cet exercice est de parcourir un entier chiffre par chiffre et de renvoyer un résultat sous la forme d'un autre entier.

Comme tout en programmation, il est possible de résoudre cet exercice de plusieurs manières. Tout d'abord, résolvons-le en utilisant les propriétés de manipulation de nombres en Python, puis j'expliquerai une autre méthode plus avancée ?.

def square_digits(num):
    if num == 0:
        return 0
    result = ""
    while num > 0:
        num_sqr = (num % 10) ** 2 
        num = num // 10
        result = str(num_sqr) + result 
    return int(result)

Dans ce code, nous évaluons d'abord si un 0 est reçu pour renvoyer un 0, comme indiqué dans l'instruction. Ensuite, nous initialisons la variable résultat sous forme de chaîne vide, créons une boucle while avec la condition num > 0. On définit la variable num_sqr, qui est le carré de chaque chiffre reçu. Avec num % 10 on obtient le dernier chiffre du numéro reçu puis on le met au carré avec **2.

• L'utilisation de num % 10 est une méthode courante pour extraire le dernier chiffre d'un nombre.

• L'expression num = num // 10 élimine le dernier chiffre du nombre en avançant chaque chiffre.

Une autre façon de le résoudre est de convertir le nombre en une chaîne et de parcourir cette chaîne avec une boucle for :

def square_digits(num):
    result = ""
    for digit in str(num):
        result += str(int(digit)**2)
    return int(result)

Ce code est plus optimal, il a moins de lignes et le parcours est très bien compris, en plus du fait qu'il n'est pas nécessaire d'évaluer s'il reçoit un 0. En Python il est possible de parcourir un caractère chaîne par caractère avec une boucle for. Nous utilisons cette fonctionnalité pour parcourir le numéro reçu, en le convertissant avec str(num) en chaîne. Nous créons la variable résultat sous la forme d'une chaîne vide, à laquelle sera concaténé un caractère qui est le résultat d'un chiffre converti en entier et élevé à 2, le tout converti en chaîne. Ensuite, nous renvoyons le résultat converti en entier.

• La concaténation de chaînes dans une boucle peut être moins efficace en termes de performances pour de très grands nombres, mais est parfaitement acceptable pour la plupart des cas d'utilisation.

*Une manière plus avancée et "élégante" * consiste à utiliser Understanding Generators et le motodo .join. Je vous présente d'abord le code et nous le décomposerons en expliquant ces termes.

def square_digits(num):
    return int(''.join(str(int(digit)**2) for digit in str(num)))

Ce premier code est peu lisible si vous ne connaissez pas les concepts
qui le composent.

L'expression str(int(digit)**2) pour digit in str(num) est un _generator _(Generator Expression) qui itère sur chaque chiffre dans la représentation sous forme de chaîne du nombre num.
Pour chaque chiffre, il le convertit en un entier (int(digit)), le met au carré (**2), puis le reconvertit en chaîne (str(...)). Ensuite, avec ''.join(...), vous prenez une séquence (dans ce cas, le générateur) et concaténez tous les éléments en une seule chaîne. Ici, tous les chiffres carrés sont combinés en une seule chaîne sans aucun séparateur (car la chaîne entre les guillemets simples est vide '').

Comme on le voit, les différentes manières de résoudre un exercice démontrent les niveaux de connaissance dans une langue. Toutes les solutions sont correctes si elles réussissent les tests, mais certaines sont plus efficaces et plus lisibles que d’autres. Le choix de l'approche dépend du contexte et de ce qui est priorisé dans chaque cas :

• Lisibilité : C'est crucial lorsque d'autres développeurs vont lire et maintenir votre code. Un code clair et facile à comprendre réduit le risque d’erreurs et facilite sa maintenance. ?

• Efficacité : important lorsque vous travaillez avec de gros volumes de données ou dans des applications où les performances sont critiques. Un code plus optimisé peut faire une grande différence en termes de vitesse et de consommation de ressources. ?

• Simplicité : Pour les cas où la priorité est de résoudre le problème rapidement et directement, comme dans les prototypes ou les exercices didactiques. La simplicité facilite souvent le débogage et les tests du code. ?

Lors du développement, il est important de trouver un équilibre entre ces considérations, en adaptant la solution aux besoins spécifiques du projet ou de la tâche.

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!