Recherche de site Web

Défis de codage Python pour les développeurs débutants - Code et explications

Apprendre Python peut être difficile, surtout si vous n’écrivez pas suffisamment de code. En tant que débutant, vous pouvez suivre des leçons et des tutoriels sans vous entraîner seul, ce qui rend l’apprentissage de la langue plus difficile.

La vérité est que vous ne pouvez pas vraiment apprendre la programmation sans écrire du code. C'est grâce à ce processus que vous apprenez de nouvelles choses et découvrez à quel point de petites erreurs, comme manquer un devis ou un espace, peuvent vous frustrer pendant des heures.

Aucun cours ne peut vous apprendre les subtilités de Python comme le fait la recherche et la résolution des erreurs.

C'est pourquoi les défis de codage sont importants si vous commencez votre parcours de codage. Ils vous aident à mettre en pratique vos connaissances et à renforcer votre confiance.

Donc, pour vous aider à commencer à coder davantage, voici huit défis Python que vous pouvez essayer en tant que débutant.

Et voici un conseil : essayez vraiment de résoudre le défi par vous-même après avoir lu la question/l'invite. Si vous êtes bloqué, vous pouvez consulter le code ci-dessous et l'explication pour vous aider à le comprendre.

Voici les défis :

  1. Défi Python n°1 : Vérifier si une liste est triée
  2. Défi Python n°2 : Convertir un nombre binaire en décimal
  3. Défi Python n°3 : m'aime, ne m'aime pas
  4. Défi Python n°4 : Le défi de la séquence Tribonacci
  5. Défi Python n°5 : Masquer un numéro de carte de crédit
  6. Défi Python n°6 : SpongeCase
  7. Défi Python n°7 : Cryptage César
  8. Défi Python n°8 : le produit est-il divisible par la somme ?

Tous ces défis vous aident à améliorer vos compétences en résolution de problèmes et en réflexion algorithmique. Vous acquerrez également de l'expérience dans l'écriture et le test de code pour garantir l'exactitude et l'efficacité.

Défi Python n°1 : Vérifier si une liste est triée

Le défi : écrire une fonction qui vérifie si une liste de nombres donnée est triée par ordre croissant ou décroissant.

Voici la solution de code :

def is_sorted(lst):
    asc, desc = True, True
    for i in range(len(lst) - 1):
        if lst[i] > lst[i + 1]:
            asc = False
    for i in range(len(lst) - 1):
        if lst[i] < lst[i + 1]:
            desc = False
    return asc or desc

Explication du code :

Dans le code ci-dessus, nous définissons une fonction is_sorted qui prend une list comme paramètre. Nous initialisons deux booléens, asc (pour croissant) et desc (pour décroissant) à True.

Nous parcourons ensuite la liste. Si le ième élément de la liste est supérieur au (i+1)ème élément, l'indicateur asc est défini sur False, indiquant que la liste n'est pas triée par ordre croissant.

Ensuite, nous parcourons à nouveau la liste. Si le ième élément de la liste est plus petit que le i+1 ème élément, l'indicateur desc est mis à False, indiquant que la liste n'est pas triée par ordre décroissant.

Si un élément s'avère supérieur à l'élément suivant, l'indicateur asc est défini sur False. Dans la boucle, nous vérifions si le ième élément de la liste est supérieur au i+1ème élément.

for i in range(len(lst) - 1):
    if lst[i] < lst[i + 1]:
        desc = False

Nous renvoyons True si asc ou desc est True. Cela signifie que la liste est triée par ordre croissant ou décroissant.

Défi Python n°2 : convertir des nombres binaires en décimaux

Le défi : Écrire une fonction qui convertit un nombre binaire en son équivalent décimal.

Voici la solution de code :

def binary_to_decimal(binary):
    decimal, i = 0, 0
    while(binary != 0):
        dec = binary % 10
        decimal = decimal + dec * pow(2, i)
        binary = binary//10
        i += 1
    return decimal

Explication du code :

Dans le code ci-dessus, nous définissons une fonction binary_to_decimal qui prend un nombre binaire comme paramètre. Nous avons ensuite initialisé les variables decimal et i à 0.

La variable decimal est utilisée pour stocker la valeur décimale résultante et la variable i représente la position actuelle lors du traitement d'un nombre binaire, à partir de 0.

Nous parcourons chaque chiffre binaire jusqu'à ce que tous les chiffres du nombre binaire deviennent 0.

while binary != 0:

Maintenant, nous extrayons le chiffre le moins significatif du nombre binaire actuel à l’aide de l’opérateur module.

dec = binary % 10

Et puis nous convertissons le chiffre extrait en son équivalent décimal en le multipliant par 2 puissance élevée à i.

decimal = decimal + dec * pow(2, i)

Ensuite, nous supprimons le chiffre traité :

Binary = binary // 10

Et incrémentez la position i pour traiter le chiffre binaire suivant :

i += 1

Enfin, nous renvoyons la valeur décimale calculée.

Défi Python n°3 : m'aime, ne m'aime pas

Le défi : étant donné un nombre entier n, imprimez une chaîne qui alterne entre les expressions « m'aime » et « ne m'aime pas » pour chaque nombre de 1 à n.

La séquence doit commencer par « Loves me » et alterner en conséquence.

Voici la solution de code :

def phrase_loves_me_not(n):
    phrases = []
    for i in range(1,n+1):
        if i % 2 != 0:
            phrases.append("Loves me")
        else:
            phrases.append("Loves me not")
    return ", ".join(phrases)

Explication du code :

Nous définissons une fonction phrase_loves_me_not qui prend un seul paramètre n.

Ensuite, nous initialisons une liste vide, phrases, qui stocke le résultat pour chaque nombre de 1 à n.

Nous itérons de 1 à n inclus :

for i in range(1, n+1):

Nous vérifions ensuite les indices impairs. Si le nombre est impair, nous ajoutons « Loves me » à la liste des « phrases ».

if i % 2 != 0:
    phrases.append("Loves me")

Pour les indices pairs, nous ajoutons « Ne m'aime pas » dans la liste des « phrases ».

else:
    phrases.append("Loves me not")

Nous utilisons ensuite la méthode join pour concaténer tous les éléments de la liste « phrases » en une seule chaîne et renvoyer cette chaîne.

Enfin, nous renvoyons la chaîne résultante.

return ", ".join(phrases)

Défi Python n°4 : Le défi de la séquence Tribonacci

Le défi « Séquence de Tribonacci » est une variante de la célèbre séquence de Fibonacci, où chaque nombre est la somme des trois nombres précédents.

Par exemple, 0, 1, 1, 2, 4, 7…

Le défi : Écrivez une fonction qui renvoie le nième nombre de la séquence Tribonacci.

Voici la solution de code :

def find_nth_tribonacci(n):
    # Base cases for n = 0, 1, 2
    if n == 0:
        return 0
    elif n == 1 or n == 2:
        return 1
    # Initialize the first three terms of the Tribonacci sequence
    a, b, c = 0, 1, 1
    for i in range(3, n + 1):
        next_term = a + b + c
        a, b, c = b, c, next_term
    return c

Explication du code :

Tout d'abord, nous définissons une fonction nommée find_nth_tribonacci qui prend un nombre n comme paramètre.

Nous définissons ensuite les cas de base comme :

  • Si n est 0, la fonction renvoie 0.
  • Si n est 1 ou 2, la fonction renvoie 1.

Remarque : Ces conditions gèrent les valeurs de départ de la séquence Tribonacci.

On initialise ensuite les trois premières valeurs de la séquence Tribonacci, de n=0 à n=2.

a, b, c = 0, 1, 1

Ensuite, nous itérons de 3 jusqu'au nombre n, où nous calculons le terme suivant en additionnant les trois termes précédents (a, b et c). Nous mettons également à jour les valeurs de a, b et c vers l'ensemble suivant de trois termes dans la séquence.

for i in range(3, n + 1):
    next_term = a + b + c
    a, b, c = b, c, next_term

A la fin de la boucle, c contient la valeur du nième terme de la séquence Tribonacci, nous renvoyons donc c.

return c

Défi Python n°5 : Masquer un numéro de carte de crédit

Écrivez une fonction qui prend un numéro de carte de crédit et le transforme en une chaîne où tous les chiffres sauf les quatre derniers sont remplacés par des astérisques.

Voici la solution de code :

def mask_credit_card(card_number):
    card=str(card_number)
    return "*"*(len(card) - 4) + (card[-4:])

Explication du code :

Nous définissons une fonction mask_credit_card qui prend card_number comme paramètre.

Tout d’abord, nous convertissons le nombre en chaîne.

card = str(card_number)

Ensuite, pour masquer le card_number, nous générons une chaîne d'astérisques d'une longueur égale au nombre total de chiffres de la carte de crédit moins quatre. Cela masque tous les chiffres sauf les quatre derniers chiffres.

"*"*(len(card) - 4)

Ensuite, nous utilisons l’opération slice pour récupérer les quatre derniers chiffres du numéro de carte de crédit.

card[-4:]

Enfin, nous renvoyons le résultat concaténé de la chaîne d'astérisque et des quatre derniers chiffres du numéro de carte.

return "*"*(len(card) - 4) + card[-4:]

Défi Python n°6 : SpongeCase

SpongeCase est un style de texte dans lequel les lettres apparaissent alternativement en minuscules et en majuscules. Par exemple, le mot dans épongeCase serait sPoNgEcAsE.

Le défi : écrire une fonction qui convertit la chaîne donnée en éponge.

Voici la solution de code :

def to_spongecase(text):
    result = []
    i = 0
    for char in text:
        if char.isalpha():
            if i % 2 == 0:
                result.append(char.lower())
            else:
                result.append(char.upper())
            i += 1
        else:
            result.append(char)
           
    return "".join(result)

Explication du code :

Nous définissons une fonction to_spongecase qui prend une chaîne text comme paramètre.

Ensuite, nous initialisons un résultat de liste vide et comptons i à 0.

Nous parcourons la fonction sur chaque caractère de la chaîne d'entrée et vérifions si le le caractère actuel est alphabétique.

for char in text:
    if char.isalpha():

Si le caractère à l'index i (ajusté pour les caractères alphabétiques uniquement) est pair, nous ajoutons le résultat avec le caractère converti en minuscule.

if i % 2 == 0:
    result.append(char.lower())

Si l'index est impair, nous ajoutons le résultat avec le caractère converti en majuscule.

else:
    result.append(char.upper())

Après traitement d'un caractère alphabétique, l'index i est incrémenté.

Dans le cas de caractères non alphabétiques, ajoutez-les à la liste des résultats tels qu'ils apparaissent, sans alterner leur casse.

Une fois que tous les caractères ont été traités, nous les combinons en une chaîne en utilisant join .

return "".join(result)

Défi Python n°7 : Cryptage César

Le chiffrement César (également connu sous le nom de chiffrement César) est une technique de chiffrement simple qui fonctionne en décalant les lettres du message en texte clair d'un certain nombre de positions.

Le défi : créer une fonction comportant deux paramètres : une chaîne à coder et un entier représentant le nombre de positions de chaque lettre doit être décalée.

Voici la solution de code :

def caesar_encryption(text, shift):
    result = ""
    for char in text:
        if char.isalpha():
            start = ord('A') if char.isupper() else ord('a')
            shifted = (ord(char) - start + shift) % 26 + start
            result += chr(shifted)
        else:
            result += char
    return result

Explication du code :

Nous définissons une fonction caesar_encryption qui prend deux paramètres : une chaîne text et un entier shift.

Ensuite on initialise une chaîne vide pour accumuler les caractères encodés.

result = ""

Ensuite, nous parcourons chaque caractère du texte de la chaîne d’entrée.

Pour les caractères alphabétiques, nous calculons le nouveau caractère après avoir appliqué le décalage.

Ensuite, nous ajoutons les caractères non alphabétiques comme les nombres au résultat inchangé.

for char in text:
    if char.isalpha():
        start = ord('A') if char.isupper() else ord('a')
    shifted = (ord(char) - start + shift) % 26 + start

Alors comment calculer le nouveau personnage ?

Nous déterminons la valeur ASCII de « A » pour les majuscules ou de « a » pour les lettres minuscules.

Tout d'abord, convertissez le caractère en son code ASCII, normalisez-le dans une plage de 0 à 25 en soustrayant le début et en ajoutant le décalage, puis enroulez-le en utilisant le modulo 26 pour vous assurer qu'il reste dans les limites de l'alphabet.

Enfin, nous ajoutons le début pour le mapper à la plage ASCII correcte.

Convertissez la valeur décalée en caractère en utilisant chr() et ajoutez-la au résultat.

result += chr(shifted)

Une fois tous les caractères traités, renvoyez la chaîne codée.

return result

Défi Python n°8 : le produit est-il divisible par la somme ?

Le défi : créer une fonction qui prend une liste d'entiers et renvoie si le produit de ces entiers est divisible par leur somme ou non.

La fonction doit renvoyer True si le produit de tous les entiers de la liste est divisible par leur somme et False sinon.

Voici la solution de code :

def is_product_divisible_by_sum(numbers):
    if not numbers:
        return False
    
    product = 1
    summation = 0
    for num in numbers:
        product *= num
        summation += num

    if summation == 0:
        return False

    return product % summation == 0

Explication du code :

Tout d'abord, nous définissons une fonction is_product_divisible_by_sum, qui prend une liste d'entiers, nombres, comme paramètre.

Ensuite, nous vérifions si la liste d'entrée numéros est vide. S'il est vide, renvoyez False.

if not numbers:
    return False

Sinon, initialisez deux variables : product à 1 et summation à 0.

product = 1
summation = 0

Parcourez chaque nombre de la liste pour calculer le produit total et la somme de tous les nombres de la liste.

for num in numbers:
    product *= num
    summation += num

Après avoir calculé la somme, vérifiez si la somme est nulle. Diviser par zéro n'est pas défini en mathématiques et générerait une erreur de programmation, retournez donc False.

if summation == 0:
    return False

Enfin, vérifiez si le produit est divisible par la somme en utilisant l'opérateur de module %.

Ici, si le reste est nul, c'est-à-dire que le produit est parfaitement divisible par la somme, retournez True. Sinon, renvoyez False.

return product % summation == 0

Emballer

Ce ne sont là que quelques défis qui peuvent vous aider à développer vos compétences en résolution de problèmes. Je vous suggère de tenter ces défis par vous-même.

Si vous souhaitez résoudre davantage de défis, vous pouvez essayer les plateformes suivantes :

  • Code Leet
  • Défis communautaires Programiz PRO
  • Exercice

Ils sont gratuits et vous aident à développer vos compétences logiques grâce à une expérience pratique.

Bon codage !

Articles connexes