Correction de Nombre de voyelles

Quelques propositions d'élèves, et à la fin un corrigé du professeur.

• Propositions d'élèves
  • Proposition 1
  • Proposition 2
  • Proposition 3
  • Proposition 4
  • Proposition 5
  • Proposition 6
  • Proposition 7
  • Proposition 8
  • Proposition 9
• Corrigé du professeur

Propositions d'élèves

À la suite de chaque proposition de code, un commentaire de correction du professeur. Le cartouche demandé en introduction a été supprimé ici.

Proposition 1

def nombre_de_voyelles(nb_caractère: int, mot: str) -> int:
    """Cette fonction prend en paramètre une chaîne de caractères majuscules et minuscules sans accents et le nombre de caractère.
    Cette fonction renvoie le nombre de voyelles qu'elle contient.
    >>> 8
        ProlOgin
    3
    """
    mot = mot.lower()
    nombre_voyelles = 0
    liste_voyelles = ["a","e","i","o","u","y"] 
    for x in range(nb_caractère):
        if mot[x] in liste_voyelles:
            nombre_voyelles += 1
    return nombre_voyelles

# tests 
import doctest
doctest.testmod()

# Entrée
nb_caractère = int(input())
mot = input()

# Sortie
print(nombre_de_voyelles(nb_caractère, mot))

• On aurait aimé ne pas voir ni lower, ni upper, voire ni in en test d'appartenance à une chaîne.

Proposition 2

def nombre_de_voyelles(chaîne_caractères:str)-> int:
    """ Prend une chaîne de caractères puis renvoie le nombres de voyelles présent dedans
    >>> nombre_de_voyelles("Je voudrais une bonne note en NSI")
    13
    >>> nombre_de_voyelles("Marseille est en France")
    8
    """

    # On transforme cette chaine de caractères en une liste de caractères.
    liste_caractères = list(chaîne_caractères)

    def est_voyelle(lettre:str) -> bool:
        """ 
        >>> est_voyelle("a")
        True
        >>> est_voyelle("X")
        False
        >>> est_voyelle("Y")
        True
        >>> est_voyelle("z")
        False
   
        """
        # On met tout en minuscule.
        lettre = lettre.lower()
        
        voyelles = {"a","e","i","o","u","y"}
        return lettre in voyelles


    nb_voyelles = 0
    for x in range(len(liste_caractères)):
        if est_voyelle(liste_caractères[x]):
            nb_voyelles += 1
    return nb_voyelles

# tests
import doctest
doctest.testmod()

# Entrée
nb_caractères = int(input())
chaîne_caractères = input()

# Sortie
print(nombre_de_voyelles(chaîne_caractères))

• On peut se passer de set et de lower, sinon c'est très bien.

Proposition 3

longueur_mot = int(input())
mot = input().upper()
voyelle = [" ","A","E","I","O","U","Y"]
A = 0
for lettre in mot:
    if lettre in voyelle:
        A += 1
print (A)

• Fonctionne, mais ce n'est pas ce qu'on attend en devoir.
• voyelle : l'identifiant est mal choisi, car tu comptes l'espace aussi.
• A : identifiant très mal choisi.
• print(A) au lieu de print (A)
• Contrairement à un problème de FranceIOI, ici on ne voulait pas compter l'espace... Il est donc faux ici !!!

Proposition 4

voyelles = "aeiouy"

nombre_caractères = int(input())
chaine_charactère = input()

print(sum(lettre.lower() in voyelles for lettre in chaine_charactère))

• Style fonctionnel, c'est bien, mais à placer dans une fonction, et idéalement en seconde version proposée.
• charactère : c'est du franglais 😉

Proposition 5

def voyelles(mot):
    """ Renvoie le nom de voyelle dans une chaîne de caractère.
    >>> voyelles("Prologin")
    3
    """
    voyelles = ['a', 'e', 'i', 'o', 'u', 'y']
    nb_voyelles = sum(1 for lettre in mot if lettre in voyelles )
    return nb_voyelles

# Test
import doctest
doctest.testmod()

# Entrées
nb_lettre = int(input())
mot = input().lower()

if not (0 <= nb_lettre <= 10000):
    raise ValueError("Trop de caractères")

# Sortie
print(voyelles(mot))

• Style fonction efficace.
• On peut éviter le lower, et le in.

Proposition 6

def cherche_nb_voyelle(chaine_caractère, liste_voyelle, nb_voyelle: int):
    """ cherche le nombre de voyelle dans un mots ou phrase
    >>> cherche_nb_voyelle('prologin', ['a', 'o', 'u', 'y', 'e', 'i'], 0)
    3
    """
    for x in chaine_caractère: 
        for y in liste_voyelle:
            if x == y :
                nb_voyelle += 1
    return nb_voyelle

import doctest
doctest.testmod()

nb_caractère = int(input())
chaine_caractère = input().lower()
nb_voyelle = 0
liste_voyelle = ['a', 'o', 'u', 'y', 'e', 'i']
print(cherche_nb_voyelle(chaine_caractère, liste_voyelle, nb_voyelle))

• La liste de voyelles pourrait rester dans le corps de la fonction, inutile de la passer en paramètre...

Proposition 7

""" Cette fonction renvoie renvoie le nombre de voyelles du mot.
Exemple d'entrée : 8 
                   ProlOgiN 
Exemple de sortie: 3
"""



# tests 
import doctest 
doctest.testmod()

#Entrée
nb_caractère= int(input())
mot = input().lower() 

#Programme
voyelles = "aeiouy" 
fonction_nb_voyelles = sum(mot.count(i) for i in voyelles) 

#Sortie
print(fonction_nb_voyelles)

• Tu aurais pu mettre aussi une fonction...

• Ton doctest est inutile sans fonction...

• Utiliser .count n'est pas génial ici...

Proposition 8

# 0- Coeur du programme

def nombre_voyelles(nb_lettres: int, chaîne_mot: str) -> int:
    """ Renvoie le nombre de voyelles de chaîne_mot.
    >>> nombre_voyelles(11, "hello world")
    3
    >>> nombre_voyelles(8, "prologin")
    3
    """

    compteur = 0
    voyelles = ["a","e","i","o","u","y"]
    for lettre in chaîne_mot:               # On vérifie pour chaque lettre de chaîne_mot si elle se trouve dans voyelles
        if lettre in voyelles:
            compteur += 1                   # Si oui, on rajoute 1 au compteur
    return compteur                         # A la fin, on renvoie le compteur

# 1- Tests

import doctest
doctest.testmod()

# 2- Lecture des entrées

nb_lettres = int(input())
chaîne_mot = input().lower()

# 3- Appel de la fonction / Sortie

print(nombre_voyelles(nb_lettres, chaîne_mot))

• On pouvait se passer de lower.

Proposition 9

def nb_voyelles(texte : str) -> int :
    """ Renvoie le nombre de voyelles que la chaîne de caractères 'texte' contient.

    >>> nb_caractères = 8
    >>> texte = 'ProlOgiN'
    >>> nb_voyelles(texte)
    3

    """
    voyelles = ['a', 'A', 'e', 'E', 'i', 'I', 'o', 'O', 'u', 'U', 'y', 'Y']
    texte = list(texte)
    return sum(1 for lettre in texte if lettre in voyelles)

# tests
import doctest
doctest.testmod()

# Entrée
nb_caractères = int(input())
assert 1 <= nb_caractères <= 10000
texte = input()

# Sortie
print(nb_voyelles(texte))

• Très bien dans l'ensemble.
• Le assert est inutile ici.
• On peut aussi se passer du in voyelles.

Corrigé du professeur

On n'utilise pas le in de l'appartenance à une chaîne de caractères ; on fait ici une boucle pour tester chaque voyelle, et exceptionnellement on utilise un break pour éviter de finir inutilement la boucle sur les voyelles.

"""
auteur : Franck CHAMBON
https://prologin.org/train/2003/qualification/nombre_de_voyelles
"""

def nb_voyelles(chaîne: str) -> int:
    """Renvoie le nombre de voyelles de la chaîne.

    >>> nb_voyelles("ProlOgiN")
    3
    
    """
    CONST_voyelles = "aeiuoyAEIOUY"
    réponse = 0
    for caractère in chaîne:
        for voyelle in CONST_voyelles:
            if caractère == voyelle:
                réponse += 1
                break
    return réponse


import doctest
doctest.testmod()

taille = int(input())
chaîne = input()

print(nb_voyelles(chaîne))

• Une version fonctionnelle de nb_voyelles en une ligne !

def nb_voyelles(taille: int, chaîne: str) -> int:
    return sum(1 for c in chaîne if c in "aeiuoyAEIOUY")