while

Croissance de la factorielle.

Soit n un entier positif.
On appelle factorielle n (et on note n!) l'entier égal au produit des entiers de 1 à n.

Exemple : 5! = 1 × 2 × 3 × 4 × 5. On donc 5! = 120.

Écrire un programme qui détermine et affiche le plus petit entier n tel n! > B, B étant un entier paramètre indiqué dans le texte du programme.

<!DOCTYPE html>
<html lang="fr">
    <head>
        <meta charset="utf-8">
        <title> n! > B </title>
    </head>
    <body>
        <script>
        let B = 10000; // borne à dépasser
        let i = 0; // contiendra les entiers successifs
        let f = 1; // contiendra i! 
        while( f <= B ) {
            i += 1;
            f = f*i;
        }
        document.write(`${i-1}! = ${f/i} <br>`);
        document.write(`${i}! = ${f} <br>`);
        document.write(`L'entier cherché est donc ${i}.`);
        </script>
    </body>
</html>

Substitution à répétition.

Question 1.

Étudier le rôle de la méthode replace (méthode qui s'applique à un string) en testant le programme suivant.

<!DOCTYPE html>
<html lang="fr">
    <head>
        <meta charset="utf-8">
        <title> replace() </title>
    </head>
    <body>
        <script>
        let ch = 'message';  
        let nvch = ch.replace('e', 'a');
        document.write( nvch );
        document.write( '<br>' );
        
        let nvch2 = ch.replace(/e/g, 'a');
        document.write( nvch2 );
        document.write( '<br>' );
        
        let nvch3 = ch.replace('ess', 'u');
        document.write( nvch3 );
        </script>
    </body>
</html>

Vous pouvez aussi voir et tester un exemple sur w3schools.

Question 2

Le rôle de cette méthode étant comprise, écrire un programme dans lequel on aura une chaîne de départ chDepart, une chaîne à remplacer chARemplacer et une chaîne de remplacement chRemplacement.

Ce script remplacera dans chDepart tous les chARemplacer par chRemplacement.

Attention, si chDepart='baaac', chARemplacer='ba' et chRemplacement='b' alors le résultat attendu n'est pas 'baac' puisque chARemplacer est encore présent. L'opération de substitution doit donc être à nouveau réalisée. Les étapes seraient ici 'baaac, 'baac' (le 'ba' du début a été remplacé par b), puis 'baac', puis 'bac' et enfin le résultat : 'bc'.

Question 1

nvch = ch.replace('e', 'a'); ne remplace que la première occurence de la lettre 'e' par 'a'.

Dans la version, nvch2 = ch.replace(/e/g, 'a');, toutes les lettres 'e' sont remplacées par 'a'.

Dans nvch3 = ch.replace('ess', 'u');, la première occurence de la chaîne "ess" est remplacée par "u".

Question 2

<!DOCTYPE html>
<html lang="fr">
    <head>
        <meta charset="utf-8">
        <title> replace() </title>
    </head>
    <body>
        <script>
        let chDepart = 'baaaac';  
        let chARemplacer = 'ba';
        let chRemplacement = 'b';
        let chModifie;
        
        let modification = true; 
        
        while( modification ) {
            chModifie = chDepart.replace( chARemplacer, chRemplacement);
            /* si chModifie est différent de chDepart, il y a eu modification 
            et il y a peut-être encore des chaînes à remplacer :
            modification se voit affecter la valeur true. 
            Si chModifie est identique à chDepart, il n'y a pas eu de modification:
            modification se voit affecter la valeur false 
            et la boucle stoppera. */ 
            modification = ( chModifie !== chDepart);
            // chDepart prend maintenant la valeur chModifie pour le tour de boucle suivant :
            chDepart = chModifie;
        }
        document.write("Résultat : " + chDepart);
        </script>
    </body>
</html>

blog.

Soit x ≥ 1 un nombre réel. On appellera blog(x) le plus petit entier n tel que x ≤ 2ⁿ.

Par exemple, blog(17)= 5. En effet x > 2⁴ et x ≤ 2⁵ car \( 2^4 = 16 \) et \( 2^5 = 32 \). Le plus petit entier n tel que \( 2^n \) dépasse x = 17 est donc l'entier n = 5.

Écrire un script qui pour un nombre flottant x ≥ 1 donne en sortie blog(x).

<!DOCTYPE html>
<html lang="fr">
    <head>
        <meta charset="utf-8">
        <title> replace() </title>
    </head>
    <body>
        <script>
        let x = 17;  
        let n = 0;
          
        while( x > 1 ) {
            x = x/2;
            n += 1; 
        }
        document.write("Résultat : " + n);
        </script>
    </body>
</html>

PGCD.

Pour déterminer le pgcd de deux entiers naturels a et b, on utilise les propriétés suivantes :

pgcd(a,0) = a
pgcd(a,b) = pgcd(b,r) où r est le reste de la division euclidienne de a par b.

Lorsqu'on remplace pgcd(a,b) par pgcd(b,r), on remplace l'élément b par un élément strictement plus petit (et ≥ 0). En réitérant le procédé, on finit par arriver à une valeur de r égale à 0. La dernière valeur de r non nulle (qui peut éventuellement être b lui-même dans certains cas) est alors le pgcd de a et b.

En d'autres termes, le calcul du pgcd revient à remplacer le couple (a, b) par le couple (b,r) successivement jusqu'à ce que r soit nul puis à appliquer la règle 1 citée ci-dessus (c'est ce que l'on appelle habituellement l'algorithme d'Euclide).

Écrire un script qui détermine le pgcd de deux entiers naturels a et b.

Algorithme d'Euclide.

<!DOCTYPE html>
<html lang="fr">
    <head>
        <meta charset="utf-8">
        <title> pgcd </title>
    </head>
    <body>
        <script>
        let a = 17;  
        let b = 5;
        
        /* les deux valeurs A et B suivantes sont là pour conserver les
        valeurs a et b initiales pour l'affichage final. */
        let A = a;
        let B = b; 
        let auxiliaire;
        
        while( b !== 0 ) {
            auxiliaire = a;
            a = b;
            b = auxiliaire % b; // reste dans la division entière de auxiliaire par b
        }
        document.write(`pgcd(${A} ; ${B}) = ${a}.`);
        </script>
    </body>
</html>

Pour éviter la variable auxiliaire:

<!DOCTYPE html>
<html lang="fr">
    <head>
        <meta charset="utf-8">
        <title> pgcd </title>
    </head>
    <body>
        <script>
        let a = 17;  
        let b = 5;
        
        /* les deux valeurs A et B suivantes sont là pour conserver les
        valeurs a et b initiales pour l'affichage final. */
        let A = a;
        let B = b; 
         
        
        while( b !== 0 ) {
			[a, b] = [b, a%b];
        }
        document.write(`pgcd(${A} ; ${B}) = ${a}.`);
        </script>
    </body>
</html>

La suite de Robinson.

Écrire un script :

générant au hasard un tableau A de chiffres (entiers entre 0 et 9).
A partir de ce tableau, le programme générera un second tableau B d'entiers naturels sur le modèle des exemples suivants :
- Avec A = [2,2, 3, 1, 3, 4,4], B sera : [2,2,1,3,1,1,1,3,2,4]. Cela correspond à une lecture du tableau A : deux 2, un 3, un 1, un 3, deux 4.
- Avec A = [9,9,9,1,2,2,2,5], B sera : [3,9,1,1,3,2,1,5].

<!DOCTYPE html>
<html lang="fr">
    <head>
        <meta charset="utf-8">
        <title> Robinson </title>
    </head>
    <body>
    
        <script>
        // on définit un tableau vide  :  
        let A = [];
        // on tire au hasard la longueur du tableau entre 5 et 20 :
        let longueur = Math.floor(Math.random() * 16) + 5;
        
        for(let i = 0; i < longueur; i += 1) {
        	// ajout d'un entier pris au hasard entre 0 et 9 : 
        	A.push( Math.floor(Math.random() * 10 )  );
        }
        
        document.write(`Le tableau A : ${A} <br><br>`);
        
        
        let B = [];
        let i = 0;
        let compteur = 1;
        
        while (i < A.length) {
        
		    while ( A[i] === A[i+1] ) {
		    	compteur += 1;
		    	i += 1;
		    }
		    B.push(compteur); 
		    B.push(A[i]);
		    i += 1; compteur = 1;
        }
        
        document.write(`Le tableau B : ${B}.`);
        
         
        </script>
    </body>
</html>

Pour comprendre le titre donné à l'exercice, on pourra par exemple lire cette page.