Summary of common algorithms such as JS accumulation, iteration, exhaustion, and recursion

This time I will bring you a summary of the use of common algorithms such as JS accumulation, iteration, exhaustion, and recursion. What are the precautions for the use of common algorithms such as JS accumulation, iteration, exhaustion, and recursion, as follows. This is a practical case, let’s take a look at it.

Accumulation and accumulation

Accumulation: Add a series of data to a variable. The final cumulative result is obtained

For example: Calculate the cumulative sum of the numbers from 1 to 100

The ball falls from a height and returns to half of the original value each time. Find the tenth time the ball lands. The distance traveled by the ball in time

<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:Multiply a series of data into a variable to get the cumulative result.

The common one is the factorial of n

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

General form:

Accumulation: V =e;

Accumulation: v*=e;

V represents accumulation and accumulation, e represents accumulation/accumulation term

Key points of the algorithm:

(1) Initialization

Initialize v and e

Accumulation: v = 0;

Accumulation: v = 1;

e initialization, if the accumulation/product item is complex, it may be decomposed into several sub-items and initialized separately , such as the problem of calculating pi, the cumulative term is decomposed into three parts: symbol, numerator and denominator.

(2) Loop control conditions

One is a fixed number of times, such as the problem of calculating the bounce distance, the problem of calculating the sum of the first 20 items of the sequence,

number of times It is not fixed, but must meet a certain condition: the problem of calculating pi requires that the absolute value of the last term be less than 10-6.

(3) Determine the change of the accumulation/product term

For example, the sum of the first 20 terms of a sequence is to use the sum of the current numerator and denominator as the next denominator, and the current denominator as the numerator .

Another example is the problem of finding pi, which is to invert the sign, add 2 to the denominator, and then find the next term.

Iteration

The iteration method is also the rolling method

Rule: it can be used continuously The old value gets the new value until we get the result we want.

How to solve the problem of iteration

1. Find the iteration variable (old value)

2. Determine the relationship between iteration

3. Knowing what the desired result is (conditions for ending the loop)

(1) is to know the final result

(2) The number of loops

<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>

Recursion

Find the mathematical rule: calculate the value of the next item through the formula until the result we want

For example: a rabbit gives birth: through the first two The item gets the next item

<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>

Recursion is divided into forward push and reverse push.

Exhaustion

When you encounter a problem and can’t find a better solution (can’t find a mathematical formula or rule) , use the "stupidest" method, take advantage of the fast computing speed of computers, list all possibilities

and record the results we want

<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>

Exhaustive method Its characteristics are: the algorithm is simple and the corresponding program is also simple, but the amount of calculation is often large. However, the advantage of computers is their fast computing speed, so this algorithm can maximize its strengths and avoid weaknesses, and can often achieve good results.

Case: There is a three-digit number, the ones digit is larger than the hundreds digit, and the hundreds digit is larger than the tens digit, and the sum of the digits is equal to the product of the multiplication of the digits, find these three Number of digits

Recursion

The so-called recursion is to call yourself again inside the function.

For example, to find the factorial problem, the fact function is called inside the fact function

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

The recursive algorithm is very complicated to understand according to the conventional thinking, and the function calls are nested layer by layer. Call, and then return layer by layer, you might as well change your mind to understand recursion.

Recursion is actually solving a problem of size n by reducing it to a problem of n-1. That is to find the relationship between n and n-1.

I believe you have mastered the method after reading the case in this article. For more exciting information, please pay attention to other related articles on the php Chinese website!

Recommended reading:

Summary of common JS algorithm examples

##Detailed explanation of JavaScript callback function use cases

The above is the detailed content of Summary of common algorithms such as JS accumulation, iteration, exhaustion, and recursion. For more information, please follow other related articles on the PHP Chinese website!