Langage naturel vers Python : QCM de maths en terminale pour réviser ses cours.

Mis à jour le 26 septembre 2025

Sommaire

Des QCM de maths en terminale sur le langage naturel vers Python pour transformer tes idées mathématiques en code informatique fonctionnel.
Ces exercices interactifs corrigés travaillent la traduction d’algorithmes, la syntaxe Python, les structures de données et l’implémentation de méthodes numériques.
Chaque questionnaire améliore tes compétences en algorithmique appliquée et perfectionne ta logique de programmation mathématique.
Un entraînement concret pour maîtriser cette compétence transversale et valoriser ton profil scientifique au bac !
Des exemples pratiques illustrent le passage du raisonnement à l’exécution informatique.

Langage naturel vers Python et traduction d'algorithmes - QCM Terminale

Score: 0/10

Questions répondues: 0/10

Question 1

Traduire en Python l'algorithme suivant : 'Prendre un nombre n en entrée. Si n est pair, le diviser par 2. Sinon, le multiplier par 3 et ajouter 1. Répéter cette opération jusqu'à obtenir 1. Retourner le nombre d'étapes nécessaires.'

def collatz(n):
    steps = 0
    while n != 1:
        if n % 2 == 0:
            n = n // 2
        else:
            n = 3*n + 1
        steps += 1
    return steps

def collatz(n):
    steps = 0
    while n > 1:
        if n % 2 == 0:
            n /= 2
        else:
            n = 3*n + 1
        steps += 1
    return steps

def collatz(n):
    steps = 1
    while n != 1:
        if n % 2 == 0:
            n = n // 2
        else:
            n = 3*n + 1
        steps += 1
    return steps

def collatz(n):
    steps = 0
    while n != 1:
        if n / 2 == 0:
            n = n // 2
        else:
            n = 3*n + 1
        steps += 1
    return steps

Question 2

Traduire en Python : 'Créer une fonction qui prend une liste de nombres et retourne True si la liste est triée par ordre croissant, False sinon.'

def est_triee(liste):
    for i in range(len(liste)):
        if liste[i] > liste[i+1]:
            return False
    return True

def est_triee(liste):
    for i in range(len(liste)-1):
        if liste[i] > liste[i+1]:
            return False
    return True

def est_triee(liste):
    for i in range(1, len(liste)):
        if liste[i] < liste[i-1]:
            return False
    return True

def est_triee(liste):
return liste == sorted(liste)

Question 3

Traduire en Python : 'Créer une fonction qui prend un texte en paramètre et retourne un dictionnaire avec le nombre d'occurrences de chaque lettre (sans tenir compte de la casse).'

def compte_lettres(texte):
    occurences = {}
    for lettre in texte:
        if lettre.isalpha():
            occurences[lettre] = occurences.get(lettre, 0) + 1
    return occurences

def compte_lettres(texte):
    occurences = {}
    for lettre in texte.lower():
        occurences[lettre] = occurences.get(lettre, 0) + 1
    return occurences

def compte_lettres(texte):
    occurences = {}
    for lettre in texte.lower():
        if lettre.isalpha():
            occurences[lettre] = occurences.get(lettre, 0) + 1
    return occurences

def compte_lettres(texte):
return {l: texte.lower().count(l) for l in texte.lower() if l.isalpha()}

Question 4

Traduire en Python : 'Écrire une fonction qui prend un nombre entier positif n et retourne la liste de tous ses diviseurs dans l'ordre croissant.'

def diviseurs(n):
    divs = []
    for d in range(1, n+1):
        if n % d == 0:
            divs.append(d)
    return divs

def diviseurs(n):
    divs = set()
    for d in range(1, n+1):
        if n % d == 0:
            divs.add(d)
    return sorted(divs)

def diviseurs(n):
return [d for d in range(1, n+1) if n % d == 0]

def diviseurs(n):
return sorted([d for d in range(1, n+1) if n % d == 0])

Question 5

Traduire en Python : 'Créer une fonction qui prend deux listes de même longueur et retourne une nouvelle liste où chaque élément est le plus grand des éléments correspondants des deux listes.'

def max_elements(liste1, liste2):
return [max(a, b) for a, b in zip(liste1, liste2)]

def max_elements(liste1, liste2):
    resultat = []
    for i in range(len(liste1)):
        resultat.append(max(liste1[i], liste2[i]))
    return resultat

def max_elements(liste1, liste2):
return list(map(max, liste1, liste2))

def max_elements(liste1, liste2):
return [liste1[i] if liste1[i] > liste2[i] else liste2[i] for i in range(len(liste1))]

Question 6

Traduire en Python : 'Créer une fonction qui prend une chaîne de caractères et retourne True si c'est un palindrome (en ignorant les espaces et la ponctuation), False sinon.'

def est_palindrome(texte):
t = texte.lower().replace(' ', '')
return t == t[::-1]

def est_palindrome(texte):
t = ''.join(c.lower() for c in texte if c.isalnum())
return t == t[::-1]

def est_palindrome(texte):
return texte.lower() == texte.lower()[::-1]

def est_palindrome(texte):
t = ''.join(c for c in texte.lower() if c.isalpha())
return t == ''.join(reversed(t))

Question 7

Traduire en Python : 'Créer une fonction qui prend une liste et retourne une nouvelle liste sans doublons, en préservant l'ordre d'apparition des éléments.'

def sans_doublons(liste):
    resultat = []
    for x in liste:
        if x not in resultat:
            resultat.append(x)
    return resultat

def sans_doublons(liste):
return list(set(liste))

def sans_doublons(liste):
return list(dict.fromkeys(liste))

def sans_doublons(liste):
vus = set()
return [x for x in liste if not (x in vus or vus.add(x))]

Question 8

Traduire en Python : 'Créer une fonction qui prend un nombre entier n et retourne les n premiers termes de la suite de Fibonacci sous forme de liste.'

def fibonacci(n):
    fib = [0, 1]
    for _ in range(n-2):
        fib.append(fib[-1] + fib[-2])
    return fib

def fibonacci(n):
    if n <= 0: return []
    if n == 1: return [0]
    fib = [0, 1]
    for _ in range(2, n):
        fib.append(fib[-1] + fib[-2])
    return fib

def fibonacci(n):
a, b = 0, 1
return [a + b * i for i in range(n)]

def fibonacci(n):
    if n <= 0: return []
    fib = [0]
    a, b = 0, 1
    for _ in range(n-1):
        fib.append(b)
        a, b = b, a + b
    return fib

Question 9

Traduire en Python : 'Créer une fonction qui prend une chaîne de caractères contenant des parenthèses et vérifie si elles sont bien équilibrées.'

def parentheses_equilibrees(chaine):
return chaine.count('(') == chaine.count(')')

def parentheses_equilibrees(chaine):
    pile = []
    for c in chaine:
        if c == '(':
            pile.append(c)
        elif c == ')':
            if not pile:
                return False
            pile.pop()
    return len(pile) == 0

def parentheses_equilibrees(chaine):
    compte = 0
    for c in chaine:
        if c == '(': compte += 1
        elif c == ')': compte -= 1
        if compte < 0: return False
    return compte == 0

def parentheses_equilibrees(chaine):
    while '()' in chaine:
        chaine = chaine.replace('()', '')
    return chaine == ''

Question 10

Traduire en Python : 'Créer une fonction qui prend une liste de nombres et retourne un tuple contenant la plus longue séquence croissante et sa longueur.'

def plus_longue_sequence(liste):
    if not liste: return ([], 0)
    longueur_max = 1
    seq_max = [liste[0]]
    longueur_courante = 1
    seq_courante = [liste[0]]
    for i in range(1, len(liste)):
        if liste[i] > liste[i-1]:
            longueur_courante += 1
            seq_courante.append(liste[i])
        else:
            longueur_courante = 1
            seq_courante = [liste[i]]
        if longueur_courante > longueur_max:
            longueur_max = longueur_courante
            seq_max = seq_courante[:]
    return (seq_max, longueur_max)

def plus_longue_sequence(liste):
    if not liste: return ([], 0)
    meilleure_seq = [liste[0]]
    seq_courante = [liste[0]]
    for x in liste[1:]:
        if x > seq_courante[-1]:
            seq_courante.append(x)
        else:
            if len(seq_courante) > len(meilleure_seq):
                meilleure_seq = seq_courante[:]
            seq_courante = [x]
    if len(seq_courante) > len(meilleure_seq):
        meilleure_seq = seq_courante
    return (meilleure_seq, len(meilleure_seq))

def plus_longue_sequence(liste):
    max_len = curr_len = 1
    max_seq = curr_seq = [liste[0]]
    for num in liste[1:]:
        if num > curr_seq[-1]:
            curr_seq.append(num)
            curr_len += 1
            if curr_len > max_len:
                max_len = curr_len
                max_seq = curr_seq[:]
        else:
            curr_seq = [num]
            curr_len = 1
    return (max_seq, max_len)

def plus_longue_sequence(liste):
    sequences = []
    seq_courante = []
    for x in liste:
        if not seq_courante or x > seq_courante[-1]:
            seq_courante.append(x)
        else:
            sequences.append(seq_courante)
            seq_courante = [x]
    sequences.append(seq_courante)
    meilleure_seq = max(sequences, key=len)
    return (meilleure_seq, len(meilleure_seq))

4.9/5 - (35564 votes)

D'autres cours et exercices corrigés

Somme de variables aléatoires

Loi des grands nombres

Produit scalaire

Dénombrement

Fonction trigonométrique

Théorèmes de Bézout et de Gauss

Forme algébrique d’un complexe

Schéma de Bernoulli

📚✏️

👥 8

🎓 L'équipe MATHS PDF

⚡ Mis à jour quotidiennement

👨‍🏫 8 Enseignants Titulaires 👩‍🏫

🏫 Collectif d'enseignants titulaires de l'Éducation Nationale en poste dans les écoles primaires, collèges et lycées.
📝 Notre équipe collaborative enrichit quotidiennement nos cours de maths et exercices corrigés.
✅ Expertise multi-niveaux • 📅 Contenu actualisé chaque jour • 🎯 Méthodes éprouvées

📚 Tous nos cours ✏️ Tous nos exercices

Nos applications

Téléchargez la dernière version gratuite de nos applications.