Langage naturel vers Python : QCM de maths en terminale pour réviser ses cours à télécharger en PDF

Langage naturel vers Python – QCM de maths niveau Terminale sur Maths-pdf.fr

Couverture : Livre de contrôles corrigés de maths Terminale en PDF

Télécharger en PDF Le livre des 25 contrôles corrigés en Terminale PDF à imprimer Voir le livre ›

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))

Enfin, pour approfondir la notion, tu peux aussi consulter Éduscol.

Nos conseils pour bien répondre

D’abord, vérifie que tu maîtrises les bases de qcm de maths en terminale sur le langage naturel vers python, souvent nécessaires pour répondre correctement. De plus, prends le temps de refaire le calcul au brouillon plutôt que de répondre à l’instinct.

Sois particulièrement attentif à exercices interactifs corrigés, qui est une source fréquente d’erreurs dans ce chapitre. Enfin, un entraînement régulier sur ce chapitre vaut mieux qu’une révision de dernière minute. Tu peux aussi t’entraîner avec dénombrement : QCM de maths en terminale pour réviser ses cours.

4.9/5 - (35564 votes)

Télécharger en PDF Le livre des 25 contrôles corrigés en Terminale PDF à imprimer Voir le livre ›

Maths PDF c'est 16 266 111 cours et exercices de maths téléchargés en PDF et 4 250 exercices.

Langage naturel vers Python : QCM de maths en terminale pour réviser ses cours à télécharger en PDF

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

Quiz terminé !

Nos conseils pour bien répondre

Ressources de maths en Terminale

Cours

Exercices corrigés

Contrôles

QCM