Le programme JavaScript vérifie si tous les éléments du tableau peuvent être convertis en nombres proniques en faisant tourner les nombres

Les nombres ploniques sont également appelés nombres rectangulaires. Les nombres ploniques sont des multiples de deux nombres consécutifs. Nous obtiendrons un tableau d’entiers et nous pourrons faire pivoter les nombres dans n’importe quelle direction un certain nombre de fois pour obtenir toutes les combinaisons. Pour toute combinaison produite par rotation de nombres, si chaque élément du tableau peut être converti en un nombre de Plonik, alors nous imprimerons vrai, sinon nous imprimerons faux.

Numéros proniques

Tout d’abord, parlons du nombre de protons : le nombre de protons est le produit de deux nombres consécutifs.

Mathématiquement parlant, si nous avons un entier x dont le prochain nombre consécutif est x+1, et que le nombre k soit le produit des deux, cela signifie : k = (x)*(x+1). Voici quelques exemples de numéros Pronic :

• 0 est le produit de 0 et 1.

• 1 est le produit de 1 et 2.

• 6 est le produit de 2 et 3.

-> 12, 20, 30, 42, 56, 72, 90, 110, 132, 156, 182, 210, 240, 272, etc.

Exemple

Supposons que nous ayons un tableau :

{21, 65, 227, 204, 2}

Sortie : Oui

Description :

Pour l'indice zéro : 21, une rotation se transforme en 12, qui est le produit de 3 et 4, d'où un nombre de Planck.

Pour le premier indice : 65, après une rotation il peut être converti en 56, qui est le produit de 7 et 8 et donc un nombre de Plonic.

Pour le deuxième indice : 227, il peut être converti en 272 après une rotation, qui est un nombre pronique.

De même, 204 à 420 et 2 lui-même est un nombre de protons.

Méthode

Nous avons vu l'exemple de code, passons maintenant aux étapes -

• Tout d'abord, nous allons définir une fonction pour faire pivoter un nombre donné. Un entier sera passé en argument et sera converti en chaîne.

• En utilisant la méthode de sous-chaîne, nous faisons pivoter la chaîne vers la droite, puis la reconvertissons encore et encore en nombre.

• Nous définirons la fonction pronique pour vérifier si le numéro actuel est pronique.

• Nous trouverons la limite inférieure de la racine carrée du nombre actuel et la multiplierons par ses nombres consécutifs pour déterminer si le nombre actuel est un proton.

• Nous définirons une fonction pour trouver le nombre de chiffres du nombre actuel en le convertissant en chaîne.

• Dans la fonction principale, nous allons parcourir le tableau et pour chaque élément, nous le ferons pivoter de sa longueur ou jusqu'à ce que nous trouvions le nombre Pronic.

• Si nous trouvons un nombre qui n'est pas un nombre pronique après toutes les itérations et que nous ne pouvons pas le convertir en nombre pronique, alors nous n'imprimerons pas oui.

Exemple

Dans l'exemple ci-dessous, nous vérifions si tous les éléments du tableau peuvent être convertis en nombres Plonik en faisant pivoter les nombres. L’entrée et la sortie attendue sont indiquées ci-dessous.

Entrée : tableau = [21, 65, 227, 204, 2]

Résultat attendu : Oui

// function to rotate the digits
function rotate(num){

   // converting integer to string
   var str = num.toString();
   
   // putting first index value to last
   str = str.substring(1) + str.substring(0,1);
   
   // converting back string to integer
   num = parseInt(str);
   return num;
}

// function to check whether current number if pronic number or not
function isPronic(num){

   // getting square root of the current number
   var cur = Math.sqrt(num);
   
   // taking floor of cur
   cur = Math.floor(cur);
   if(cur*(cur+1) == num) {
      return true;
   }
   else {
      return false;
   }
}

// function to find the length of the current integer
function number_length(num){
   var str = num.toString()
   var len = str.length;
   return len;
}

// function to check whether array is pronic or not
function check(arr){
   var len = arr.length;
   for(var i =0; i<len; i++){
      // getting length of the current number
      var cur = number_length(arr[i]);
      while(cur--){
         if(isPronic(arr[i])){
            break;
         }
         arr[i] = rotate(arr[i]);
      }
      if(isPronic(arr[i]) == false){
         return false;
      }
   }
   return true;
}
var arr = [21, 65, 227, 204, 2]
console.log("Array:", JSON.stringify(arr))
if(check(arr)){
   console.log("The elements of array can be converted to pronic numbers.");
}
else{
   console.log("The elements of array can't be converted to pronic numbers.");
}

Sortie

Array: [21,65,227,204,2]
The elements of array can be converted to pronic numbers.

Complexité temporelle et spatiale

La complexité temporelle du code ci-dessus est O(N), où N est la taille du tableau. Ici, nous obtenons un facteur logarithmique supplémentaire de taille numérique pour parcourir le tableau et prendre sa racine carrée, mais comme la longueur maximale d'un entier donné est très petite, il n'y a aucun impact sur la complexité temporelle linéaire.

La complexité spatiale du code ci-dessus est constante ou O(1) puisque nous n'utilisons aucun espace supplémentaire ici.

Conclusion

Dans ce tutoriel, nous avons implémenté un programme JavaScript pour trouver la météo en convertissant chaque élément du tableau en un nombre pronique simplement en faisant pivoter son numéro vers la gauche ou la droite. Nous avons défini certaines fonctions pour faire pivoter les nombres, vérifier s'il s'agit de protons et obtenir le nombre de chiffres. La complexité temporelle du code ci-dessus est O(N) et la complexité spatiale est O(1).

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!