id: 33-1649-fonctions-procedures-usuelles slug: 33-1649-fonctions-procedures-usuelles titre: Quelques fonctions et procédures usuelles chapitre: 0 chapitre_titre: Bibliothèque de modules usuels lecon: 1 niveau: 4eme-sci ordre: 100 prerequis: [] duree_estimee_min: 60 mots_cles:

saisie
affichage
tableau
chaine
tri
recherche
pgcd
palindrome
anagramme
modules langages:
analyse
pascal
python objectifs:
Réutiliser des schémas types de saisie contrôlée de données
Écrire des modules d'affichage simple, conditionné ou contrôlé
Implémenter les modules usuels sur les tableaux et les chaînes
Traduire un algorithme entre la notation algorithmique et Python status: published source_pdf: 33_1649.pdf source_pages:
1
2
3
4
5
6
7
8
9
10
11 kind: cours

Quelques fonctions et procédures usuelles

Ce document rassemble une bibliothèque de modules (fonctions et procédures) fréquemment utilisés dans les exercices de programmation : saisie contrôlée, affichage, traitements sur les tableaux et sur les chaînes de caractères, recherches et tris.

Pour chaque problème, on présente la version en algorithme (notation pseudo-code) et la version en Python.

Ecrire("Saisir x")
Lire(x)

Tableau :

Pour i de binf à bsup faire
    Ecrire("Saisir la case n°", i)
    Lire(T[i])
Fin pour

Algorithme

Variable simple (entier, réel, caractère, chaîne) :

Ecrire("Saisir x")
Lire(x)

Tableau :

Pour i de binf à bsup faire
    Ecrire("Saisir la case n°", i)
    Lire(T[i])
Fin pour

Python

Variable simple :

x = input("Saisir x")

Tableau :

for i in range(binf, bsup+1):
    T[i] = input('Saisir la case n°' + str(i))

Saisie contrôlée

Variable simple :

Répéter
    Ecrire("Saisir x")
    Lire(x)
Jusqu'à (condition)

Tableau :

Pour i de binf à bsup faire
    Répéter
        Ecrire("Saisir la case n°", i)
        Lire(T[i])
    Jusqu'à (condition)
Fin pour

Algorithme

Variable simple :

Répéter
    Ecrire("Saisir x")
    Lire(x)
Jusqu'à (condition)

Tableau :

Pour i de binf à bsup faire
    Répéter
        Ecrire("Saisir la case n°", i)
        Lire(T[i])
    Jusqu'à (condition)
Fin pour

Python

Variable simple :

x = input("Saisir x")
while not(condition):
    x = input("Saisir x")

Tableau :

for i in range(binf, bsup+1):
    x = input("Saisir x")
    while not(condition):
        x = input("Saisir x")

1.2 Saisie d'un entier

Saisir un entier x (sans contrôle)

Ecrire("Saisir x")
Lire(x)

Algorithme

Ecrire("Saisir x")
Lire(x)

Python

x = int(input("Saisir x"))

Saisir un entier x strictement positif

Procédure saisie(@ x : entier)
Début
    Répéter
        Ecrire("Saisir x")
        Lire(x)
    Jusqu'à (x > 0)
Fin

Algorithme

Procédure saisie(@ x : entier)
Début
    Répéter
        Ecrire("Saisir x")
        Lire(x)
    Jusqu'à (x > 0)
Fin

Python

def saisie():
    x = int(input("Saisir x"))
    while not(x > 0):
        x = input("Saisir x")
    return x

Saisir un entier négatif

Procédure saisie(@ x : entier)
Début
    Répéter
        Ecrire("Saisir x")
        Lire(x)
    Jusqu'à (x < 0)
Fin

Algorithme

Procédure saisie(@ x : entier)
Début
    Répéter
        Ecrire("Saisir x")
        Lire(x)
    Jusqu'à (x < 0)
Fin

Python

def saisie():
    x = int(input("Saisir x"))
    while not(x < 0):
        x = input("Saisir x")
    return x

Saisir un entier n avec 2 < n < 50

Procédure saisie(@ n : entier)
Début
    Répéter
        Ecrire("Saisir n")
        Lire(n)
    Jusqu'à (2 < n < 50)
Fin

Algorithme

Procédure saisie(@ n : entier)
Début
    Répéter
        Ecrire("Saisir n")
        Lire(n)
    Jusqu'à (2 < n < 50)
Fin

Python

def saisie():
    n = int(input("Saisir n"))
    while not(2 < n < 50):
        n = input("Saisir n")
    return n

Saisir un entier n de trois chiffres

Procédure saisie(@ n : entier)
Début
    Répéter
        Ecrire("Saisir n")
        Lire(n)
    Jusqu'à (n ∈ [100..999])
Fin

Algorithme

Procédure saisie(@ n : entier)
Début
    Répéter
        Ecrire("Saisir n")
        Lire(n)
    Jusqu'à (n ∈ [100..999])
Fin

Python

def saisie():
    n = int(input("Saisir n"))
    while not(100 <= n <= 999):
        n = input("Saisir n")
    return n

1.3 Saisie d'un caractère

Saisir un caractère c (sans contrôle)

Ecrire("Saisir c")
Lire(c)

Algorithme

Ecrire("Saisir c")
Lire(c)

Python

c = input("Saisir c")

Saisir une lettre minuscule

Procédure saisie(@ c : caractère)
Début
    Répéter
        Ecrire("Saisir c")
        Lire(c)
    Jusqu'à (c ∈ ["a".."z"])
Fin

Algorithme

Procédure saisie(@ c : caractère)
Début
    Répéter
        Ecrire("Saisir c")
        Lire(c)
    Jusqu'à (c ∈ ["a".."z"])
Fin

Python

def saisie():
    c = input("Saisir c")
    while not("a" <= c <= "z" and len(c) == 1):
        c = input("Saisir c")
    return c

Saisir une lettre majuscule

Procédure saisie(@ c : caractère)
Début
    Répéter
        Ecrire("Saisir c")
        Lire(c)
    Jusqu'à (c ∈ ["A".."Z"])
Fin

Algorithme

Procédure saisie(@ c : caractère)
Début
    Répéter
        Ecrire("Saisir c")
        Lire(c)
    Jusqu'à (c ∈ ["A".."Z"])
Fin

Python

def saisie():
    c = input("Saisir c")
    while not("A" <= c <= "Z" and len(c) == 1):
        c = input("Saisir c")
    return c

Saisir un caractère numérique

Procédure saisie(@ c : caractère)
Début
    Répéter
        Ecrire("Saisir c")
        Lire(c)
    Jusqu'à (c ∈ ["0".."9"])
Fin

Algorithme

Procédure saisie(@ c : caractère)
Début
    Répéter
        Ecrire("Saisir c")
        Lire(c)
    Jusqu'à (c ∈ ["0".."9"])
Fin

Python

def saisie():
    c = input("Saisir c")
    while not("0" <= c <= "9" and len(c) == 1):
        c = input("Saisir c")
    return c

Saisir un caractère 'O' ou 'N'

Procédure saisie(@ c : caractère)
Début
    Répéter
        Ecrire("Saisir c")
        Lire(c)
    Jusqu'à (c ∈ {"O","N"})
Fin

Algorithme

Procédure saisie(@ c : caractère)
Début
    Répéter
        Ecrire("Saisir c")
        Lire(c)
    Jusqu'à (c ∈ {"O","N"})
Fin

Python

def saisie():
    c = input("Saisir c")
    while not(c in {"O", "N"}):
        c = input("Saisir c")
    return c

1.4 Saisie d'une chaîne de caractères

Saisir une chaîne ch (sans contrôle)

Ecrire("Saisir ch")
Lire(ch)

Algorithme

Ecrire("Saisir ch")
Lire(ch)

Python

ch = input("Saisir ch")

Saisir une chaîne dont la longueur ne dépasse pas 5

Procédure saisie(@ ch : chaîne)
Début
    Répéter
        Ecrire("Saisir ch")
        Lire(ch)
    Jusqu'à (long(ch) <= 5)
Fin

Algorithme

Procédure saisie(@ ch : chaîne)
Début
    Répéter
        Ecrire("Saisir ch")
        Lire(ch)
    Jusqu'à (long(ch) <= 5)
Fin

Python

def saisie():
    ch = input("Saisir ch")
    while not(len(ch) <= 5):
        ch = input("Saisir ch")
    return ch

Saisir une chaîne composée uniquement de lettres

Procédure saisie(@ ch : chaîne)
Début
    Répéter
        Ecrire("Saisir ch")
        Lire(ch)
    Jusqu'à (alpha(ch))
Fin

Algorithme

Procédure saisie(@ ch : chaîne)
Début
    Répéter
        Ecrire("Saisir ch")
        Lire(ch)
    Jusqu'à (alpha(ch))
Fin

Python

def saisie():
    ch = input("Saisir ch")
    while not(alpha(ch)):
        ch = input("Saisir ch")
    return ch

Saisir une chaîne composée uniquement de chiffres

Procédure saisie(@ ch : chaîne)
Début
    Répéter
        Ecrire("Saisir ch")
        Lire(ch)
    Jusqu'à (Estnum(ch))
Fin

Algorithme

Procédure saisie(@ ch : chaîne)
Début
    Répéter
        Ecrire("Saisir ch")
        Lire(ch)
    Jusqu'à (Estnum(ch))
Fin

Python

def saisie():
    ch = input("Saisir ch")
    while not(ch.isnumeric()):
        ch = input("Saisir ch")
    return ch

Saisir une chaîne composée uniquement des lettres 'A' et 'B'

Procédure saisie(@ ch : chaîne)
Début
    Répéter
        Ecrire("Saisir ch")
        Lire(ch)
    Jusqu'à (AB(ch))
Fin

Algorithme

Procédure saisie(@ ch : chaîne)
Début
    Répéter
        Ecrire("Saisir ch")
        Lire(ch)
    Jusqu'à (AB(ch))
Fin

Python

def saisie():
    ch = input("Saisir ch")
    while not(AB(ch)):
        ch = input("Saisir ch")
    return ch

1.5 Saisie d'un tableau

Tableau de n éléments

Procédure remplir(@ T : tab, n : entier)
Début
    Pour i de 0 à n-1 faire
        Ecrire("Saisir la case n°", i)
        Lire(T[i])
    Fin pour
Fin

Algorithme

Procédure remplir(@ T : tab, n : entier)
Début
    Pour i de 0 à n-1 faire
        Ecrire("Saisir la case n°", i)
        Lire(T[i])
    Fin pour
Fin

Python

from numpy import array
T = array([str]*n)

def remplir(T, n):
    for i in range(n):
        T[i] = input('Saisir la case n°' + str(i))

Tableau de n entiers positifs

Procédure remplir(@ T : tab, n : entier)
Début
    Pour i de 0 à n-1 faire
        Répéter
            Ecrire("Saisir la case n°", i)
            Lire(T[i])
        Jusqu'à (T[i] >= 0)
    Fin pour
Fin

Algorithme

Procédure remplir(@ T : tab, n : entier)
Début
    Pour i de 0 à n-1 faire
        Répéter
            Ecrire("Saisir la case n°", i)
            Lire(T[i])
        Jusqu'à (T[i] >= 0)
    Fin pour
Fin

Python

from numpy import array
T = array([int]*n)

def remplir(T, n):
    for i in range(n):
        T[i] = int(input('Saisir la case n°' + str(i)))
        while not(T[i] > 0):
            T[i] = int(input('Saisir la case n°' + str(i)))

Tableau de n lettres minuscules

Procédure remplir(@ T : tab, n : entier)
Début
    Pour i de 0 à n-1 faire
        Répéter
            Ecrire("Saisir la case n°", i)
            Lire(T[i])
        Jusqu'à (T[i] ∈ ["a".."z"])
    Fin pour
Fin

Algorithme

Procédure remplir(@ T : tab, n : entier)
Début
    Pour i de 0 à n-1 faire
        Répéter
            Ecrire("Saisir la case n°", i)
            Lire(T[i])
        Jusqu'à (T[i] ∈ ["a".."z"])
    Fin pour
Fin

Python

from numpy import array
T = array([str()]*n)

def remplir(T, n):
    for i in range(n):
        T[i] = input('Saisir la case n°' + str(i))
        while not("a" <= T[i] <= "z"):
            T[i] = input('Saisir la case n°' + str(i))

Tableau de n chaînes dont la longueur ne dépasse pas 6

Procédure remplir(@ T : tab, n : entier)
Début
    Pour i de 0 à n-1 faire
        Répéter
            Ecrire("Saisir la case n°", i)
            Lire(T[i])
        Jusqu'à (long(T[i]) <= 6)
    Fin pour
Fin

Algorithme

Procédure remplir(@ T : tab, n : entier)
Début
    Pour i de 0 à n-1 faire
        Répéter
            Ecrire("Saisir la case n°", i)
            Lire(T[i])
        Jusqu'à (long(T[i]) <= 6)
    Fin pour
Fin

Python

from numpy import array
T = array([str]*n)

def remplir(T, n):
    for i in range(n):
        T[i] = input('Saisir la case n°' + str(i))
        while not(len(T[i]) <= 6):
            T[i] = input('Saisir la case n°' + str(i))

Tableau de n caractères 'A' et 'B'

Procédure remplir(@ T : tab, n : entier)
Début
    Pour i de 0 à n-1 faire
        Répéter
            Ecrire("Saisir la case n°", i)
            Lire(T[i])
        Jusqu'à (T[i] ∈ {"A","B"})
    Fin pour
Fin

Algorithme

Procédure remplir(@ T : tab, n : entier)
Début
    Pour i de 0 à n-1 faire
        Répéter
            Ecrire("Saisir la case n°", i)
            Lire(T[i])
        Jusqu'à (T[i] ∈ {"A","B"})
    Fin pour
Fin

Python

from numpy import array
T = array([str()]*n)

def remplir(T, n):
    for i in range(n):
        T[i] = input('Saisir la case n°' + str(i))
        while not(T[i] in {"A", "B"}):
            T[i] = input('Saisir la case n°' + str(i))

Tableau de n éléments ordonnés (croissants)

Procédure remplir(@ T : tab, n : entier)
Début
    Ecrire("Saisir la case n°0")
    Lire(T[0])
    Pour i de 1 à n-1 faire
        Répéter
            Ecrire("Saisir la case n°", i)
            Lire(T[i])
        Jusqu'à (T[i] > T[i-1])
    Fin pour
Fin

Algorithme

Procédure remplir(@ T : tab, n : entier)
Début
    Ecrire("Saisir la case n°0")
    Lire(T[0])
    Pour i de 1 à n-1 faire
        Répéter
            Ecrire("Saisir la case n°", i)
            Lire(T[i])
        Jusqu'à (T[i] > T[i-1])
    Fin pour
Fin

Python

from numpy import array
T = array([str()]*n)

def remplir(T, n):
    T[0] = int(input('Saisir la case n° 0'))
    for i in range(1, n):
        T[i] = int(input('Saisir la case n°' + str(i)))
        while not(T[i] > T[i-1]):
            T[i] = int(input('Saisir la case n°' + str(i)))

Tableau de n éléments distincts

Procédure remplir(@ T : tab, n : entier)
Début
    Pour i de 0 à n-1 faire
        Répéter
            Ecrire("Saisir la case n°", i)
            Lire(T[i])
        Jusqu'à (distinct(T, i))
    Fin pour
Fin

Algorithme

Procédure remplir(@ T : tab, n : entier)
Début
    Pour i de 0 à n-1 faire
        Répéter
            Ecrire("Saisir la case n°", i)
            Lire(T[i])
        Jusqu'à (distinct(T, i))
    Fin pour
Fin

Python

from numpy import array
T = array([str()]*n)

def remplir(T, n):
    for i in range(n):
        T[i] = input('Saisir la case n°' + str(i))
        while not(distinct(T, i)):
            T[i] = input('Saisir la case n°' + str(i))

2. Affichage de données

2.1 Affichage simple

Variable simple :

Ecrire(x)

Tableau :

Pour i de binf à bsup faire
    Ecrire(T[i])
Fin pour

Algorithme

Variable simple :

Ecrire(x)

Tableau :

Pour i de binf à bsup faire
    Ecrire(T[i])
Fin pour

Python

Variable simple :

print(x)

Tableau :

for i in range(taille):
    print(T[i])

2.2 Affichage conditionné

Variable simple :

Si (condition) alors
    Ecrire(x)
Fin si

Tableau :

Pour i de binf à bsup faire
    Si (condition) alors
        Ecrire(T[i])
    Fin si
Fin pour

Algorithme

Variable simple :

Si (condition) alors
    Ecrire(x)
Fin si

Tableau :

Pour i de binf à bsup faire
    Si (condition) alors
        Ecrire(T[i])
    Fin si
Fin pour

Python

Variable simple :

if condition:
    print(x)

Tableau :

for i in range(taille):
    if condition:
        print(T[i])

2.3 Affichage contrôlé

Variable simple :

Répéter
    Ecrire(x)
Jusqu'à (condition)

Tableau :

Pour i de binf à bsup faire
    Répéter
        Ecrire(T[i])
    Jusqu'à (condition)
Fin pour

Algorithme

Variable simple :

Répéter
    Ecrire(x)
Jusqu'à (condition)

Tableau :

Pour i de binf à bsup faire
    Répéter
        Ecrire(T[i])
    Jusqu'à (condition)
Fin pour

Python

Variable simple :

while condition:
    print(x)

Tableau :

for i in range(taille):
    while condition:
        print(T[i])

Fonction somme(t : tab ; n : entier) : entier
Début
    s ← 0
    Pour i de 0 à n-1 faire
        s ← s + t[i]
    Fin pour
    Retourner s
Fin somme

Algorithme

Fonction somme(t : tab ; n : entier) : entier
Début
    s ← 0
    Pour i de 0 à n-1 faire
        s ← s + t[i]
    Fin pour
    Retourner s
Fin somme

Python

def somme(t, n):
    s = 0
    for i in range(n):
        s = s + t[i]
    return s

Somme des éléments d'indice pair d'un tableau

Fonction somme(t : tab ; n : entier) : entier
Début
    s ← 0
    Pour i de 0 à n-1 faire
        Si t[i] mod 2 = 0 alors
            s ← s + t[i]
        Fin si
    Fin pour
    Retourner s
Fin

Algorithme

Fonction somme(t : tab ; n : entier) : entier
Début
    s ← 0
    Pour i de 0 à n-1 faire
        Si t[i] mod 2 = 0 alors
            s ← s + t[i]
        Fin si
    Fin pour
    Retourner s
Fin

Python

def somme(t, n):
    s = 0
    for i in range(n):
        if i % 2 == 0:
            s = s + t[i]
    return s

Concaténation des éléments caractères d'un tableau

Fonction somme(t : tab ; n : entier) : chaîne
Début
    ch ← ""
    Pour i de 0 à n-1 faire
        ch ← ch + t[i]
    Fin pour
    Retourner ch
Fin

Algorithme

Fonction somme(t : tab ; n : entier) : chaîne
Début
    ch ← ""
    Pour i de 0 à n-1 faire
        ch ← ch + t[i]
    Fin pour
    Retourner ch
Fin

Python

def somme(t, n):
    ch = ''
    for i in range(n):
        ch = ch + t[i]
    return ch

Recherche du minimum d'un tableau

Fonction min(t : tab ; n : entier) : entier
Début
    m ← t[0]
    Pour i de 1 à n-1 faire
        Si t[i] < m alors
            m ← t[i]
        Fin si
    Fin pour
    Retourner m
Fin

Algorithme

Fonction min(t : tab ; n : entier) : entier
Début
    m ← t[0]
    Pour i de 1 à n-1 faire
        Si t[i] < m alors
            m ← t[i]
        Fin si
    Fin pour
    Retourner m
Fin

Python

def min(t, n):
    m = t[0]
    for i in range(1, n):
        if t[i] < m:
            m = t[i]
    return m

Recherche du maximum d'un tableau

Fonction max(t : tab ; n : entier) : entier
Début
    m ← t[0]
    Pour i de 1 à n-1 faire
        Si t[i] > m alors
            m ← t[i]
        Fin si
    Fin pour
    Retourner m
Fin

Algorithme

Fonction max(t : tab ; n : entier) : entier
Début
    m ← t[0]
    Pour i de 1 à n-1 faire
        Si t[i] > m alors
            m ← t[i]
        Fin si
    Fin pour
    Retourner m
Fin

Python

def max(t, n):
    m = t[0]
    for i in range(1, n):
        if t[i] > m:
            m = t[i]
    return m

Moyenne des éléments d'un tableau

Fonction moyenne(t : tab ; n : entier) : réel
Début
    s ← 0
    Pour i de 0 à n-1 faire
        s ← s + t[i]
    Fin pour
    Retourner s/n
Fin

Algorithme

Fonction moyenne(t : tab ; n : entier) : réel
Début
    s ← 0
    Pour i de 0 à n-1 faire
        s ← s + t[i]
    Fin pour
    Retourner s/n
Fin

Python

def moyenne(t, n):
    s = 0
    for i in range(n):
        s = s + t[i]
    return s/n

Recherche des occurrences d'un élément dans un tableau

Fonction occur(t : tab ; x, n : entier) : entier
Début
    oc ← 0
    Pour i de 0 à n-1 faire
        Si t[i] = x alors
            oc ← oc + 1
        Fin si
    Fin pour
    Retourner oc
Fin

Algorithme

Fonction occur(t : tab ; x, n : entier) : entier
Début
    oc ← 0
    Pour i de 0 à n-1 faire
        Si t[i] = x alors
            oc ← oc + 1
        Fin si
    Fin pour
    Retourner oc
Fin

Python

def occur(t, x, n):
    oc = 0
    for i in range(n):
        if t[i] == x:
            oc = oc + 1
    return oc

Conversion des éléments d'un tableau en une chaîne

Fonction convert(t : tab ; n : entier) : chaîne
Début
    ch ← ""
    Pour i de 0 à n-1 faire
        ch ← ch + convch(t[i])
    Fin pour
    Retourner ch
Fin

Algorithme

Fonction convert(t : tab ; n : entier) : chaîne
Début
    ch ← ""
    Pour i de 0 à n-1 faire
        ch ← ch + convch(t[i])
    Fin pour
    Retourner ch
Fin

Python

def convert(t, n):
    ch = ""
    for i in range(n):
        ch = ch + str(t[i])
    return ch

Décalage des éléments d'un tableau vers la gauche

Procédure dec(@ t : tab ; p, f : entier)
Début
    Pour i de p à f faire
        t[i] ← t[i+1]
    Fin pour
Fin

Algorithme

Procédure dec(@ t : tab ; p, f : entier)
Début
    Pour i de p à f faire
        t[i] ← t[i+1]
    Fin pour
Fin

Python

def dec(t, p, f):
    for i in range(p, f+1):
        t[i] = t[i+1]

Décalage vers la gauche avec suppression d'une case

Procédure dec(@ t : tab ; p, f : entier ; @ n : entier)
Début
    Pour i de p à f faire
        t[i] ← t[i+1]
    Fin pour
    n ← n - 1
Fin

Algorithme

Procédure dec(@ t : tab ; p, f : entier ; @ n : entier)
Début
    Pour i de p à f faire
        t[i] ← t[i+1]
    Fin pour
    n ← n - 1
Fin

Python

def dec(t, p, f, n):
    for i in range(p, f+1):
        t[i] = t[i+1]
    n = n - 1
    return n

Décalage des éléments d'un tableau vers la droite

Procédure dec(@ t : tab ; p, f : entier)
Début
    Pour i de f à p (pas = -1) faire
        t[i] ← t[i-1]
    Fin pour
Fin

Algorithme

Procédure dec(@ t : tab ; p, f : entier)
Début
    Pour i de f à p (pas = -1) faire
        t[i] ← t[i-1]
    Fin pour
Fin

Python

def dec(t, p, f):
    for i in range(f, p, -1):
        t[i] = t[i-1]

Décalage vers la droite avec ajout d'une case

Procédure dec(@ t : tab ; p, f, n : entier)
Début
    n ← n + 1
    Pour i de f à p (pas = -1) faire
        t[i] ← t[i-1]
    Fin pour
Fin

Algorithme

Procédure dec(@ t : tab ; p, f, n : entier)
Début
    n ← n + 1
    Pour i de f à p (pas = -1) faire
        t[i] ← t[i-1]
    Fin pour
Fin

Python

def dec(t, p, f, n):
    n = n + 1
    for i in range(f, p, -1):
        t[i] = t[i-1]
    return n

3.2 Modules sur les chaînes de caractères

Somme des éléments numériques d'une chaîne

Fonction somme(ch : chaîne) : entier
Début
    s ← 0
    Pour i de 0 à long(ch)-1 faire
        Si (ch[i] dans ["0".."9"]) alors
            s ← s + valeur(ch[i])
        Fin si
    Fin pour
    Retourner s
Fin

Algorithme

Fonction somme(ch : chaîne) : entier
Début
    s ← 0
    Pour i de 0 à long(ch)-1 faire
        Si (ch[i] dans ["0".."9"]) alors
            s ← s + valeur(ch[i])
        Fin si
    Fin pour
    Retourner s
Fin

Python

def somme(ch):
    s = 0
    for i in range(len(ch)):
        if ch[i].isdigit():
            s = s + int(ch[i])
    return s

Conversion des caractères d'une chaîne en tableau

Procédure convers(ch : chaîne ; @ t : tab)
Début
    Pour i de 0 à long(ch)-1 faire
        t[i] ← ch[i]
    Fin pour
Fin

Algorithme

Procédure convers(ch : chaîne ; @ t : tab)
Début
    Pour i de 0 à long(ch)-1 faire
        t[i] ← ch[i]
    Fin pour
Fin

Python

def convers(ch):
    t = [''] * len(ch)
    for i in range(len(ch)):
        t[i] = ch[i]
    return t

Nombre d'occurrences d'un caractère dans une chaîne

Fonction occurence(ch : chaîne ; c : caractère) : entier
Début
    oc ← 0
    Pour i de 0 à long(ch)-1 faire
        Si ch[i] = c alors
            oc ← oc + 1
        Fin si
    Fin pour
    Retourner oc
Fin

Algorithme

Fonction occurence(ch : chaîne ; c : caractère) : entier
Début
    oc ← 0
    Pour i de 0 à long(ch)-1 faire
        Si ch[i] = c alors
            oc ← oc + 1
        Fin si
    Fin pour
    Retourner oc
Fin

Python

def occurence(ch, c):
    oc = 0
    for i in range(len(ch)):
        if ch[i] == c:
            oc = oc + 1
    return oc

Caractères en commun de deux chaînes (avec doublons)

Fonction commun(ch1, ch2 : chaîne) : chaîne
Début
    c ← ""
    Pour i de 0 à long(ch1)-1 faire
        Si pos(ch1[i], ch2) ≠ -1 alors
            c ← c + ch1[i]
        Fin si
    Fin pour
    Retourner c
Fin

Algorithme

Fonction commun(ch1, ch2 : chaîne) : chaîne
Début
    c ← ""
    Pour i de 0 à long(ch1)-1 faire
        Si pos(ch1[i], ch2) ≠ -1 alors
            c ← c + ch1[i]
        Fin si
    Fin pour
    Retourner c
Fin

Python

def commun(ch1, ch2):
    c = ''
    for i in range(len(ch1)):
        if ch2.find(ch1[i]) != -1:
            c = c + ch1[i]
    return c

Caractères en commun de deux chaînes (sans redondance)

Fonction commun(ch1, ch2 : chaîne) : chaîne
Début
    c ← ""
    Pour i de 0 à long(ch1)-1 faire
        Si (pos(ch1[i], ch2) ≠ -1) et (pos(ch1[i], c) = -1) alors
            c ← c + ch1[i]
        Fin si
    Fin pour
    Retourner c
Fin

Algorithme

Fonction commun(ch1, ch2 : chaîne) : chaîne
Début
    c ← ""
    Pour i de 0 à long(ch1)-1 faire
        Si (pos(ch1[i], ch2) ≠ -1) et (pos(ch1[i], c) = -1) alors
            c ← c + ch1[i]
        Fin si
    Fin pour
    Retourner c
Fin

Python

def commun(ch1, ch2):
    c = ''
    for i in range(len(ch1)):
        if ch2.find(ch1[i]) != -1 and c.find(ch1[i]) == -1:
            c = c + ch1[i]
    return c

Vérifier si une chaîne est composée uniquement de lettres alphabétiques

Fonction alpha(ch : chaîne) : booléen
Début
    i ← 0
    test ← vrai
    Tant que test = vrai et i < long(ch) faire
        Si majus(ch[i]) dans ["A".."Z"] alors
            i ← i + 1
        Sinon
            test ← faux
        Fin si
    Fin tant que
    Retourner test
Fin

Algorithme

Fonction alpha(ch : chaîne) : booléen
Début
    i ← 0
    test ← vrai
    Tant que test = vrai et i < long(ch) faire
        Si majus(ch[i]) dans ["A".."Z"] alors
            i ← i + 1
        Sinon
            test ← faux
        Fin si
    Fin tant que
    Retourner test
Fin

Python

def alpha(ch):
    i = 0
    test = True
    while test and i < len(ch):
        if "A" <= ch[i].upper() <= "Z":
            i += 1
        else:
            test = False
    return test

3.3 Modules arithmétiques

Vérifier si un entier est premier

Fonction premier(x : entier) : booléen
Début
    i ← 2
    Tant que (x mod i ≠ 0) et (i < x) faire
        i ← i + 1
    Fin tant que
    premier ← (i = x)
Fin

Algorithme

Fonction premier(x : entier) : booléen
Début
    i ← 2
    Tant que (x mod i ≠ 0) et (i < x) faire
        i ← i + 1
    Fin tant que
    premier ← (i = x)
Fin

Python

def premier(x):
    i = 2
    while x % i != 0 and i < x:
        i += 1
    return i == x

Décomposer un entier en facteurs premiers

Procédure decomp(@ t : tab ; x : entier ; @ n : entier)
Début
    i ← 2
    n ← -1
    Répéter
        Si (x mod i = 0) alors
            n ← n + 1
            T[n] ← i
            x ← x div i
        Sinon
            i ← i + 1
        Fin si
    Jusqu'à (x = 1)
Fin

Algorithme

Procédure decomp(@ t : tab ; x : entier ; @ n : entier)
Début
    i ← 2
    n ← -1
    Répéter
        Si (x mod i = 0) alors
            n ← n + 1
            T[n] ← i
            x ← x div i
        Sinon
            i ← i + 1
        Fin si
    Jusqu'à (x = 1)
Fin

Python

def decomp(x, t):
    i = 2
    n = -1
    while x > 1:
        if x % i == 0:
            n += 1
            t[n] = i
            x = x // i
        else:
            i = i + 1
    return n

Calculer x puissance n

Fonction puissance(x, n : entier) : entier
Début
    p ← 1
    Pour i de 1 à n faire
        p ← p * x
    Fin pour
    Retourner p
Fin

Algorithme

Fonction puissance(x, n : entier) : entier
Début
    p ← 1
    Pour i de 1 à n faire
        p ← p * x
    Fin pour
    Retourner p
Fin

Python

def puissance(x, n):
    p = 1
    for i in range(n):
        p = p * x
    return p

Calculer la factorielle d'un entier

Fonction factorielle(x : entier) : entier
Début
    f ← 1
    Pour i de 2 à x faire
        f ← f * i
    Fin pour
    Retourner f
Fin

Algorithme

Fonction factorielle(x : entier) : entier
Début
    f ← 1
    Pour i de 2 à x faire
        f ← f * i
    Fin pour
    Retourner f
Fin

Python

def factorielle(x):
    f = 1
    for i in range(1, x+1):
        f = f * i
    return f

Chercher les diviseurs d'un entier

Procédure diviseur(x : entier ; @ t : tab ; @ n : entier)
Début
    n ← -1
    Pour i de 1 à x faire
        Si (x mod i = 0) alors
            n ← n + 1
            T[n] ← i
        Fin si
    Fin pour
Fin

Algorithme

Procédure diviseur(x : entier ; @ t : tab ; @ n : entier)
Début
    n ← -1
    Pour i de 1 à x faire
        Si (x mod i = 0) alors
            n ← n + 1
            T[n] ← i
        Fin si
    Fin pour
Fin

Python

def diviseur(x, t):
    n = -1
    for i in range(1, x+1):
        if x % i == 0:
            n += 1
            t[n] = i
    return n

Somme des diviseurs d'un entier

Fonction sommediviseur(x : entier) : entier
Début
    s ← 0
    Pour i de 1 à x faire
        Si (x mod i = 0) alors
            s ← s + i
        Fin si
    Fin pour
    Retourner s
Fin

Algorithme

Fonction sommediviseur(x : entier) : entier
Début
    s ← 0
    Pour i de 1 à x faire
        Si (x mod i = 0) alors
            s ← s + i
        Fin si
    Fin pour
    Retourner s
Fin

Python

def sommediviseur(x):
    s = 0
    for i in range(1, x):
        if x % i == 0:
            s += i
    return s

Calculer le PGCD de deux entiers (par soustraction)

Fonction PGCD(a, b : entier) : entier
Début
    Tant que a ≠ b faire
        Si a > b alors
            a ← a - b
        Sinon
            b ← b - a
        Fin si
    Fin tant que
    Retourner a
Fin

Algorithme

Fonction PGCD(a, b : entier) : entier
Début
    Tant que a ≠ b faire
        Si a > b alors
            a ← a - b
        Sinon
            b ← b - a
        Fin si
    Fin tant que
    Retourner a
Fin

Python

def pgcd(a, b):
    while a != b:
        if a > b:
            a = a - b
        else:
            b = b - a
    return a

Calculer le PPCM de deux entiers

Fonction ppcm(a, b : entier) : entier
Début
    max ← a
    min ← b
    Si b > a alors
        max ← b
        min ← a
    Fin si
    Tant que max mod min ≠ 0 faire
        max ← max + a + b - min
    Fin tant que
    Retourner max
Fin

Algorithme

Fonction ppcm(a, b : entier) : entier
Début
    max ← a
    min ← b
    Si b > a alors
        max ← b
        min ← a
    Fin si
    Tant que max mod min ≠ 0 faire
        max ← max + a + b - min
    Fin tant que
    Retourner max
Fin

Python

def ppcm(a, b):
    mn = a
    mx = b
    if a > b:
        mn = b
        mx = a
    while mx % mn != 0:
        mx = mx + int(a) + int(b) - mn
    return mx

Vérifier si un entier est parfait

Fonction parfait(x : entier) : booléen
Début
    Retourner x = sommediviseur(x)
Fin

Algorithme

Fonction parfait(x : entier) : booléen
Début
    Retourner x = sommediviseur(x)
Fin

Python

def parfait(x):
    return x == sommediviseur(x)

3.4 Modules de vérification sur les chaînes

Vérifier si une chaîne est un palindrome

Fonction palindrome(ch : chaîne) : booléen
Début
    i ← 0
    j ← long(ch) - 1
    Tant que (ch[i] = ch[j]) et (i < j) faire
        i ← i + 1
        j ← j - 1
    Fin tant que
    Retourner i >= j
Fin

Algorithme

Fonction palindrome(ch : chaîne) : booléen
Début
    i ← 0
    j ← long(ch) - 1
    Tant que (ch[i] = ch[j]) et (i < j) faire
        i ← i + 1
        j ← j - 1
    Fin tant que
    Retourner i >= j
Fin

Python

def palindrome(ch):
    i = 0
    j = len(ch) - 1
    while ch[i] == ch[j] and i < j:
        i += 1
        j -= 1
    return i >= j

Vérifier si une chaîne est un pangramme

Fonction pangramme(ch : chaîne) : booléen
Début
    p ← vrai
    i ← "A"
    Répéter
        Si (pos(i, majus(ch)) = -1) alors
            p ← faux
        Fin si
        i ← chr(ord(i) + 1)
    Jusqu'à (i = "Z") ou (p = faux)
    Retourner p
Fin

Algorithme

Fonction pangramme(ch : chaîne) : booléen
Début
    p ← vrai
    i ← "A"
    Répéter
        Si (pos(i, majus(ch)) = -1) alors
            p ← faux
        Fin si
        i ← chr(ord(i) + 1)
    Jusqu'à (i = "Z") ou (p = faux)
    Retourner p
Fin

Python

def pangramme(ch):
    i = 'A'
    p = True
    while i < 'Z' and p:
        if ch.upper().find(i) == -1:
            p = False
        i = chr(ord(i) + 1)
    return p

Vérifier si deux chaînes sont des anagrammes

Fonction anagramme(ch1, ch2 : chaîne) : booléen
Début
    i ← 0
    Répéter
        Si (pos(ch1[i], ch2) ≠ -1) alors
            ch2 ← Efface(ch2, pos(ch1[i], ch2), pos(ch1[i], ch2)+1)
            ch1 ← Efface(ch1, i, i+1)
        Sinon
            i ← i + 1
        Fin si
    Jusqu'à (ch2 = "") ou (pos(ch1[i], ch2) = -1) ou (ch1 = "")
    Retourner (ch2 = "") et (ch1 = "")
Fin

Algorithme

Fonction anagramme(ch1, ch2 : chaîne) : booléen
Début
    i ← 0
    Répéter
        Si (pos(ch1[i], ch2) ≠ -1) alors
            ch2 ← Efface(ch2, pos(ch1[i], ch2), pos(ch1[i], ch2)+1)
            ch1 ← Efface(ch1, i, i+1)
        Sinon
            i ← i + 1
        Fin si
    Jusqu'à (ch2 = "") ou (pos(ch1[i], ch2) = -1) ou (ch1 = "")
    Retourner (ch2 = "") et (ch1 = "")
Fin

Python

def anagramme(ch1, ch2):
    p = ch2.find(ch1[0])
    while ch2 != "" and ch1 != "" and p != -1:
        if p != -1:
            ch2 = ch2[:p] + ch2[p+1:]
            ch1 = ch1[1:]
        if ch1 != "":
            p = ch2.find(ch1[0])
    return ch1 == "" and ch2 == ""

Vérifier si une chaîne est un tautogramme

Fonction tautogramme(ch : chaîne) : booléen
Début
    Répéter
        Si ch[pos(" ", ch)+1] = ch[0] alors
            ch ← Efface(ch, pos(" ", ch), pos(" ", ch)+1)
        Fin si
    Jusqu'à (pos(" ", ch) = -1) ou (ch[pos(" ", ch)+1] ≠ ch[0])
    Retourner pos(" ", ch) = -1
Fin

Algorithme

Fonction tautogramme(ch : chaîne) : booléen
Début
    Répéter
        Si ch[pos(" ", ch)+1] = ch[0] alors
            ch ← Efface(ch, pos(" ", ch), pos(" ", ch)+1)
        Fin si
    Jusqu'à (pos(" ", ch) = -1) ou (ch[pos(" ", ch)+1] ≠ ch[0])
    Retourner pos(" ", ch) = -1
Fin

Python

def tautogramme(ch):
    p = ch.find(' ')
    while p != -1 and ch[p+1] == ch[0]:
        ch = ch[:p] + ch[p+1:]
        p = ch.find(' ')
    return p == -1

4. Tris et recherches dans un tableau

4.1 Tri à bulles

Procédure tri_bulles(@ T : tab ; n : entier)
Début
    Répéter
        echange ← faux
        Pour i de 1 à n-2 faire
            Si T[i] > T[i+1] alors
                X ← T[i]
                T[i] ← T[i+1]
                T[i+1] ← X
                echange ← vrai
            Fin si
        Fin pour
        n ← n - 1
    Jusqu'à (echange = faux) ou (n = 1)
Fin

4.2 Tri par sélection

0- Définir procédure tri_selection(var T : tab ; n : entier)
1- Pour i de 1 à n-1 faire
       M ← i
       Pour j de i+1 à n faire
           Si T[M] > T[j] alors
               M ← j
           Fin si
       Fin pour
       X ← T[M]
       T[M] ← T[i]
       T[i] ← X
   Fin pour
2- Fin tri_selection

4.3 Chercher un élément dans un tableau

0- Définir fonction existe(T : tab ; n, x : entier) : booléen
1- i ← 1
   Répéter
       Si T[i] = x alors
           test ← vrai
       Sinon
           test ← faux
       Fin si
       i ← i + 1
   Jusqu'à (i >= n) ou (test = vrai)
2- existe ← test
3- Fin existe

4.4 Vérifier si les éléments d'un tableau sont distincts

0- Définir fonction distinct(T : tab ; n : entier) : booléen
1- i ← 1
   Tant que (i < n) et (n ≠ 1) et (T[i] ≠ T[n]) faire
       i ← i + 1
   Fin tant que
2- distinct ← (i = n)
3- Fin distinct