【学习笔记28】JavaScript数组字符串面试题

笔记首发

一、有10个学生的成绩存在数组中, 请统计大于等于平均成绩的人数

1、方法一

       const arr = [50, 69, 70, 56, 77, 67, 70, 78, 67, 59];

        // 定义变量 存储数据
        let count = 0;
        let sum = 0;
        let avg = 0;

        arr.forEach(function (item) {
            sum += item;

            // 再循环最后一轮的时候，会计算出数组的实际平均值
            avg = sum / 10
        })

        console.log(avg);   //平均值

        arr.forEach(function (item) {

            // 统计大于等于平均成绩的人数
            if (item > avg) {
                count++
            }
        })
        console.log(count); //统计的人数

2、方法二

        const arr = [50, 69, 70, 56, 77, 67, 70, 78, 67, 59];

        // 1.1 计算平均值
        let num = arr.reduce(function (prev, item) { 
            // 求和   
            return prev + item;
        })
        // 求平均值
        num = num / arr.length;  
        console.log(`平均值：${num}`);

        // 1.2找到符合条件的人数
        // 定义变量 存储符合条件的人数
        let count = 0;
        arr.forEach(function (item) {
            // 判断符合条件的人数
            if (item >= num) { 
                count++;
            }
        })
        console.log(`人数：${count}`);

二、将"i love javascript very much"的每个单词的第一个字母，变为大写

        let str = 'i love javascript very much';

        let arr = str.split(' ');
        // console.log(arr);

        // 定义变量 存储数据
        let newStr = '';

        for (let i = 0; i < arr.length; i++) {
            // 将第一个字母变大写
            let FristStr = arr[i].charAt(0).toUpperCase();

            // 剪切
            let VStr = arr[i].slice(1, arr[i].length);

            // 合并
            newStr += FristStr + VStr + ' '

            //  newStr += item.charAt(0).toUpperCase() + item.slice(1) + ' '
        }
        newStr = newStr.trimEnd();
        console.log(newStr);

三、数组去重

        const arr = [1, 8, 1, 2, 3, 7, 6, 6, 6, 4, 5, 5, 5];

        // 方法一：indexOf
        arr.sort(function (a, b) { return a - b })

        // 定义变量 存储数据
        const newArr1 = [];

        arr.forEach(function (item) {
            // console.log(item, index);

            if (newArr1.indexOf(item) === -1) {

                newArr1.push(item);
            }
        })

        console.log(newArr1);

        // 方法二：set去重
        var newArr2 = [...new Set(arr)];
        console.log(newArr2);

四、数组排序

        // sort 排序
        const arr = [1, 8, 1, 2, 3, 7, 6, 6, 6, 4, 5, 5, 5];
        arr.sort(function (a, b) { return a - b })
        console.log(arr);

        // 冒泡排序
        for (let j = 0; j < arr.length - 1; j++) {

            for (let i = 0; i < arr.length - 1 - j; i++) {

                if (arr[i] > arr[i + 1]) {
                    let temp = arr[i];
                    arr[i] = arr[i + 1];
                    arr[i + 1] = temp;
                }
            }
        }
        console.log(arr);

        // 选择排序
        for (let j = 0; j < arr.length - 1; j++) {

            // 定义变量 存储最小下标
            let minIndex = j;

            for (let i = j + 1; i < arr.length; i++) {

                if (arr[minIndex] > arr[i]) {

                    minIndex = i;
                }
            }
            // 交换真实最小下标
            let temp = arr[j];
            arr[j] = arr[minIndex];
            arr[minIndex] = temp;
        }
        console.log(arr);

五、数组转对象

    const arr = ['a', 'a', 'a', 'b', 'b', 'c', 'c', 'c', 'c', 'd', 'd', 'd', 'd'];
    let obj = {};

    for (let i = 0; i < arr.length; i++) {

      // if( obj[arr[i]] === undefined){
      if (!obj[arr[i]]) {

        obj[arr[i]] = 1;
      } else {
        obj[arr[i]]++;
      }
    }
    console.log(obj);

六、有一个长度为100的数组, 求出该数组前10个元素之和

1、我的方法

        // 定义空数组 存储长度为100的数组
        const arr = [];

        // 定义变量 存储元素之和
        let sum = 0;

        for (let i = 1; i <= 100; i++) {
            // 将数字添加到数组中
            arr.push(i);
        }
        console.log(arr);

        // 求前10个元素的和
        arr.forEach(function (item, index) {
            if (index <= 9) {
                sum += item;
            }
        })
        console.log(sum); 

2、代码实现

        // 1. 找到数组前 10个元素;  
        // 2. 求和
        var arr = [9, 8, 1, 4, 6, 3, 7, 2, 5, 10, 110000000, 120000000, 13000000000]
        // 1. 找到数组前 10 个元素
        var newArr = arr.splice(0, 10)
        console.log(newArr)
        // 2. 求和
        var num = newArr.reduce(function (prev, item) {return prev + item})
        console.log(num)

七、引用数据类型分析题

1、我的分析

        var x = [1, 2, 3];
        var y = x;    // y = [1, 2, 3];
        y[0] = 10;
        x[2] = 30;    // y = [10, 2, 30];
        console.log(x, y);

        /**
         * 分析如下：
         *    x = [10, 2, 30];
         *    y = [10, 2, 30];
         *  
         *    因为x，y是引用数据类型 改变的地址
         *    当y改变的时候 x也会改变
         *    因此x，y输出的是一样的
        */

2、分析

        var x = [1, 2, 3];      // x == QF001   QF001 == [1, 2, 3]
        var y = x;              // y == QF001   QF001 == [1, 2, 3]
        y[0] = 10;              // 修改变量y[0] 的值, 其实就是修改地址 QF001 的内容 ----> QF001 == [10, 2, 3]
        x[2] = 30;              // 修改变量x[2] 的值, 其就是修改地址 QF001 的内容 ---> QF001 == [10, 2, 30]
        console.log(x, y);      // x --- y      相当于打印两次 QF001        ---> [10, 2, 30]   [10, 2, 30]

八、引用数据类型分析题

1、我的分析

        var x = [1, 2, 3];
        var y = x;        // y = [1, 2, 3]
        var z = [4, 5, 6];
        y[0] = 10;   // y = [10, 2, 3]
        y = z;       // y = [4, 5, 6]
        z[1] = 20;   // z = [4, 20, 6]
        x[2] = 30;   // x = [10, 2, 30]
        console.log(x, y, z);

        /**
         * 分析如下：
         *    x,y,z 都是引用数据类型 x = [10, 2, 30]
         *    var y = x; 因此y和x在一个地址空间
         *    y[0] = 10； // y = [10, 2, 3]
         *    x[2] = 30;  // x = [10, 2, 30]
         * 
         *    因为y = z;  // y = [4, 5, 6]  
         *    所以y的地址改变 y和z是一个地址空间
         * 
         *    y =  [4, 20, 6]
         *    z =  [4, 20, 6]
        */

2、分析

        var x = [1, 2, 3];          // x == QF001   QF001 == [1, 2, 3]
        var y = x;                  // y == QF001   QF001 == [1, 2, 3]
        var z = [4, 5, 6];          // z == QF002   QF002 == [4, 5, 6]
        y[0] = 10;                  // 修改y[0] 的值, 其实就是修改 QF001;   QF001 == [10, 2, 3]
        y = z;                      // y == QF002   QF002 == [4, 5, 6]     !!! 注意, 此时切断了y和x之间的关系
        z[1] = 20;                  // 修改z[1] 的值, 其实就是修改 QF002;   QF002 = [4, 20, 6]
        x[2] = 30;                  // 修改x[2] 的值, 其实就是修改 QF001;   QF001 == [10, 2, 30]
        console.log(x, y, z);
        /**
         *  x == QF001  ---> [10, 2, 30]
         *  y == QF002  ---> [4, 20, 6]
         *  z == QF002  ---> [4, 20, 6]
        */

九、请自己手写一个函数, 实现数组的push功能

        var arr = [1, 2, 3];
        function myPush(fnArr, num) {
            // 1. 在数组末尾添加一个数据
            // fnArr.splice(arr.length, 0, num);
            fnArr[fnArr.length] = num;

            // 2. 返回一个最新数组的长度
            return fnArr.length;
        }
        var num = myPush(arr, 5);
        console.log(arr, num); // [1, 2, 3, 5]

十、解决问题

    /**
     * 10. 买卖股票的最佳时机；给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。
     如果你最多只允许完成一笔交易（即买入和卖出一支股票一次）设计一个算法来计算你所能获取的最大利润。
     *  注意: 你不能再购买股票的前一天卖出股票
     *
     * 示例: 输入：[7, 1, 5, 3, 6, 4]  输出：5
     *
     *  解释: 在第2天（当天股票价格等于1）的时候买入，在第五天（当天股票价格等于6）的时候卖出，最大利润为 6 - 1 = 5。
     *  注意：利润不能是7 - 1 = 6，因为第二天的价格为1，第一天的价格为7，你是不可能在第二天买入股票然后等到第一天卖出的
     */

        /**
         *  逻辑: 当前项与后续的所有成员中, 差值最大的
         *      1. 双重for循环, 拿到数组的每一项与后续的所有项
         *      2. 计算出最大的差值并存储
        */
        var arr = [7, 1, 5, 3, 6, 4, 100];
        // 定义变量 存储最大的差值
        var max = 0 
        for (var i = 0; i < arr.length; i++) {
            for (var k = i + 1; k < arr.length; k++) {
            
                // console.log(`当前项 ${i}; 后续的每一个项 ${k}`)
                
                if (arr[k] - arr[i] > max) {
                    max = arr[k] - arr[i];
                }
            }
        }
        console.log(max)