Correction du professeur

Prologin 2003 ; quelques problèmes.

Épreuve régionale

42

"""
auteur : Franck CHAMBON
https://prologin.org/train/2003/semifinal/42
"""

def réponse_question_universelle():
    """Renvoie la réponse à la question universelle,
    sur la vie, l'univers, et le reste.
    Pour ceux qui ne le sauraient pas déjà,
    la réponse à cette question est le nombre 42.
    """
    return 42

print(réponse_question_universelle())

Escalier

"""
auteur : Franck CHAMBON
https://prologin.org/train/2003/semifinal/escalier
"""

def affiche_escalier(nb_marches):
    """Affiche un escalier qui a `nb_marches`.
    """
    for largeur in range(1, 1 + nb_marches):
        for _ in range(largeur):
            print("X", end="")
        print()

nb_marches = int(input())
affiche_escalier(nb_marches)

Grand écart

"""
auteur : Franck CHAMBON
https://prologin.org/train/2003/semifinal/grand_ecart
"""

def grand_écart(n, tableau):
    """Renvoie le plus grand écart entre un élément et son successeur.
    """
    écart_max = 0
    for i in range(n - 1):
        écart = abs(tableau[i] - tableau[i + 1])
        if écart_max < écart:
            écart_max = écart
    return écart_max


n = int(input())
tableau = list(map(int, input().split()))

print(grand_écart(n, tableau))

Initiales

"""
auteur : Franck CHAMBON
https://prologin.org/train/2003/semifinal/initiales
"""

def majuscule(lettre):
    """Renvoie la version majuscule de lettre,
    lettre est donnée en minuscule.
    """
    id_lettre = ord(lettre) - ord('a')
    lettre_maj = chr(ord('A') + id_lettre)
    return lettre_maj


def initiales(n, chaîne):
    """Renvoie les initiales de la chaîne, en majuscules.
    """

    sigle = [majuscule(chaîne[0])]
    for i in range(1, n):
        if chaîne[i - 1] == ' ':
            if chaîne[i] != ' ':
                sigle.append(majuscule(chaîne[i]))
    return "".join(sigle)


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

print(initiales(n, chaîne))

Mot le plus long

"""
auteur : Franck CHAMBON
https://prologin.org/train/2003/semifinal/mot_le_plus_long
"""

def longueur_plus_long_mot(n, chaîne):
    """Renvoie la longueur du mot le plus long.
    """
    longueur_max = 0
    longueur = 0
    for i in range(n + 1): # Oui, n+1.
        if (i == n) or (chaîne[i] == ' '):
            # ce test permet de tester aussi le dernier mot
            # tout en factorisant le code
            if longueur_max < longueur:
                longueur_max = longueur
            longueur = 0
        else:
            longueur += 1

    return longueur_max


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

print(longueur_plus_long_mot(n, chaîne))

Nombres impairs

"""
auteur : Franck CHAMBON
https://prologin.org/train/2003/semifinal/nombres_impairs
"""

def nombres_impairs(n, m):
    """Renvoie la liste des nombres impairs entre `n` et `m` inclus.
    """

    liste = []
    i = n
    if i % 2 == 0:
        i += 1
    while i <= m:
        liste.append(i)
        i += 2
    return liste


n, m = map(int, input().split())

impairs = nombres_impairs(n, m)
print(" ".join(map(str, impairs)))

Table de multiplication

"""
auteur : Franck CHAMBON
https://prologin.org/train/2003/semifinal/table_de_multiplications
"""

def affiche_table(nombre):
    """Affiche la table de multiplication de `nombre`
    """
    for k in range(1, 10):
        ## Version classique
        #print(nombre, "x", k, "=", k * nombre, sep="")

        ## Version f-string ; recommandée
        print(f"{nombre}x{k}={k * nombre}")


nombre = int(input())

affiche_table(nombre)

Puissance 4

"""
auteur : Franck CHAMBON
https://prologin.org/train/2003/semifinal/puissance_4
"""

def gagnant_puiss4(grille):
    """Renvoie le gagnant au jeu de Puissance 4.
    * '0' désigne une case vide, et aussi un match nul.
    """
    def est_dans_grille(i, j):
        return (0 <= i < 6) and (0 <= j < 7)
    
    def teste_en(i, j):
        """Renvoie "1" ou "2" si un gagnant est trouvé en partant de (i, j),
        sinon renvoie "0".
        """
        if grille[i][j] == "0":
            return "0"
        vecteurs = [
                    (0, 1), # horizontal
                    (1, 0), # vertical
                    (1, 1), # diagonal 1
                    (1, -1) # diagonal 2
                ]
        for di, dj in vecteurs:
            if est_dans_grille(i + 3*di, j + 3*dj):
                if (grille[i][j] == grille[i + di][j + dj] ==
                    grille[i + 2*di][j + 2*dj] == grille[i + 3*di][j + 3*dj]):
                        return grille[i][j]
        return "0"
    
    for i in range(6):
        for j in range(7):
            candidat = teste_en(i, j)
            if candidat != "0":
                return candidat
    return "0"


grille = [input() for _ in range(6)]

print(gagnant_puiss4(grille))

Puzzle

"""
auteur : Franck CHAMBON
https://prologin.org/train/2003/semifinal/puzzle
"""

# constantes
L_Pièce = 4
L_Puzzle = 10

pièce = [input() for _ in range(L_Pièce)]
puzzle = [input() for _ in range(L_Puzzle)]

def est_valide(i, j):
    "Renvoie : peut-on mettre la pièce en partant de (i, j) ?"
    for di in range(L_Pièce):
        idi = i + di
        for dj in range(L_Pièce):
            jdj = j+dj
            if pièce[di][dj] == "1":
                if (idi >= L_Puzzle) or (jdj >= L_Puzzle):
                    return False
                if puzzle[idi][jdj] == "1":
                    return False
    return True

def plaçable():
    "Renvoie : peut-on placer la pièce quelque part ?"
    for i in range(L_Puzzle):
        for j in range(L_Puzzle):
            if est_valide(i, j):
                return True
    return False

print("1" if plaçable() else "0")

Solitaire

"""
auteur : Franck CHAMBON
https://prologin.org/train/2003/semifinal/solitaire
"""

grille = [input() for _ in range(7)]

def est_valide(i, j):
    if not((0 <= i < 7) and (0 <= j < 7)):
        # en dehors du grand rectangle
        return False
    # Est-on sur une des deux bandes ?
    return (2 <= i < 5) or (2 <= j < 5)

def est_occupée(i, j):
    return est_valide(i, j) and (grille[i][j] == "1")

def est_libre(i, j):
    return est_valide(i, j) and (grille[i][j] == "0")

réponse = 0
for i in range(7):
    for j in range(7):
        if est_occupée(i, j):
            for di, dj in [(0, +1), (0, -1), (+1, 0), (-1, 0)]:
                if est_occupée(i + di, j + dj):
                    if est_libre(i + 2*di, j + 2*dj):
                        réponse += 1
print(réponse)

Qualification

Comparer des chaînes

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

def plus_petite(l_1, chaîne_1, l_2, chaîne_2):
    """Renvoie la plus petite des deux chaînes.
    En suivant l'ordre lexicographique,
    et sans utiliser la fonction de la bibliothèque interne.
    """
    l = min(l_1, l_2)
    for i in range(l):
        c_1 = chaîne_1[i]
        c_2 = chaîne_2[i]
        if c_1 < c_2:
            return chaîne_1
        if c_2 < c_1:
            return chaîne_2
    if l_1 < l_2:
        return chaîne_1
    if l_2 < l_1:
        return chaîne_2
    # ici on a 
    assert chaîne_1 == chaîne_2, f"Erreur curieuse"
    return chaîne_1


l_1 = int(input())
chaîne_1 = input()
l_2 = int(input())
chaîne_2 = input()

print(plus_petite(l_1, chaîne_1, l_2, chaîne_2))

Les trois nombres

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

def égal_somme_deux_autres(n_1, n_2, n_3):
    """Renvoie le nombre si égal à la somme des autres,
    sinon renvoie 0.
    """
    liste = [n_1, n_2, n_3]
    somme = n_1 + n_2 + n_3
    for n in liste:
        if n * 2 == somme:
            return n
    return 0

n_1, n_2, n_3 = map(int, input().split())
print(égal_somme_deux_autres(n_1, n_2, n_3))

Nombre de voyelles

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

def nb_voyelles(longueur, chaîne):
    """Renvoie le nombre de voyelles de la chaîne.
    """
    voyelles = "aeiuoyAEIOUY"
    Q_voyelles = len(voyelles)
    réponse = 0
    for i in range(longueur):
        for j in range(Q_voyelles):
            if chaîne[i] == voyelles[j]:
                réponse += 1
    return réponse


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

print(nb_voyelles(longueur, chaîne))