Maison >interface Web >js tutoriel >Programme JavaScript pour calculer le nombre de tours divisible par 4

Programme JavaScript pour calculer le nombre de tours divisible par 4

WBOYavant: 2023-08-25 18:09:02746parcourir

JavaScript 程序计算可被 4 整除的旋转次数

Dans ce tutoriel, nous apprendrons à calculer le nombre total de tours d'un nombre donné divisible par 4.

Énoncé du problème - On nous donne une valeur numérique. Nous devons faire pivoter le nombre dans le sens des aiguilles d’une montre ou dans le sens inverse et compter le nombre total de rotations divisibles par 4.

Ici, nous allons apprendre deux manières différentes de calculer le nombre de tours divisible par 4.

Faites pivoter le nombre et vérifiez s'il est divisible par 4

Dans cette méthode, nous convertissons d'abord le nombre en chaîne. On peut effectuer n rotations sur une chaîne de longueur n. Nous allons supprimer le premier caractère de la chaîne et l'ajouter au dernier caractère de la chaîne. Ensuite, on peut vérifier si le nouveau nombre généré par la rotation est divisible par 4.

Grammaire

Les utilisateurs peuvent suivre la syntaxe suivante pour vérifier si la rotation est divisible par 4 et faire pivoter la chaîne numérique.

for ( ) {
   if (parseInt(numStr) % 4 == 0) {
      count++;
   }
   numStr = numStr.substring(1, len) + numStr[0];
}

Dans la syntaxe ci-dessus, la méthode parseInt() est utilisée pour convertir la chaîne en nombre et la méthode substring() est utilisée pour faire pivoter la chaîne.

Algorithme

Étape 1 - Utilisez la méthode toString() et convertissez le nombre en chaîne.
Étape 2 - Utilisez une boucle for pour effectuer un total de "n" rotations sur une chaîne de longueur "n".
Étape 3 - Convertissez la chaîne en nombre à l'aide de la méthode parseInt() et vérifiez si le nombre est divisible par 4. Si le nombre est divisible par 4, la variable count est incrémentée et décrémentée de 1.
Étape 4 - Obtenez la sous-chaîne du premier index en utilisant la méthode substring(). De plus, le premier caractère de la chaîne est ajouté à la fin de la sous-chaîne. De cette façon, nous pouvons faire pivoter la chaîne et générer un nouveau nombre.

Exemple 1

Dans l'exemple ci-dessous, nous définissons la fonction countRotations(), qui implémente l'algorithme ci-dessus et renvoie le nombre total de rotations divisible par 4. Dans le résultat, l'utilisateur peut observer que le nombre total de tours pour ce nombre est divisible par 4.

<html>
<body>
   <h3> Program to find the total number of rotations divisible by 4 </h3>
   <div id = "output"> </div>
   <script>
      let output = document.getElementById('output');
      // JavaScript program to find the total count of rotations divisible by 4
      let countRotations = (number) => {
         let numStr = number.toString();
         let len = numStr.length;
         let count = 0;
         
         // Loop to traverse the string
         for (let i = 0; i < len; i++) {
         
            // Check if the string is divisible by 4
            if (parseInt(numStr) % 4 == 0) {
               count++;
            }
            
            // Rotate the string
            numStr = numStr.substring(1, len) + numStr[0];
         }
         return count;
      }
      let number = 121342435345;
      output.innerHTML = "Total count of rotations divisible by 4 of " + number + " is " + countRotations(number);
   </script>
</body>
</html>

Vérifiez si chaque paire de nombres à 2 chiffres est divisible par 4

Si les 2 derniers chiffres d'un nombre sont divisibles par 4, on peut dire que ce nombre est divisible par 4. Lors de la rotation des nombres, chaque paire de deux chiffres apparaît à la fin du nombre. Par conséquent, nous pouvons vérifier si une paire de deux nombres est divisible par 4 ; nous pouvons dire qu’une rotation associée à cette paire est divisible par 4.

Grammaire

Les utilisateurs peuvent suivre la syntaxe ci-dessous pour extraire une paire de nombres à deux chiffres d'un nombre et vérifier s'il est divisible par 4.

let lastDigit = num % 10;
num = Math.floor(num / 10);
let secondLastDigit = num % 10;
if ((secondLastDigit * 10 + lastDigit) % 4 == 0) {
   count++;
}

Dans la syntaxe ci-dessus, nous obtenons le dernier et l'avant-dernier chiffre du nombre. Après cela, nous créons un nombre à deux chiffres en utilisant les deux et vérifions s'il est divisible par 4. Si tel est le cas, nous incrémentons la variable count.

Algorithme

Étape 1 - Si le nombre est à un chiffre, vérifiez s'il est divisible par 4. Renvoie 1 si oui ; sinon, renvoie 1. Sinon, renvoie 0.
Étape 2 - Si le nombre contient deux chiffres ou plus, initialisez la variable "count" à 0.
Étape 3 - Maintenant, nous devons créer une paire en utilisant le dernier chiffre et le premier chiffre du nombre. Utilisez l'opérateur modulo pour obtenir le dernier chiffre et la méthode Math.log() pour obtenir le premier chiffre.
Étape 4 - Multipliez le dernier chiffre par 10 puis multipliez le premier chiffre par 10. Vérifiez ensuite si le résultat est divisible par 4. S'il est divisible par 4, ajoutez 1 au décompte.
Étape 5 - Utilisez une boucle while pour vérifier les deux autres paires de nombres. Dans la boucle while, utilisez l'opérateur modulo pour obtenir le dernier et l'avant-dernier nombre. Créez une paire en utilisant deux nombres et vérifiez si la paire est divisible par 2. Si c'est le cas, augmentez le nombre de 1.

Exemple 2

Dans cet exemple, la fonction countRotations() compte le nombre de paires à deux chiffres divisibles par 4. Il implémente l'algorithme ci-dessus et renvoie une valeur de comptage une fois toutes les opérations terminées.

<html>
<body>
   <h3> Program to find the total number of rotations divisible by 4 </h3>
   <div id = "output"> </div>
   <script>
      let output = document.getElementById('output');
      function countRotations(number) {
         //If the length of the number is equal to 1, check if the digit is a multiple of 4
         if (number < 10) {
            return number % 4 == 0 ? 1 : 0;
         } else {
            // Initialize count of rotations divisible by 4
            let count = 0;
            let num = number;
            //Check for the last digit and the first digit
            let lastDigit = number % 10;
            // Get the first digit from the number
            let firstDigit = Math.floor(number / Math.pow(10, Math.floor(Math.log10(number))));
            //If the last digit and first digit are divisible by 4, then add 1 to count
            if ((lastDigit * 10 + firstDigit) % 4 == 0) {
               count++;
            }
            while (num > 0) {
               // get last digit of number
               let lastDigit = num % 10;
               // get second last digit of number
               num = Math.floor(num / 10);
               let secondLastDigit = num % 10;
               if ((secondLastDigit * 10 + lastDigit) % 4 == 0) {
                  count++;
               }
            }
            return count;
         }
      }
      let number = 90645232432;
      output.innerHTML = "Total count of rotations divisible by 4 of " + number + " is " + countRotations(number);
   </script>
</body>
</html>

L'utilisateur a appris à trouver le nombre total de tours pour un nombre divisible par 4. Nous voyons deux approches différentes. La première méthode convertit le nombre en chaîne, fait pivoter la chaîne, reconvertit à nouveau la chaîne en nombre et vérifie si la rotation nouvellement générée est divisible par 4.

La deuxième méthode compte le nombre total de paires à deux chiffres divisibles par 4.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!

Déclaration：

Cet article est reproduit dans:. en cas de violation, veuillez contacter admin@php.cn Supprimer

Article précédent：Comment appliquer une fonction à chaque clé d'un accumulateur et d'un objet en JavaScript ?Article suivant：Comment appliquer une fonction à chaque clé d'un accumulateur et d'un objet en JavaScript ?

Articles Liés

Voir plus