说点js平易算数题

js算法题：

基础题

求三个数的大小，并按从小到大输出

    var min = Number(prompt('请输入三个值的第一个值：'))
    var center = Number(prompt('请输入三个值的第二个值：'))
    var max = Number(prompt('请输入三个值的第三个值：'))

    function sort() {
      // 定义三个变量来接收相应的值
      // 假设第一个值为最小值
      var min = arguments[0];
      var center;
      // 假设第一个值为最大值
      var max = arguments[0];

      // 这个循环是求得最小值 和 最大值
      for (var i = 0; i < arguments.length; i++) {
        if (min > arguments[i]) {
          min = arguments[i]
        }
        if (max < arguments[i]) {
          max = arguments[i]
        }
      }
      // 只要不是最小是也不是最大值 那么就是中间的值
      for (var j = 0; j < arguments.length; j++) {
        if (arguments[j] !== min && arguments[j] !== max) {
          center = arguments[j]
        }
      }

      // 把结果返回出去
      console.log(min, center, max); //打印输出台
      alert(min + "," + center + "," + max); //弹出框也可以输出
    }
    sort(min, center, max);

判断是否为质数

  /*
        - 编写一个函数，求一个数字是否是质数
        - 一个数字除了 1 和本以外，不能被别的数字整除，那么这个数字就是质数
        7 是一个质数 因为7 只能被 自己 和 1整除
        7 %  6 ！== 0
        7 %  5 ！== 0
        7 %  4 ！== 0
        7 %  3 ！== 0
        7 %  2 ！== 0

        12 不是质数 2--11

        11 求2-10之间有没有一个数能够被11整除，那么如果有就说明不是质数，没有就说明是质数
        n  求2--n-1之间有没有一个数能够被n整除
    */
    function zhishu(n) {
      // 定义一个标识去判断 是否是质数
      var flag = true;
      for (var i = 2; i < n; i++) {
        // 判断能够被 n整除的数，有被整除的数就执行if条件
        if (n % i === 0) {
          //  执行了if条件的代码就说明不是一个质数，跳出循环
          // 执行了这里就说明不是质数
          flag = false;
          break
        }
      }
      if (flag) {
        console.log(n + '是一个质数');
      } else {
        console.log(n + '不是一个质数');
      }
    }

    //这个循环可以 求100——200之间的质数
    for (var i = 100; i <= 200; i++) {
      zhishu(i);
    }

编写一个函数，计算任意两个数字之间所能组成的奇数个数，数字必须是个位数,
但是如11,33的数值需要去掉;
比如： 计算0-3之间能组成的奇数个是01、03、11、13、21、23、31、33
00 01 02 03
11 12 13

 function fun(a, b) {
      // 当你要拼接字符串的时候，那么这个位置必须给 ''
      var result = '';

      // q求最小值和最大值
      var min = a > b ? b : a;
      var max = a > b ? a : b
      for (var i = min; i <= max; i++) {
        for (var j = min; j <= max; j++) {
          // var res = '' + i + j; 用整数 去计算 到底是不是偶数
          // if (res % 2 !== 0 || i !== j) {

          // }

          // 用数的个位数去计算到底是不是偶数
          if (j % 2 !== 0 && i !== j) {
            // console.log('' + i + j)
            // 赋值运算的优先级最低 先把右边的表达式计算完成 然后进行 赋值运算
            result += '' + i + j + ','
          }
        }
      }
      return result;
    }
    console.log(fun(3, 6))

求叠数之和

• 如输入的是 n=3， a=2；则输出 2 + 22 + 222 的值。
• 如输入的是 n=4， a=3；输出 3 + 33 + 333 + 3333的值
  • n = 3,相加三次,每次相加比前一次相加的数,多一位
  • 每次多的这个位数的值为a, 如果a为2则 2 * 10 + 2 =22, 22 * 10+2 = 222

    var n = 4, a = 3;
    // 求2+22+222的和,n为多少，就要加多少个数
    var sum = 0;//用来存放计算的和

    for (var i = 1; i <= n; i++) {
        sum += a;
        a = a * 10 + a % 10; //a %10 = 2 得到每个数字的个位数
    }
    console.log(sum);
    
    /*
        a = a * 10 + 2; a + 2  2不能写死，当a变量的值不是2的时候，那么加的不是2
        i = 1   sum = sum + a = 0 +2 = 2  a = a*10 +2 = 22
        i = 2   sum = sum + a = 2 + 22    a = a*10 +2 =  222
        i = 3   sum =sum + a = 2 +22 +222  a = a*10 +2 =2220 + 2 = 2222

        a = a * 10 + a; 直接+a有问题，因为a一直在变化
        i = 1   sum = sum + a = 0 +2 = 2  a = a*10 + a = 22
        i = 2   sum = sum + a = 2 + 22    a = a*10 + a=  220 + 22 = 242
        i = 3   sum =sum + a = 2 +22 +222 a = a*10 + a =2220 + 2 = 2222
    */
  

阶乘题：求1 + 2！ + 3！ + 4！…+20!的值

        /*
          求1 + 2！ + 3！ + 4！....+20!的值
        */
        // var res1 = 1;
        // var res2 = 1;

        // for (var i = 1; i <= 1; i++) {
        //     res1 *= i; // 1
        //     //1
        // }
        // sum += res1;

        // for (var i = 1; i <= 2; i++) {
        //     res2 *= i; // res2 = 1 
        //     // 这句代码写在for循环里面，每执行一次循环就会 加一次
        //     // sum += res2
        // }
        // sum += res2

        var sum = 0; //定义一个变量来接收求和的值

        for (var j = 1; j <= 20; j++) {
            // 一定要重置 res的值为1，确保每一个阶乘的值都是正确
            var res = 1;
            // 这个循环是求得每一个数的阶乘
            for (var i = 1; i <= j; i++) {
                res *= i;
            }
            // 内层循环循环完之后，那阶乘的值相加
            sum += res;
        }
        console.log(sum);

回文数

• 要求：打印10000~99999区间的回文数字，形如12321 23432 34543等
  • 提示: 回文数需同时满足下面的条件
    [1] 第一位和倒数第一位相等
    [2] 第二位和倒数第二位相等
    [2] 第二位等于第一位数加一
    [3] 第三位等于第二位数加一

      for(var i = 10000;i <=99999;i++){
        var g = i % 10;
        var s = parseInt(i /10 % 10);
        var b = parseInt(i /100 % 10);
        var q = parseInt(i /1000 % 10);
        var w = parseInt(i / 10000);
        if(g === w && s === q && s === g+1 && b === s+1){
           document.write(i)
        }
    }
    

输入两个数，求两个数的最小公倍数

• 先取出两个数中最大的数
• 最大的数不断递增，提出能整除两个数的那个数，然后退出循环

  <input type="text" value="num1">
  <input type="text" value="num2">
  <button onclick="lcm()"> </button>
  
  function lcm(){
      //获取两个数的值
      var num1 = num1.value;
  	  var num2 = num2.value;
      
      //判断两个数中较小的值
      var max = num1 > num2 ? num1 : num2;
      for(var i = max;i >= 1;i++){
          if(i % num1 === 0 && i % num2 === 0){
              console.log(i + '就是' + num1 +'和' + num2 +'的最小公倍数')
          }
      }
  }
  

输入两个数求两个数的最大公约数

• 先取出两个数中最小的数
• 最小的数不断递减，取出能同时被两个数整除的数，并退出循环

  <input type="text" value="num1">
  <input type="text" value="num2">
  <button onclick="gcd()"> </button>
  
  function gcd(){
      //获取两个数的值
      var num1 = num1.value;
  	  var num2 = num2.value;
      
      //判断两个数中较小的值
      var min = num1 > num2 ? num2 : num1;
      
      //用最小的值 递减找出能被两个数整除的值
      for(var i = min; i >= 1;i--){
          if(num1 % i === 0 && num2 % i === 0){
              console.log(i + '就是' + num1 +'和'+ num2 + '的最大公约数')；
              break
          }
      }
  }

打印三角形

  *
  **
  ***
  ****
  *****
  ******
  *******
  ********
  *********
  
  for(var i = 0; i <=9 ;i++){
     for(var j = 1;j <= i;j++){
          document.write('*');
      }
      document.write('<br />')
  }
  

求出1-1/2 + 1/3 - 1/4 + 1/5… 1/100的和

  var sum = 0;
  for(var i = 1;i <= 100; i++){
      if(i % 2 === 0){
          sum -= 1/i;
      }else {
         sum += 1/i 
      }
  }
  console.log(sum)
  

斐波那契数列

1 1 2 3 5 8 13 21…
推导公式：fib(m) = fib(m-1) + fib(m-2)

 // 求 6 的斐波那契数列值 ，用函数返回
    function fib(n) {
      // 1 和 2 的斐波那契数列的值都为 1
      if (n === 1 || n === 2) {
        return 1
      }
      // 变量更新
      // var n1 = n - 1;
      // var n2 = n - 2;
      return fib(n - 1) + fib(n - 2)
    }
    console.log(fib(9));

数组题

求数组的偶数和五个一组并输出平均值，放在另一个数组中并输出。试编程

<script>
    // 定义一个含有30个整型元素的数组，按顺序分别赋予从2开始的偶数；
    // 然后按顺序每五个数求出一个平均值，放在另一个数组中并输出。试编程。

    // [1]定义一个长度为30 的数组
    var arr = new Array(30);

    // [2]循环给数组添加数据
    for (var i = 0; i < arr.length; i++) {
      // 设置数组的每一个数据
      arr[i] = (i + 1) * 2;
    }

    // [3] 创建一个新数组来存放平均值
    var arr1 = [];
    var sum = 0; //用来接收每5个数的和
    var index = 0; //定义一个 新数字的索引，默认从0开始

    // [4]循环 原始数组 计算平均值
    for (var j = 0; j < arr.length; j++) {
      sum += arr[j]
      // 第一次得到5个数的时候 j = 4 % 5 = 4
      // 第二次得到5个数的时候 j = 9 % 5 = 4
      // 第三次得到5个数的时候 j = 14 % 5 = 4 
      // (j + 1) % 5 === 0
      if (j % 5 === 4) {
        // 进入这个条件说明已经加够 5个数，需要求平均值 放入 新数组
        arr1[index] = sum / 5;
        // 已经得到5个数的平均值了，求下一次5个数之和之前一定情况sum
        sum = 0;
        // 索引+1
        index++
      }
    }

  </script>

求：通过循环按行顺序得到一个5×5的二维数组 赋值1到25的自然数，然后输出该数组的左下半三角。试编程。提示：多维数组，也就是数组里面的数据也是数组（二维数据），会涉及数据的存储区别

// 结果
[
  [1, 2, 3, 4, 5],
  [6, 7, 8, 9, 10],
  [11, 12, 13, 14, 15],
  [16, 17, 18, 19, 20],
  [21, 22, 23, 24, 25]
]

1
6  7
11 12 13
16 17 18 19
21 22 23 24 25

 // 
        var bigArr = [];
        var smallArr = [];
        for (var i = 1; i <= 25; i++) {
            smallArr.push(i);
            if (i % 5 == 0) {
                bigArr.push(smallArr);
                // 重新给 smallArr赋值一个空的地址
                smallArr = [];
            }
        }
        // console.log(bigArr[0][0]);
        // console.log(bigArr[1][0]);
        // console.log(bigArr[1][1]);

        // console.log(bigArr[2][0]);
        // console.log(bigArr[2][1]);
        // console.log(bigArr[2][2]);

        for (var i = 0; i < bigArr.length; i++) {
            // bigArr[i] 小数组
            // bigArr[0] 只打印一个数据 ，小数组中的第一个 内层循环只需要循环一次
            // bigArr[1] 要打印两个数据  内层循环两次

            // 内层循环取出二维数组中列的数据
            for (var j = 0; j <= i; j++) {
                document.write(bigArr[i][j]);
            }
            document.write('<br>')
        }

编写函数norepeat(arr) 将数组的重复元素去掉，并返回新的数组

 // 编写函数norepeat(arr) 将数组的重复元素去掉，并返回新的数组
    
    function noRepeat(array) {
      var newArr = [];

      // 去重 
      // 循环的把原始属数组的数据添加到新数组中
      outer: for (var i = 0; i < array.length; i++) {
        // 如果新数组中已经存在的数据，那么久不需要往新数组添加此数据
        // 用当前的这个数据与新数组中每一个元素比较
        for (var j = 0; j < newArr.length; j++) {
          if (array[i] === newArr[j]) {
            // 如果原始数组的数据 跟新数组的数据一样的 ，说明新数组已经存在这个数据了，就不需要往新数组添加此数据
            // 不需要往新数组中添加这条数据， 需要进行下一次与数据的匹配
            // 拿到原始数组的下一个数据  跳过外层循环的本次循环 进入下一次外层循环
            continue outer
          }
        }
        newArr.push(array[i])

      }

      return newArr
    }
    var arr = [1, 2, 3, 1, 67, 8, 9, 8, 3, 2, 1]
    var res = noRepeat(arr)

编写一个函数，传一个数组，在原始数组的基础上增加30% ，返回增加之后的新数组

 <script>
    // 编写一个函数，传一个数组，在原始数组的基础上增加30% ，返回增加之后的新数组
    // function map(array) {
    //     // vra array = arr;
    //     // 在原始数组中每一个数据增加30% 
    //     var newArr = [];
    //     for (var i = 0; i < array.length; i++) {
    //         newArr.push(array[i] * 1.3)
    //     }
    //     return newArr

    // }
    // var arr = [10, 20, 30, 40];
    // var res = map(arr);\\

    // 在原始数组的数据上 + 10 ，返回一个新数组
    function map(array, callback) {
      var newArr = [];
      for (var i = 0; i < array.length; i++) {
        // newArr.push(array[i] + 10)
        // 直接在函数内部写计算，函数不灵活，只能进行默认写好的计算
        // 给函数添加一个回调函数
        //  newArr.push(callback(array[i])) 把回调函数的返回值 push到新数组
        // callback(array[i]) 调用回调函数，并且把原始数组的数据当成回调函数的实参
        newArr.push(callback(array[i]))
      }
      return newArr

    }
    var arr = [10, 20, 30, 40];
    // 当在函数内部调用回调函数的时候 会执行
    // function (value) {
    //  return value * 1.3
    // }
    // value = 原始数组的每一个数据
    var res = map(arr, function (value) {
      // 拿到 原始数组的数据，进行相应的操作
      // 并且把操作的结果当成 回调函数的返回值
      return value * 1.3
    });
    var res1 = map(arr, function (value) {
      return value + 100
    })
  </script>
  

字符串题

统计字符串中每个字符的个数？以对象的形式返回

 <script>
    /*
        1.统计字符串中每个字符的个数？以对象的形式返回
     */
    var str = 'abcdacbabcbababcbabcabd';
    var obj = {}; //记录字符出现的次数
    for (var i = 0; i < str.length; i++) {
      // 判断对象中是否存在 
      if (str[i] in obj) {
        // 存在的情况 让这个属性的属性值 +1
        obj[str[i]] += 1
      } else {
        // 不存在的情况下，添加此属性，并且属性值为 1
        obj[str[i]] = 1;
      }
    }
    

字符串去重

  // 2.字符串去重
    var str1 = 'abcdacbabcbababcbabcabd'; //字符串去重
    var str2 = ''; //存放去重之后的字符串
    // 拿str1中的字符去 判断是否已经存在 str2中
    // 如果存在，是一个重复的字符，不需要把此字符添加到str2中
    // 如果不存在时候，需要把此字符添加到 str2 中
    for (var i = 0; i < str1.length; i++) {

      // 判断str2中是否存在str1[i]这个字符
      if (str2.indexOf(str1[i]) === -1) {
        str2 += str1[i]
      }
    }

寻找连续5位数中的最大数

 // 3.寻找连续5位数中的最大数
    var res = '9234567890';
    // 假设maxNum为一个最大值
    var maxNum = 0;
    for (var i = 0; i < res.length - 4; i++) {
      var num = res.substr(i, 5);
      // 组成的5位数为 字符串 ，当字符串的比较不会比较大小，而是比较他们ASCII码
      // 把字符串转换为数值 在进行比较

      // 如果num的值比maxNum的值大，把num的值赋值给maxNum
      if (maxNum < Number(num)) {
        maxNum = Number(num);
      }

    }
    console.log(maxNum)

随机生成一个五位以内的数，然后输出该数共有多少位，每位分别是什么。

  // 4.随机生成一个五位以内的数，然后输出该数共有多少位，每位分别是什么。
    var randomNum = parseInt(Math.random() * 10000); //得到一个5位以内的随机整数

    // 因为数值没有length属性，把数值转成字符串
    randomNum += '';
    console.log('该为' + randomNum + '是一个' + randomNum.length + '位数');

    for (var i = 0; i < randomNum.length; i++) {
      console.log('第' + (i + 1) + '为' + randomNum[i]);
    }

计算字符串中最长的字符串和长度

 // 计算最长字符串并输入长度和那个最长
    var s = 'I love you forever too';
    var arr = s.split(' ');
    // console.log(arr) //转为数组
    // console.log(arr[3])  //字符串
    var arr2 = [];
    for (var i = 0; i < arr.length; i++) {
      arr2.push(arr[i].length);
    }
    arr2 = arr2.sort(function (a, b) {
      return a - b
    });
    // console.log(arr2) // [1, 3, 3, 4, 7]
    // 得出最长的字符串的长度
    var maxLength = arr2[arr2.length - 1];
    for (var i = 0; i < arr.length; i++) {
      if (arr[i].length == maxLength) {
        console.log(arr[i]);  //forever
        console.log(arr[i].length); //7
      }
    }

以上看似简单，但是可能要动脑子啊，哈哈哈