Découpage en fonctions

Au IX^e siècle, le mathématicien Thābit ibn Qurra a étudié la somme des diviseurs propres des entiers (c'est-à-dire les diviseurs d'un nombre strictement inférieurs à celui-ci) pour rechercher des nombres remarquables.

On considère le programme Python ci-dessous composé de deux fonctions :

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

def somme_liste(L):
    s = 0
    for x in L:
        s = s + x
    return s

Déterminer la valeur renvoyée par l'instruction somme_liste(diviseurs_propres(12)).

Saisir la valeur renvoyée par l'instruction.

On considère les deux fonctions Python ci-dessous :

def multiplier(x, k):
    return x * k

def calculer_somme(liste, k):
    s = 0
    for x in liste:
        s = s + multiplier(x, k)
    return s

On exécute le programme avec la liste L = [3, 7, 10].

Sachant que l'appel calculer_somme(L, k) renvoie la valeur $80$, déterminer la valeur de l'argument k.

Saisir la valeur de k.

On considère le programme Python suivant :

def esperance(valeurs, probas):
    e = 0
    for i in range(len(valeurs)):
        e = e + valeurs[i] * probas[i]
    return e

valeurs = [10, 20, 30]
probas = [0.2, 0.5, 0.3]

Déterminer la valeur renvoyée par l'appel esperance(valeurs, probas).

Saisir la valeur numérique renvoyée par le programme.

On considère la fonction suivante rédigée en langage Python :

def calcul(V, P):
    s = 0
    for i in range(len(V)):
        s = s + V[i] * P[i]
    return s

On exécute l'instruction calcul([2, 6, k], [0.1, 0.3, 0.6]) où $k$ est un nombre réel.

Sachant que cette instruction renvoie le nombre $8$, déterminer la valeur du paramètre $k$.

Saisir la valeur de $k$.

On considère le programme Python suivant composé de trois fonctions :

def filtrer_impairs(liste):
    res = []
    for x in liste:
        if x % 2 != 0:
            res.append(x)
    return res

def moyenne(liste):
    return sum(liste) / len(liste)

def chercher_indice(donnees, valeur_cible):
    for i in range(len(donnees)):
        f = filtrer_impairs(donnees[i])
        if moyenne(f) == valeur_cible:
            return i
    return -1

Soit donnees une liste composée de $50$ sous-listes $L_0, L_1, \dots, L_{49}$, où pour tout entier $i$ allant de $0$ à $49$, la sous-liste $L_i$ est définie par :

On sait que l'exécution de la commande chercher_indice(donnees, V) renvoie la valeur $35$.

Déterminer la valeur du nombre $V$.

Ératosthène de Cyrène (III^e siècle av. J.-C.) a élaboré un procédé algorithmique pour obtenir la liste des nombres premiers. Le script Python ci-dessous implémente cette méthode pour filtrer les entiers de $2$ à $n$ :

def crible_eratosthene(n):
    nombres = list(range(2, n + 1))
    premiers = []
    while len(nombres) > 0:
        p = nombres[0]
        premiers.append(p)
        nombres = [x for x in nombres if x % p != 0]
    return premiers

Déterminer la valeur renvoyée par l'instruction len(crible_eratosthene(20)).

On considère le programme écrit en langage Python composé de trois fonctions interdépendantes :

def est_impair(n):
    return n % 2 != 0

def transformer(n):
    if est_impair(n):
        return 3 * n + 1
    else:
        return n // 2

def traiter_liste(liste):
    somme = 0
    for x in liste:
        somme = somme + transformer(x)
    return somme

On exécute la fonction traiter_liste avec la liste L = [10, k, 5], où $k$ est un nombre entier naturel.

L'appel traiter_liste([10, k, 5]) renvoie la valeur 35.

Saisir la valeur de l'entier $k$.

En 1772, le mathématicien Leonhard Euler s'intéresse aux formules quadratiques générant des nombres premiers. On considère le programme Python modulaire suivant, où la fonction diviseurs(val) utilise une liste par compréhension pour recenser tous les diviseurs d'un entier :

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

def est_premier(val):
    if val < 2:
        return False
    return len(diviseurs(val)) == 2

def polynome(n):
    return n**2 + n + 17

def premier_contre_exemple():
    n = 0
    while est_premier(polynome(n)):
        n = n + 1
    return n

Déterminer la valeur entière renvoyée par la fonction premier_contre_exemple().

On considère le script Python ci-dessous composé de trois fonctions complémentaires :

def moyenne(liste):
    somme = 0
    for val in liste:
        somme += val
    return somme / len(liste)

def sous_liste(liste, debut, taille):
    extrait = []
    for j in range(debut, debut + taille):
        extrait.append(liste[j])
    return extrait

def compte_valides(liste, taille, seuil):
    compteur = 0
    for i in range(len(liste) - taille + 1):
        bloc = sous_liste(liste, i, taille)
        if moyenne(bloc) > seuil:
            compteur += 1
    return compteur

On définit la liste $L = [10, 15, 8, 14, 11, 16, 9, 13, 12]$.

On s'intéresse à l'exécution de l'instruction compte_valides(L, 3, S), où $S$ désigne un nombre entier.

Saisir la plus petite valeur entière du paramètre $S$ pour laquelle l'appel compte_valides(L, 3, S) renvoie la valeur $0$.