Aller au contenu

Un mot pour Fahmio

Tu écris. Tu continues.

Un problème, une idée — assez pour qu’on comprenne, puis tu retournes à ta copie.

On lit. Tu n’as rien d’autre à faire.

Où veux-tu aller ?

↑ ↓ pour parcourir · Entrée pour ouvrir · Échap pour fermer

Fahmio
Fahmio
Bac Tunisie
RA-KAlgorithmes récurrents et arithmétiques

Nombre défini par l’énoncé : fonction de test construite sur une brique (chiffres, facteurs premiers), N premiers, filtrage d’un tableau et affichage groupé

Idée directrice

L’énoncé invente une propriété (nombre de Keith, premier sûr, primaire, triangulaire carré…) et la montre sur trois ou quatre exemples, dont un contre-exemple. Tout se joue sur la traduction de la définition en une fonction de test bâtie sur une brique connue — extraction des chiffres par Mod 10 / Div 10, décomposition en facteurs premiers, primalité, factorielle, conversion de base. Cette fonction devient ensuite une boîte noire : on l’appelle dans une boucle Répéter … Jusqu’à cpt = N pour afficher les N premiers, ou dans un parcours qui recopie dans T2 les éléments de T1 qui la vérifient, avant un affichage regroupé.

Ce qui aide à reconnaître la démarche

« Un entier … est dit … s’il … » ; « Exemples : » ; « qui permet de retourner la valeur de l’entier … et 0 dans le cas contraire » ; « qui affiche les N premiers … » ; « générer un deuxième tableau T2 contenant les éléments de T1 qui sont … » ; « regroupés selon leurs nombres de chiffres »

Besoin d’un point de départ ? Voir la méthode
  • Tester chaque exemple de l’énoncé à la main avant d’écrire : il révèle la brique (chiffres, facteurs, primalité) et le cas limite que le contre-exemple veut piéger.
  • Écrire d’abord les briques (somme des chiffres, décomposition, Premier), puis une fonction de test courte qui ne fait que les combiner.
  • Une fonction qui « retourne le paramètre ou 0 » évite de recalculer : un seul appel donne à la fois la réponse et la valeur utile.
  • « Les N premiers » : Répéter, candidat suivant, compteur, jusqu’à compteur = N ; « les éléments de T1 qui… » : Pour sur T1, recopie à l’indice N2 puis N2 ← N2 + 1.
  • Affichage groupé : une boucle sur le critère de groupe (nombre de chiffres) englobe le parcours de T2.
Les pièges à vérifier dans ta démarche

Oublier la condition « composé » (13 passerait le test des sommes). Incrémenter d après une division réussie : pour 27 = 3 × 3 × 3, on ajouterait 3 puis 9 (qui n’est pas premier), soit 12 au lieu de 9. Réécrire le test dans chaque module au lieu d’appeler la fonction. Saisir T1 sans contrôler le nombre de chiffres, ou compter les chiffres avec une boucle alors que Long(Convch(x)) suffit. Afficher « Aucun… » pour chaque élément au lieu d’une fois par groupe vide.

Sujet principal

Problème (13 points) — dans l’esprit des problèmes des sessions principales 2015 et 2025

15 questionsCorrigé masqué

Un entier naturel composé n (c’est-à-dire non premier, avec n ≥ 4) est dit nombre de Smith si la somme de ses chiffres est égale à la somme des chiffres de tous ses facteurs premiers, chaque facteur étant compté autant de fois qu’il apparaît dans la décomposition de n en produit de facteurs premiers.

Exemples :

  • 58 = 2 × 29 : la somme des chiffres de 58 est 5 + 8 = 13 et celle de ses facteurs est 2 + (2 + 9) = 13, donc 58 est un nombre de Smith.
  • 27 = 3 × 3 × 3 : 2 + 7 = 9 et 3 + 3 + 3 = 9, donc 27 est un nombre de Smith.
  • 30 = 2 × 3 × 5 : 3 + 0 = 3 alors que 2 + 3 + 5 = 10, donc 30 n’est pas un nombre de Smith.
  • 13 est premier : 13 n’est pas un nombre de Smith, bien que la somme de ses chiffres soit égale à celle de son unique facteur.

On se propose d’écrire un programme qui permet de :

  • remplir un tableau T1 par N1 entiers (5 ≤ N1 ≤ 20), chacun composé de 2 à 4 chiffres ;
  • générer un deuxième tableau T2 contenant les entiers de T1 qui sont des nombres de Smith ;
  • afficher les entiers de T2 regroupés selon leur nombre de chiffres, comme dans l’exemple suivant.

Exemple : pour N1 = 12 et T1 = [85, 4937, 202, 31, 666, 1000, 94, 3251, 58, 729, 121, 2025], le tableau généré est T2 = [85, 202, 666, 94, 58, 729, 121] et le programme affiche les trois lignes :

  • « 85, 94, 58 : nombre(s) de Smith de 2 chiffres. »
  • « 202, 666, 729, 121 : nombre(s) de Smith de 3 chiffres. »
  • « Aucun nombre de Smith de 4 chiffres. »

Travail demandé :

  1. Vérifier, en détaillant les calculs, que 378 est un nombre de Smith et que 91 n’en est pas un.
  2. Briques du test :
    1. Écrire l’algorithme d’une fonction SomChif(n) qui retourne la somme des chiffres d’un entier naturel n.
    2. Écrire l’algorithme d’une fonction SomFact(n) qui, pour un entier n ≥ 2, retourne la somme des chiffres de ses facteurs premiers (comptés avec leur multiplicité) si n est composé, et 0 si n est premier. On cherchera les diviseurs de n à partir de 2, en divisant n chaque fois que c’est possible. Exemples : SomFact(85) retourne 13 car 85 = 5 × 17 ; SomFact(97) retourne 0.
    3. En faisant appel aux deux fonctions précédentes, écrire l’algorithme d’une fonction booléenne Smith(n) qui vérifie si n est un nombre de Smith.
  3. Écrire l’algorithme d’une procédure Premiers_Smith(N) qui affiche les N premiers nombres de Smith. Pour N = 6, elle affiche 4, 22, 27, 58, 85 et 94. N est déjà saisi dans le programme appelant.
  4. Écrire l’algorithme du programme principal, solution au problème posé, en le décomposant en modules (Remplir, Generer, Afficher).
  5. Écrire l’algorithme de chacun des modules Remplir, Generer et Afficher.

N.B. : le candidat est appelé à dresser les tableaux de déclaration des objets et des nouveaux types nécessaires.

Voir la correction commentéeAprès avoir posé votre démarche

1. Idée : décomposer en divisant chaque fois par le plus petit diviseur possible ; ce diviseur est forcément premier. 378 = 2 × 189 = 2 × 3 × 63 = 2 × 3 × 3 × 21 = 2 × 3 × 3 × 3 × 7.

  • Somme des chiffres de 378 : 3 + 7 + 8 = 18 ; somme des chiffres des facteurs : 2 + 3 + 3 + 3 + 7 = 18. 378 est composé et les deux sommes sont égales : 378 est un nombre de Smith.
  • 91 = 7 × 13 : 9 + 1 = 10 alors que 7 + (1 + 3) = 11. 91 n’est pas un nombre de Smith.

2.a Idée : n Mod 10 donne le chiffre des unités, n Div 10 le supprime ; on s’arrête quand n devient nul.

Fonction SomChif (n : Entier) : Entier
DEBUT
    s ← 0
    Tant que n ≠ 0 Faire
        s ← s + n Mod 10
        n ← n Div 10
    Fin Tant que
    Retourner s
FIN

TDOL de SomChif : s — Type/Nature : Entier — somme des chiffres déjà extraits.

2.b Idée : tant que n > 1, si d divise n on ajoute les chiffres de d et on divise n par d (sans changer d, pour compter la multiplicité) ; sinon on passe à d + 1. Chaque d retenu est premier, puisque ses propres diviseurs ont déjà été retirés. Un seul facteur trouvé signifie que n était premier.

Fonction SomFact (n : Entier) : Entier
DEBUT
    s ← 0
    nbf ← 0
    d ← 2
    Tant que n > 1 Faire
        Si n Mod d = 0 Alors
            s ← s + SomChif(d)
            nbf ← nbf + 1
            n ← n Div d
        Sinon
            d ← d + 1
        FinSi
    Fin Tant que
    Si nbf ≥ 2 Alors
        Retourner s
    Sinon
        Retourner 0
    FinSi
FIN

TDOL de SomFact :

  • s — Type/Nature : Entier — somme des chiffres des facteurs
  • nbf — Type/Nature : Entier — nombre de facteurs premiers trouvés
  • d — Type/Nature : Entier — diviseur essayé
  • SomChif — Type/Nature : Fonction — somme des chiffres

Contrôle sur 85 : d = 2, 3, 4 ne divisent pas ; d = 5 donne s = 5 et n = 17 ; d avance jusqu’à 17, s = 5 + 8 = 13 et n = 1 ; nbf = 2, la fonction retourne 13. Pour 97, le seul facteur est 97 lui-même (nbf = 1) : retour 0. Le paramètre n est passé par valeur : le diviser dans la fonction ne modifie pas l’objet de l’appelant.

2.c Idée : traduire la définition mot pour mot — composé (SomFact non nul) et sommes égales.

Fonction Smith (n : Entier) : Booléen
DEBUT
    f ← SomFact(n)
    Retourner (f ≠ 0) Et (f = SomChif(n))
FIN

TDOL de Smith : f — Entier — résultat de SomFact ; SomFact, SomChif — Fonction. Avec 13 : SomFact(13) = 0, le test est faux, conformément à l’exemple de l’énoncé.

3. Idée : on ne sait pas jusqu’où chercher, seulement combien en trouver : boucle Répéter avec un compteur, en partant de 4, le plus petit entier composé.

Procédure Premiers_Smith (N : Entier)
DEBUT
    cpt ← 0
    n ← 3
    Répéter
        n ← n + 1
        Si Smith(n) Alors
            Ecrire(n)
            cpt ← cpt + 1
        FinSi
    Jusqu'à cpt = N
FIN

TDOL : cpt, n — Entier — nombres trouvés, entier examiné ; Smith — Fonction. Pour N = 6 : 4 = 2 × 2 (4 et 2 + 2), 22 = 2 × 11 (4 et 4), puis 27, 58, 85 et 94.

4. Programme principal :

Algorithme Nombres_Smith
DEBUT
    Remplir(T1, N1)
    Generer(T1, N1, T2, N2)
    Afficher(T2, N2)
FIN

Tableau de déclaration des nouveaux types : TAB = Tableau de 20 Entiers.

Tableau de déclaration des objets globaux :

  • T1, T2 — Type/Nature : TAB — entiers saisis, nombres de Smith retenus
  • N1, N2 — Type/Nature : Entier — tailles effectives de T1 et T2
  • Remplir, Generer, Afficher — Type/Nature : Procédure

5. Idée : la saisie contrôle les deux contraintes chiffrées de l’énoncé ; un entier de 2 à 4 chiffres est compris entre 10 et 9999.

Procédure Remplir (@T : TAB, @N : Entier)
DEBUT
    Répéter
        Ecrire("N1 = "), Lire(N)
    Jusqu'à (N ≥ 5) Et (N ≤ 20)
    Pour i de 0 à N - 1 Faire
        Répéter
            Ecrire("T1[", i, "] = ")
            Lire(T[i])
        Jusqu'à (T[i] ≥ 10) Et (T[i] ≤ 9999)
    Fin Pour
FIN

TDOL de Remplir : i — Entier — compteur.

Procédure Generer (T1 : TAB, N1 : Entier,
                   @T2 : TAB, @N2 : Entier)
DEBUT
    N2 ← 0
    Pour i de 0 à N1 - 1 Faire
        Si Smith(T1[i]) Alors
            T2[N2] ← T1[i]
            N2 ← N2 + 1
        FinSi
    Fin Pour
FIN

TDOL de Generer : i — Entier — compteur ; Smith — Fonction. N2 sert à la fois de compteur et de prochaine case libre de T2.

Idée pour l’affichage : pour chaque longueur k de 2 à 4, on parcourt T2 et on concatène les éléments de k chiffres ; une chaîne restée vide donne la ligne « Aucun… ».

Procédure Afficher (T : TAB, N : Entier)
DEBUT
    Pour k de 2 à 4 Faire
        ch ← ""
        Pour i de 0 à N - 1 Faire
            Si Long(Convch(T[i])) = k Alors
                Si ch ≠ "" Alors
                    ch ← ch + ", "
                FinSi
                ch ← ch + Convch(T[i])
            FinSi
        Fin Pour
        Si ch = "" Alors
            Ecrire("Aucun nombre de Smith de ",
                   k, " chiffres.")
        Sinon
            Ecrire(ch, " : nombre(s) de Smith",
                   " de ", k, " chiffres.")
        FinSi
    Fin Pour
FIN

TDOL d’Afficher : k, i — Entier — nombre de chiffres traité, compteur ; ch — Chaîne — ligne en construction.

Sur l’exemple : 4937 et 3251 sont premiers (SomFact retourne 0), 31 aussi ; 1000 = 2³ × 5³ donne 1 contre 21 et 2025 = 3⁴ × 5² donne 9 contre 22. Restent 85, 202 = 2 × 101, 666 = 2 × 3 × 3 × 37, 94, 58, 729 = 3⁶ et 121 = 11 × 11, soit T2 = [85, 202, 666, 94, 58, 729, 121] ; les trois lignes affichées sont celles de l’énoncé, la longueur 4 n’ayant aucun élément.

Changer d’énoncé, garder le raisonnement

Choisis un seul transfert après le sujet principal. Qu’est-ce qui change ? Quel résultat ou quelle méthode peux-tu réutiliser ? Les autres exercices restent disponibles pour une prochaine séance.

Variantes rencontrées : nombres de Keith, test par la suite générée à partir des chiffres, T2 et affichage regroupé par nombre de chiffres (principale 2025, sections Mathématiques, Sciences expérimentales et Sciences techniques) ; éléments premiers sûrs rangés en tête puis triés (principale 2015) ; séquences de nombres premiers consécutifs (principale 2026) ; en section Sciences de l’informatique : N premiers nombres primaires (contrôle 2016), auto-nombre (principale 2015), suite de Baum-Sweet (contrôle 2015), couples A!·B! mod (A+B) (principale 2017), chiffres distincts en base B (contrôle 2018), triangulaires carrés dans un tableau d’enregistrements (contrôle 2021), quadruplets de premiers jumeaux (principale 2021), nombres brésiliens vers un fichier (principale 2022). Les séries des enseignants en font leur famille la plus fournie (nombres étranches, de Smith, doublement palindromes…).

Exercices d'entraînement — une nuance à la fois

1 Drill RA-K.1 — brique « chiffres » : nombre heureux, suite générée à partir des chiffres jusqu’à une valeur d’arrêt
Entraînement 01 / 06

Drill RA-K.1 — brique « chiffres » : nombre heureux, suite générée à partir des chiffres jusqu’à une valeur d’arrêt

4 questionsCorrigé masqué

À tout entier naturel non nul n, on associe la somme des carrés de ses chiffres, notée SC(n). Par exemple SC(68) = 6² + 8² = 100. En remplaçant n par SC(n) et en recommençant, on admet qu’on obtient toujours, après un nombre fini d’étapes, soit la valeur 1, soit la valeur 4 (qui fait ensuite tourner indéfiniment le cycle 4, 16, 37, 58, 89, 145, 42, 20, 4). L’entier n est dit heureux si l’on aboutit à 1.

Exemples : 19 est heureux car 19 → 82 → 68 → 100 → 1 ; 15 n’est pas heureux car 15 → 26 → 40 → 16 → 37 → 58 → 89 → 145 → 42 → 20 → 4.

  1. Montrer, en écrivant les valeurs successives, que 7 est heureux.
  2. Écrire l’algorithme d’une fonction SC(n) qui retourne la somme des carrés des chiffres de n.
  3. En utilisant SC, écrire l’algorithme d’une fonction booléenne Heureux(n). Expliquer pourquoi son exécution se termine toujours.
  4. Écrire l’algorithme d’un module qui affiche les N premiers entiers heureux (N est déjà saisi). Pour N = 8, on obtient 1, 7, 10, 13, 19, 23, 28, 31.
Voir la correction commentéeAprès avoir posé votre démarche

1. 7 → 7² = 49 → 16 + 81 = 97 → 81 + 49 = 130 → 1 + 9 + 0 = 10 → 1 : on aboutit à 1, 7 est heureux\boxed{7 \text{ est heureux}}.

2. Idée : même parcours des chiffres que pour une somme, en cumulant le carré du chiffre.

Fonction SC (n : Entier) : Entier
DEBUT
    s ← 0
    Tant que n ≠ 0 Faire
        c ← n Mod 10
        s ← s + c * c
        n ← n Div 10
    Fin Tant que
    Retourner s
FIN

TDOL : s, c — Type/Nature : Entier — somme des carrés, chiffre des unités.

3. Idée : on ne connaît pas le nombre d’étapes, mais on connaît les deux valeurs d’arrêt : Répéter … Jusqu’à (n = 1) Ou (n = 4), puis tester laquelle a été atteinte.

Fonction Heureux (n : Entier) : Booléen
DEBUT
    Répéter
        n ← SC(n)
    Jusqu'à (n = 1) Ou (n = 4)
    Retourner n = 1
FIN

TDOL : SC — Fonction. La boucle se termine parce que l’énoncé garantit que la suite atteint 1 ou 4 après un nombre fini d’étapes. S’arrêter seulement sur 1 ferait tourner indéfiniment le cycle de 4 pour tout entier non heureux. Pour n = 1, un tour donne SC(1) = 1 : 1 est heureux.

4.

Procédure Afficher_Heureux (N : Entier)
DEBUT
    cpt ← 0
    n ← 0
    Répéter
        n ← n + 1
        Si Heureux(n) Alors
            Ecrire(n)
            cpt ← cpt + 1
        FinSi
    Jusqu'à cpt = N
FIN

TDOL : cpt, n — Entier — heureux trouvés, entier examiné ; Heureux — Fonction. 2 → 4 et 3 → 9 → 81 → 65 → 61 → 37 → … → 4 ne sont pas heureux, d’où la liste 1, 7, 10, 13, 19, 23, 28, 31.

2 Drill RA-K.2 — brique « Premier » : triplets de nombres premiers, rangement en tête d’un tableau par permutations
Entraînement 02 / 06

Drill RA-K.2 — brique « Premier » : triplets de nombres premiers, rangement en tête d’un tableau par permutations

4 questionsCorrigé masqué

Un entier p est dit premier de triplet si les trois entiers p, p + 2 et p + 6 sont tous premiers. Exemples : 11 est premier de triplet car 11, 13 et 17 sont premiers ; 23 ne l’est pas car 25 n’est pas premier ; 9 ne l’est pas car 9 n’est pas premier.

  1. Écrire l’algorithme d’une fonction booléenne Premier(n) qui vérifie si un entier n est premier (un nombre premier admet exactement deux diviseurs, 1 et lui-même ; 0 et 1 ne sont pas premiers).
  2. En utilisant Premier, écrire l’algorithme d’une fonction booléenne Triplet(p).
  3. Écrire l’algorithme d’un module Ranger(T, n, nb) qui place en tête d’un tableau T de n entiers, en permutant, les entiers premiers de triplet, dans l’ordre où ils apparaissent, et calcule leur nombre nb.
  4. Donner le contenu de T et la valeur de nb après l’exécution de Ranger(T, 8, nb) pour T = [9, 11, 23, 17, 29, 41, 15, 5].
Voir la correction commentéeAprès avoir posé votre démarche

1. Idée : chercher un diviseur d entre 2 et √n ; s’il n’y en a pas, n est premier. La condition d * d ≤ n évite la racine carrée.

Fonction Premier (n : Entier) : Booléen
DEBUT
    d ← 2
    Tant que (d * d ≤ n) Et (n Mod d ≠ 0) Faire
        d ← d + 1
    Fin Tant que
    Retourner (n ≥ 2) Et (d * d > n)
FIN

TDOL : d — Type/Nature : Entier — diviseur essayé. Contrôles : 2 (boucle non exécutée, 4 > 2 : Vrai), 9 (arrêt sur d = 3, 9 > 9 faux : Faux), 1 (n ≥ 2 faux : Faux).

2.

Fonction Triplet (p : Entier) : Booléen
DEBUT
    Retourner Premier(p) Et Premier(p + 2)
              Et Premier(p + 6)
FIN

3. Idée : nb est à la fois le nombre d’éléments retenus et l’indice de la prochaine place en tête ; chaque élément retenu est échangé avec T[nb].

Procédure Ranger (@T : TAB, n : Entier,
                  @nb : Entier)
DEBUT
    nb ← 0
    Pour i de 0 à n - 1 Faire
        Si Triplet(T[i]) Alors
            aux ← T[i]
            T[i] ← T[nb]
            T[nb] ← aux
            nb ← nb + 1
        FinSi
    Fin Pour
FIN

TDOL : i, aux — Entier — compteur, variable d’échange ; Triplet — Fonction.

4. Les éléments retenus sont 11 (11, 13, 17), 17 (17, 19, 23), 41 (41, 43, 47) et 5 (5, 7, 11) ; 9, 23 (25), 29 (35 = 5 × 7) et 15 sont rejetés. Échanges successifs : i = 1 avec T[0], i = 3 avec T[1], i = 5 avec T[2], i = 7 avec T[3] :

T=[11, 17, 41, 5, 29, 23, 15, 9]T = [11,\ 17,\ 41,\ 5,\ 29,\ 23,\ 15,\ 9]

et nb=4\boxed{nb = 4}. Les quatre premiers de triplet sont en tête, dans leur ordre d’apparition ; l’ordre des autres éléments n’est pas conservé.

3 Drill RA-K.3 — brique « puissances » : nombre puissant, exposants de la décomposition, N premiers
Entraînement 03 / 06

Drill RA-K.3 — brique « puissances » : nombre puissant, exposants de la décomposition, N premiers

3 questionsCorrigé masqué

Un entier n ≥ 2 est dit puissant si, pour tout nombre premier p qui divise n, p² divise aussi n : dans la décomposition de n en facteurs premiers, chaque facteur apparaît avec un exposant au moins égal à 2. Exemples : 72 = 2³ × 3² et 500 = 2² × 5³ sont puissants ; 12 = 2² × 3 et 90 = 2 × 3² × 5 ne le sont pas.

  1. Décomposer 1800 en produit de facteurs premiers et dire s’il est puissant.
  2. Écrire l’algorithme d’une fonction booléenne Puissant(n) qui vérifie si n est puissant, en calculant l’exposant de chaque facteur premier de n.
  3. Écrire l’algorithme d’un module qui affiche les N premiers entiers puissants (N déjà saisi). Pour N = 10, on obtient 4, 8, 9, 16, 25, 27, 32, 36, 49, 64.
Voir la correction commentéeAprès avoir posé votre démarche

1. 1800 = 2 × 900 = 2 × 2 × 450 = 2³ × 225 = 2³ × 3² × 25 = 2³ × 3² × 5². Tous les exposants valent au moins 2 : 1800 est puissant\boxed{1800 \text{ est puissant}}.

2. Idée : pour chaque d à partir de 2, on divise n par d tant que c’est possible en comptant les divisions (exposant e) ; un exposant égal à 1 suffit à conclure. Un d non premier ne divise plus n à ce stade, son exposant vaut 0.

Fonction Puissant (n : Entier) : Booléen
DEBUT
    d ← 2
    ok ← Vrai
    Tant que (n > 1) Et ok Faire
        e ← 0
        Tant que n Mod d = 0 Faire
            n ← n Div d
            e ← e + 1
        Fin Tant que
        Si e = 1 Alors
            ok ← Faux
        FinSi
        d ← d + 1
    Fin Tant que
    Retourner ok
FIN

TDOL :

  • d — Type/Nature : Entier — facteur essayé
  • e — Type/Nature : Entier — exposant de d dans n
  • ok — Type/Nature : Booléen — aucun exposant égal à 1 rencontré

Contrôle sur 90 : d = 2 donne e = 1, ok devient Faux et la boucle s’arrête. Sur 72 : e = 3 pour d = 2, e = 2 pour d = 3, n vaut 1 : Vrai.

3.

Procédure Afficher_Puissants (N : Entier)
DEBUT
    cpt ← 0
    n ← 1
    Répéter
        n ← n + 1
        Si Puissant(n) Alors
            Ecrire(n)
            cpt ← cpt + 1
        FinSi
    Jusqu'à cpt = N
FIN

TDOL : cpt, n — Entier ; Puissant — Fonction. Les dix premiers sont 4, 8, 9, 16, 25, 27, 32, 36 = 2² × 3², 49, 64 ; 12, 18, 20, 24, 28… sont écartés par un exposant égal à 1.

4 Drill RA-K.4 — brique « factorielle » : test de Wilson, factorielle réduite modulo p pour éviter le dépassement
Entraînement 04 / 06

Drill RA-K.4 — brique « factorielle » : test de Wilson, factorielle réduite modulo p pour éviter le dépassement

4 questionsCorrigé masqué

Théorème de Wilson : un entier p ≥ 2 est premier si et seulement si (p − 1)! mod p = p − 1. Exemples : 4! = 24 et 24 mod 5 = 4, donc 5 est premier ; 5! = 120 et 120 mod 6 = 0 ≠ 5, donc 6 n’est pas premier.

  1. On suppose que le type Entier est codé sur 32 bits (plus grande valeur 2 147 483 647). Sachant que 12! = 479 001 600 et 13! = 6 227 020 800, expliquer pourquoi on ne peut pas calculer (p − 1)! puis son reste dès que p ≥ 14.
  2. Écrire l’algorithme d’une fonction FactMod(n, m) qui retourne n! mod m en réduisant modulo m après chaque produit (f ← (f × i) mod m). Donner les valeurs successives de f pour FactMod(6, 7).
  3. En utilisant FactMod, écrire l’algorithme d’une fonction booléenne Wilson(p) qui vérifie si p est premier.
  4. Écrire l’algorithme d’un module qui affiche, à l’aide de Wilson, les nombres premiers compris entre a et b (2 ≤ a ≤ b ≤ 30000, déjà saisis). Pour a = 20 et b = 40, on obtient 23, 29, 31, 37.
Voir la correction commentéeAprès avoir posé votre démarche

1. Pour p ≥ 14, (p − 1)! ≥ 13! = 6 227 020 800 > 2 147 483 647 : la factorielle dépasse la capacité du type Entier avant même le calcul du reste, et le résultat serait faux.

2. Idée : le reste d’un produit ne dépend que des restes des facteurs, donc on peut réduire modulo m à chaque tour ; f reste inférieur à m et le produit f × i reste inférieur à m².

Fonction FactMod (n, m : Entier) : Entier
DEBUT
    f ← 1
    Pour i de 2 à n Faire
        f ← (f * i) Mod m
    Fin Pour
    Retourner f
FIN

TDOL : f, i — Type/Nature : Entier — produit réduit, facteur courant. Trace de FactMod(6, 7) : i = 2 : f = 2 ; i = 3 : f = 6 ; i = 4 : 24 mod 7 = 3 ; i = 5 : 15 mod 7 = 1 ; i = 6 : f = 6. Résultat 6\boxed{6}, égal à 7 − 1 : 7 est premier. Pour m ≤ 30000, f × i < 30000² = 9 × 10⁸, qui reste sous 2 147 483 647.

3.

Fonction Wilson (p : Entier) : Booléen
DEBUT
    Retourner FactMod(p - 1, p) = p - 1
FIN

4.

Procédure Premiers_AB (a, b : Entier)
DEBUT
    Pour p de a à b Faire
        Si Wilson(p) Alors
            Ecrire(p)
        FinSi
    Fin Pour
FIN

TDOL : p — Entier — entier testé ; Wilson — Fonction. Entre 20 et 40 : 23, 29, 31, 37. Pour un nombre composé comme 9, FactMod(8, 9) = 0 ≠ 8.

5 Drill RA-K.5 — (section Sciences de l’informatique) brique « base » : nombre palindrome en base 10 et en base 2
Entraînement 05 / 06

Drill RA-K.5 — (section Sciences de l’informatique) brique « base » : nombre palindrome en base 10 et en base 2

4 questionsCorrigé masqué

Un entier naturel non nul est dit bipalindrome si son écriture décimale et son écriture binaire sont toutes deux des palindromes (elles se lisent de la même façon dans les deux sens). Exemples : 585 est bipalindrome car 585 = (1001001001)2(1001001001)_2 ; 33 = (100001)2(100001)_2 l’est aussi. 11 ne l’est pas : il est palindrome en base 10 mais 11 = (1011)2(1011)_2 ; 44 non plus, car 44 = (101100)2(101100)_2.

  1. Donner l’écriture binaire de 99 et dire si 99 est bipalindrome.
  2. Écrire l’algorithme d’une fonction Binaire(n) qui retourne, sous forme de chaîne, l’écriture binaire de n obtenue par divisions successives par 2.
  3. Écrire l’algorithme d’une fonction booléenne Palindrome(ch).
  4. Écrire l’algorithme d’une procédure qui affiche tous les bipalindromes inférieurs ou égaux à M (1 ≤ M ≤ 30000, déjà saisi). Pour M = 1000, on obtient 1, 3, 5, 7, 9, 33, 99, 313, 585, 717.
Voir la correction commentéeAprès avoir posé votre démarche

1. 99 = 64 + 32 + 2 + 1 = (1100011)2(1100011)_2, qui se lit de la même façon dans les deux sens ; 99 est palindrome en base 10 : 99 est bipalindrome\boxed{99 \text{ est bipalindrome}}.

2. Idée : le reste de la division par 2 est le chiffre de poids faible ; on l’ajoute donc en tête de la chaîne.

Fonction Binaire (n : Entier) : Chaîne
DEBUT
    ch ← ""
    Répéter
        ch ← Convch(n Mod 2) + ch
        n ← n Div 2
    Jusqu'à n = 0
    Retourner ch
FIN

TDOL : ch — Type/Nature : Chaîne — chiffres binaires déjà obtenus.

3. Idée : comparer le i-ème caractère au i-ème en partant de la fin, en s’arrêtant au premier écart ou au milieu.

Fonction Palindrome (ch : Chaîne) : Booléen
DEBUT
    i ← 0
    L ← Long(ch)
    Tant que (i < L Div 2) Et
             (ch[i] = ch[L - 1 - i]) Faire
        i ← i + 1
    Fin Tant que
    Retourner i ≥ L Div 2
FIN

TDOL : i, L — Type/Nature : Entier — position comparée, longueur de ch.

4.

Procédure Bipalindromes (M : Entier)
DEBUT
    Pour n de 1 à M Faire
        Si Palindrome(Convch(n)) Et
           Palindrome(Binaire(n)) Alors
            Ecrire(n)
        FinSi
    Fin Pour
FIN

TDOL : n — Entier ; Palindrome, Binaire — Fonction. Par exemple 313 = (100111001)2(100111001)_2 et 717 = (1011001101)2(1011001101)_2 sont retenus.

6 Drill RA-K.6 — (section Sciences de l’informatique) fonctions qui retournent un paramètre ou 0, tableau d’enregistrements : entiers triangulaires et pentagonaux
Entraînement 06 / 06

Drill RA-K.6 — (section Sciences de l’informatique) fonctions qui retournent un paramètre ou 0, tableau d’enregistrements : entiers triangulaires et pentagonaux

6 questionsCorrigé masqué

Un entier naturel non nul x est dit triangulaire s’il existe un entier n ≥ 1 tel que x = n(n + 1)/2, et pentagonal s’il existe un entier k ≥ 1 tel que x = k(3k − 1)/2. On admet que :

  • x est triangulaire si et seulement si 8x + 1 est le carré d’un entier r, et alors n = (r − 1)/2 ;
  • x est pentagonal si et seulement si 24x + 1 est le carré d’un entier r tel que r + 1 soit divisible par 6, et alors k = (r + 1)/6.

Exemples : 8 × 21 + 1 = 169 = 13², donc 21 est triangulaire (n = 6) ; 24 × 21 + 1 = 505 n’est pas un carré, 21 n’est pas pentagonal. 24 × 22 + 1 = 529 = 23² et 24 est divisible par 6, donc 22 est pentagonal (k = 4). 24 × 7 + 1 = 169 = 13², mais 14 n’est pas divisible par 6 : 7 n’est pas pentagonal.

  1. Écrire l’algorithme d’une fonction Triang(x) qui retourne n si x est triangulaire et 0 sinon (on pourra utiliser Ent et RacineCarré).
  2. Écrire l’algorithme d’une fonction Pent(x) qui retourne k si x est pentagonal et 0 sinon.
  3. Vérifier que 210 est à la fois triangulaire et pentagonal, en donnant n et k.
  4. En faisant appel aux deux fonctions, écrire l’algorithme d’un module Remplir(T, m) qui remplit un tableau T d’enregistrements par les m premiers entiers à la fois triangulaires et pentagonaux ; chaque enregistrement contient le nombre x, l’entier n et l’entier k. Pour m = 3, on obtient (1, 1, 1), (210, 20, 12) et (40755, 285, 165). m est déjà saisi (1 ≤ m ≤ 3) ; déclarer les nouveaux types.
Voir la correction commentéeAprès avoir posé votre démarche

1. Idée : r = Ent(RacineCarré(8x + 1)) ; 8x + 1 est un carré exactement quand r × r = 8x + 1, test en entiers qui évite toute comparaison de réels.

Fonction Triang (x : Entier) : Entier
DEBUT
    r ← Ent(RacineCarré(8 * x + 1))
    Si r * r = 8 * x + 1 Alors
        Retourner (r - 1) Div 2
    Sinon
        Retourner 0
    FinSi
FIN

TDOL : r — Type/Nature : Entier — partie entière de la racine. 8x + 1 est impair, donc r aussi, et r − 1 est pair.

2.

Fonction Pent (x : Entier) : Entier
DEBUT
    r ← Ent(RacineCarré(24 * x + 1))
    Si (r * r = 24 * x + 1) Et
       ((r + 1) Mod 6 = 0) Alors
        Retourner (r + 1) Div 6
    Sinon
        Retourner 0
    FinSi
FIN

3. 8 × 210 + 1 = 1681 = 41², n = (41 − 1)/2 = 20 ; 24 × 210 + 1 = 5041 = 71² et 72 est divisible par 6, k = 72/6 = 12. En effet 20 × 21/2 = 210 et 12 × 35/2 = 210 : n=20, k=12\boxed{n = 20,\ k = 12}.

4. Nouveaux types : Tri = Enregistrement x, n, k : Entier Fin et TAB = Tableau de 3 Tri.

Procédure Remplir (@T : TAB, m : Entier)
DEBUT
    i ← 0
    x ← 0
    Répéter
        x ← x + 1
        n ← Triang(x)
        k ← Pent(x)
        Si (n ≠ 0) Et (k ≠ 0) Alors
            T[i].x ← x
            T[i].n ← n
            T[i].k ← k
            i ← i + 1
        FinSi
    Jusqu'à i = m
FIN

TDOL : i, x, n, k — Entier — enregistrements remplis, candidat, paramètres retournés ; Triang, Pent — Fonction. Chaque fonction n’est appelée qu’une fois par candidat, et sa valeur sert à la fois de test (non nul) et de champ. Pour 40755 : 8x + 1 = 571², n = 285 ; 24x + 1 = 989², k = 165.

Relier ce raisonnement au bac

Choisis une filière pour voir les sujets qui étayent ce scénario.