Maison > Article > interface Web > Programme JavaScript pour calculer le nombre de rotations divisible par 8

Programme JavaScript pour calculer le nombre de rotations divisible par 8

PHPzavant: 2023-09-03 10:05:081261parcourir

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

Énoncé du problème - On nous donne un numéro. Nous devons faire pivoter ce nombre et trouver le nombre total de rotations divisible par 8.

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

Faites pivoter le numéro et vérifiez si la rotation est divisible par 8

La première méthode consiste à faire pivoter les nombres et à obtenir chaque rotation possible une par une. Vérifiez également si la rotation est divisible par 8. Si c'est le cas, ajoutez 1 au décompte.

Grammaire

Les utilisateurs peuvent suivre la syntaxe ci-dessous pour calculer le nombre de tours divisible par 8 par rotation des nombres.

for ( ) {
   str = lastDigit + str.substring(0, str.length - 1);
   let num = parseInt(str);
   if (num % 8 == 0) {
      count++;
   }
}

Dans la syntaxe ci-dessus, nous obtenons le dernier chiffre de la chaîne numérique et l'ajoutons au début de la chaîne pour faire pivoter le nombre.

Algorithme

Étape 1 - Initialisez la variable count à 0, ce qui signifie que le compte initial est zéro.
Étape 2 - Utilisez une boucle for pour parcourir la chaîne numérique et rendre la rotation totale égale à la longueur de la chaîne numérique.
Étape 3 - Dans la boucle for, récupérez le dernier chiffre de la chaîne numérique. Obtenez également la sous-chaîne contenant les n-1 premiers chiffres.
Étape 4 - Ajoutez le dernier chiffre au début de la sous-chaîne pour faire pivoter la chaîne numérique.
Étape 5 - Extrayez les nombres de la chaîne à l'aide de la méthode parseInt().
Étape 6 - Vérifiez si la rotation est divisible par 8. Si c'est le cas, augmentez le nombre de 1.
Étape 7 - Une fois que nous avons vérifié toutes les rotations à l'aide d'une boucle for, renvoyez la valeur du nombre.

Exemple 1

Dans l'exemple ci-dessous, la fonction rotationsDivisibleBy8() accepte un nombre comme argument et renvoie le nombre total de rotations divisible par 8. De plus, nous convertissons d'abord le nombre en chaîne à l'aide de la méthode toString(), puis implémentons l'algorithme ci-dessus pour calculer le nombre de rotations divisible par 8.

<html>
<body>
   <h3> Program to find the total number of rotations divisible by 8 </h3>
   <div id = "output"> </div>
   <script>
      let output = document.getElementById('output');
      const rotationsDivisibleBy8 = (number) => {
         let count = 0;
         //Count rotations divisible by 8 by rotating numbers
         let str = number.toString();
         for (let i = 0; i < str.length; i++) {
         
            //Get the last character of the string
            let lastDigit = str[str.length - 1];
            
            // rotating number
            str = lastDigit + str.substring(0, str.length - 1);
            
            // convert string to integer
            let num = parseInt(str);
            
            //Check if num is divisible by 8
            if (num % 8 == 0) {
               count++;
            }
         }
         return count;
      }
      let number = 90645232432;
      output.innerHTML = "Total count of rotations divisible by 8 of " + number + " is " + rotationsDivisibleBy8(number);
   </script>
</body>
</html>

Vérifiez si un nombre à trois chiffres est divisible par 8

Si les trois derniers chiffres d'un nombre sont divisibles par 8, on peut dire que le nombre entier est divisible par 8. Donc, ici, nous pouvons prendre une paire de trois nombres consécutifs et vérifier si la paire est divisible par 8. Si tel est le cas, cela signifie que la rotation contenant ce nombre à trois chiffres à la fin est divisible par 8.

Grammaire

Les utilisateurs peuvent suivre la syntaxe ci-dessous pour calculer le nombre de tours divisible par 8.

for ( ) {
   let pairOf3 = numStr.substring(i, i + 3);
   if (pairOf3 % 8 == 0) {
      count++;
   }
}

Dans la syntaxe ci-dessus, nous avons utilisé la méthode substring() pour obtenir la paire à trois chiffres.

Algorithme

Étape 1 - Convertissez le nombre en chaîne à l'aide de la méthode toString().
Étape 2 - Si la longueur du nombre est égale à 1, renvoyez 1 si le nombre est divisible par 8 sinon, renvoyez 0 ;
Étape 3 - Si la longueur du nombre est égale à 2, vérifiez le nombre de tours divisible par 8 parmi les tours possibles et retournez le décompte.
Étape 4 - Pour les nombres de plus de 3 chiffres, utilisez la méthode substring() et extrayez la paire de trois chiffres consécutifs. Après cela, vérifiez si la paire est divisible par 8 et incrémentez la valeur de comptage.
Étape 5 - Vérifiez également les paires contenant les deux derniers chiffres et le premier chiffre, le dernier chiffre et les deux premiers chiffres, et incrémentez la valeur de « Compte » en conséquence. p>

Exemple 2

Dans l'exemple ci-dessous, nous utilisons la méthode for loop et substring() pour obtenir n-2 paires de nombres à trois chiffres et vérifier s'il est divisible par 8. Dans le résultat, l'utilisateur peut observer que le nombre donné contient un total de 5 tours divisibles par 8.

<html>
<body>
   <h3> Program to find the total number of rotations divisible by 8 </h3>
   <div id = "output"> </div>
   <script>
      let output = document.getElementById('output');
      const rotationsDivisibleBy8 = (number) => {
         let count = 0;
         let numStr = number.toString();
         let n = numStr.length;
         if (n == 1) {
            // for 1 digit
            return number % 8 == 0 ? 1 : 0;
         }
         else if (n == 2) {
         
            // for 2 digits
            if (number % 8 == 0) {
               count++;
            }
            let temp = numStr.substring(1, 2) + numStr.substring(0, 1);
            if (temp % 8 == 0) {
               count++;
            }
            return count;
         }
         else {
         
            // for 3 digits
            for (let i = 0; i < n - 2; i++) {
               let pairOf3 = numStr.substring(i, i + 3);
               if (pairOf3 % 8 == 0) {
                  count++;
               }
            }
            
            // for last two and first digit
            let lastTwo = numStr.substring(n - 2, n);
            let firstDigit = numStr.substring(0, 1);
            let lastTwoFirstDigit = lastTwo + firstDigit;
            if (lastTwoFirstDigit % 8 == 0) {
               count++;
            }
            
            // for last digit and first two digits
            let lastDigit = numStr.substring(n - 1, n);
            let firstTwo = numStr.substring(0, 2);
            let lastDigitFirstTwo = lastDigit + firstTwo;
            if (lastDigitFirstTwo % 8 == 0) {
               count++;
            }
            return count;
         }
      }
      let number = 104104104104104;
      output.innerHTML = "Total count of rotations divisible by 8 of " + number + " is " + rotationsDivisibleBy8(number);
   </script>
</body>
</html>

L'utilisateur a appris deux manières différentes de calculer le nombre total de tours divisible par 8. Dans la première méthode, on prend toutes les rotations possibles et on vérifie si elle est divisible par 8. Dans la deuxième méthode, on utilise les propriétés d'un nombre qui le rendent divisible par 8, c'est-à-dire les trois derniers chiffres d'un nombre divisible par 8.

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!

JavaScript for 字符串循环算法

Déclaration：

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

Article précédent：Types d'événements en JavaScript : événements courants du clavier et de la sourisArticle suivant：Types d'événements en JavaScript : événements courants du clavier et de la souris

Articles Liés

Voir plus