Résumé des exemples d'algorithmes JS courants

Cette fois, je vais vous présenter un résumé des exemples d'algorithmes JS courants. Quelles sont les précautions lors de l'utilisation des algorithmes courants JS. Voici des cas pratiques, jetons un coup d'œil.

Accumuler et accumuler

Accumuler : Ajouter une série de données à une variable. Finalement, le résultat cumulé est obtenu

Par exemple : Trouver la somme cumulée des nombres de 1 à 100

La balle tombe de haut et revient à chaque fois à la moitié de la valeur d'origine . Trouvez la dixième fois que la balle atterrit. La distance parcourue par la balle dans le temps

<script>
 var h=100;
 var s=0;
 for(var i=0;i<10;i++){
  h=h/2;
  s+=h;
 }
 s=s*2+100;
</script>

Accumulation : Multipliez une série de données dans une variable pour obtenir le résultat cumulé.

La commune est la factorielle de n

var n=100;
var result= 1;
for(var i=1;i<=n;i++){
 result *=i;
}

Forme générale :

Accumulation : V +=e;

Accumulation : v*= e;

V représente l'accumulation et l'accumulation, e représente le terme d'accumulation/accumulation

Points d'algorithme :

(1) Initialisation

Initialisation v et e

accumulation : v = 0 ;

accumulation : v = 1

e initialisation, si le terme accumulation/produit est plus complexe, cela peut être décomposé en plusieurs Les sous-termes sont initialisés séparément. Par exemple, dans le problème du calcul de pi, le terme cumulé est décomposé en trois parties : symbole, numérateur et dénominateur.

(2) Conditions de contrôle de boucle

L'une est un nombre fixe de fois, comme le problème du calcul de la distance de rebond, le problème du calcul de la somme des 20 premiers éléments de la séquence ,

fois Il n'est pas fixe, mais doit remplir une certaine condition : le problème du calcul de pi nécessite que la valeur absolue du dernier terme soit inférieure à 10-6.

(3) Déterminer le changement du terme d'accumulation/produit

Par exemple, la somme des 20 premiers termes d'une séquence consiste à utiliser la somme du numérateur et du dénominateur actuels comme prochain dénominateur et le dénominateur actuel comme numérateur.

Un autre exemple consiste à trouver la circonférence de pi. Inversez le signe, ajoutez 2 au dénominateur, puis trouvez le terme suivant.

Itération

La méthode d'itération est aussi la méthode de lancer

Règle : ça peut être utilisé en continu L'ancienne valeur obtient la nouvelle valeur jusqu'à ce que nous obtenions le résultat souhaité.

Comment résoudre le problème d'itération

1. Trouver la variable d'itération (ancienne valeur)

2. Déterminer la relation entre les itérations

3. quel est le résultat souhaité (conditions de fin de boucle)

(1) c'est connaître le résultat final

(2) Le nombre de boucles

<script>
 /*
 * 1.接受用户输入的俩个数
 * 2.一个函数的到最大公约数
 * 3.打印这个最大公约数*/
 var num1 = Number(prompt("请输入一个数"));
 var num2 = Number(prompt("请输入一个数"));
 var result = GCD(num1,num2);
 alert(result);
 /*
 * 函数的功能：得到最大公约数
 * 函数名：GCD
 * 函数的参数：俩个整数
 * 返回值：最大公约数*/
 /*
 * 如果num1<num2则交换，确保num1是交大的
 * 计算余数
 * 当num1（除数），对num2（被除数）的余数不为0，重复一下步骤
 * num2=>num1,
 * 余数=>num2
 * 重新计算余数
 * 最终的到最大公约数，也就是num2的值*/
 function GCD(num1,num2){
  /*return0;*/
  if(num1<num2){
   var t = num1;
   num1=num2;
   num2 = t;
  }
  var remainder = num1%num2;
  while(remainder!= 0){
   num1=num2;
   num2= remainder;
   remainder=num1%num2;
  }
  returnnum2;
 }
</script>

Récursion

Trouver des règles mathématiques : Calculer la valeur de l'élément suivant à travers la formule jusqu'au résultat souhaité

Par exemple : un lapin accouche : through Les deux premiers éléments obtiennent l'élément suivant

<script>
 /*
 * 一般而言，兔子在出生俩个月后，就有繁殖能力
 * 一对兔子每个月能生出一对小兔子来
 * 如果所有的兔子都不死，那么一年以后总共有多少对兔子*/
 /*
 * 月份 0 1 2 3 4 5 6
 * 幼崽 1 1 1 2 3 5 8
 * 成年 0 0 1 1 2 3 5
 * 总共 1 1 2 3 5 8 13
 * */
 /*
 * 接收用户输入的月份
 * 计算兔子的对数
 * （1）如果经过的月份<2那么兔子的对数为1
 * （2）否则用初始的兔子的对数 加上 第一个月的对数为
 * 第二个月兔子的个数（an = an-1 +an-2）
 * 反复使用这个公式，计算出下个月兔子的个数一直到用户输入的月份为止
 * 打印的兔子的对数
 * */
 /* var month = Number(prompt("输入月份"));
  var sum ;
  var an =1;
  var an_1=1;
  var an_2;
  if(month < 2){
  sum=1;
  }else{
  sum=2;
  for(var i=1; i<month; i++){
  sum= an +an_1;
  an_1 =an;
  an = sum;
  }
  }
  alert(sum);*/
 /*
 * 思路2*/
 var month = Number(prompt("输入月份"));
 var rabbit = [1,1];
 for(var m=2;m<=month;m++){
  rabbit[m]=rabbit[m-1]+rabbit[m-2];
 }
 alert(rabbit[month]);
</script>

La récursion est divisée en avant et arrière.

Épuisement

Lorsque vous rencontrez un problème et que vous ne trouvez pas de meilleure solution (impossible de trouver une formule ou une règle mathématique), utiliser la méthode la plus "stupide", profiter de la vitesse de calcul rapide des ordinateurs, lister toutes les possibilités

et enregistrer les résultats que nous souhaitons obtenir

<script>
 /*
 * 公鸡一值钱5，鸡母一值钱三，鸡仔三值钱一
 * 百钱买百鸡，问公鸡，鸡母、鸡仔各几何？
 * x y z
 * x + y + z = 100
 * x*5 + y * 3 + z/3 = 100*/
 for(var cock=0;cock<=20;cock++){
  for(var hen=0;hen<=33;hen++){
   var chihen=100-cock-hen;
   if(100== cock*5+ hen*3+ chihen/3){
    document.write("公鸡一共："+cock+"鸡母一共："+hen+"小鸡一共："+chihen+"<br>")
   }
  }
 }
</script>

Mauvais Les caractéristiques de la méthode de levage sont : l'algorithme est simple et le programme correspondant est également simple, mais le montant du calcul est souvent important. Cependant, l'avantage des ordinateurs est leur vitesse de calcul rapide, de sorte que cet algorithme peut maximiser ses points forts et éviter ses faiblesses, et peut souvent obtenir de bons résultats.

Cas : Il existe un nombre à trois chiffres, le chiffre des unités est plus grand que le chiffre des centaines, et le chiffre des centaines est plus grand que le chiffre des dizaines, et la somme des chiffres est égale au produit du multiplication des chiffres, trouvez ces trois chiffres

Récursion

La soi-disant récursivité consiste à s'appeler à l'intérieur de la fonction.

Par exemple, pour trouver le problème factoriel, la fonction de fait est appelée à l'intérieur de la fonction de fait

<script>
 /*计算n的阶乘*/
 function fact(n){
  if(1== n){
   return 1
  }
   return n*fact(n-1);
 }
 alert(fact(5));
</script>

L'algorithme récursif est très compliqué à comprendre selon les idées conventionnelles, avec une couche d'appels de fonctions par couche, puis en revenant couche par couche, autant changer votre façon de penser pour comprendre la récursivité.

La récursion consiste en fait à résoudre un problème de taille n en le réduisant à un problème de n-1. Il s’agit de trouver la relation entre n et n-1.

Je pense que vous maîtrisez la méthode après avoir lu le cas dans cet article. Pour des informations plus intéressantes, veuillez prêter attention aux autres articles connexes sur le site Web chinois de php !

Lecture recommandée :

Vérification du formulaire VeeValidate, analyse du code de cas d'utilisation dans le projet Vue

Vue utilise vee-validate Explication détaillée des étapes du formulaire de vérification

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!