数组常见面试题目

      **1. 提示用户输入数组的长度，以及数组每一项的值，然后输出该数组**

    var len = +prompt("请输入其数组的长度1")
    if (!len || len < 0) {
        alert("请重新进行输入")
    } else {
        var arr = new Array(len)
        for (var i = 0; i < arr.length; i++) {
            arr[i] = prompt("请输入其" + (i + 1) + "的值")
        }
        console.log(arr)
    }



    **2. 初始化一个数字数组，然后求该数组所有项之和**

    var arr = [1, 2, 3, 4, 5, 6, 8, 9, 6]
    var sum = 0
    for (var i = 0; i < arr.length; i++) {
        sum += arr[i]
    }
    console.log(sum)




    **3.初始化一个数字数组，然后输出数组中所有的奇数**


    var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9]
    for (const index in arr) {
        if (arr[index] % 2 != 0) {
            console.log(arr[index])
        }
    }




    **4. 初始化一个数字数组，然后输出数组中所有的素数**

    var arr = [234, 2, 6, 23, 211, 23];
    for (var index in arr) {
        // 判断arr[index]是不是素数
        var isFind = false;
        for (var i = 2; i < arr[index] - 1; i++) {
            if (arr[index] % i === 0) {
                isFind = true;
                break;
            }
        }
        if (!isFind &&
            arr[index] >= 2) {
            console.log(arr[index]);
        }
    }


    **5. 斐波拉契数列是这样一种数列：1 1 2 3 5 8 13 ......
    数列前两位为1，第n位=第n-1位+第n-2位
    让用户输入斐波拉契数列的长度，在控制台中打印该长度的斐波拉契数列
  
  
    var len = +prompt("请输入斐波拉契数列的长度")
    if (!len || len < 0) {
        console.log("输入有误")
    } else {
        var arr = []
        for (var i = 0; i < len; i++) {
            if (i === 0 || i === 1) {
                arr[i] = 1
            } else {
                arr[i] = arr[i - 1] + arr[i - 2]
            }
        }
        console.log(arr)
    }**




    **6. 定义一个用户数组，数组的每一项是一个用户对象，用户对象中包含账号和密码，随意初始化一些对象放入数组中。
    然后提示用户输入账号和密码，判断是否登录成功**

    var arr = [{
            "id": "1232",
            "pwd": "4562"
        },
        {
            "id": "789",
            "pwd": "456"
        }
    ]
    var loginId = prompt("请输入其用户的账号")
    var loginPwd = prompt("请输入其用户的密码")
    for (var i = 0; i < arr.length; i++) {
        if (arr[i].id === loginId && arr[i].pwd === loginPwd) {
            console.log("登陆成功")
        }
    }



    **7. 初始化一个5*5的二维数组，数组每一项是一个数字，计算对角线之和**
    var arr = [
        [1, 23, 4, 5, 0],
        [1, 25, 4, 0, 6],
        [1, 23, 1, 5, 6],
        [1, 3, 4, 2, 6],
        [2, 23, 4, 5, 1]
    ]
    var sum = 0
    for (var i = 0; i < arr.length; i++) {

        for (var j = 0; j < arr[i].length; j++) {

            if (i === j || i + j === arr.length) {

                sum += arr[i][j]
            }
        }
    }
    console.log(sum)


    **8. 初始化一个数字数组（数据随意），对该数组进行升序排序，然后输出结果
    思路提示：
    数组的排序有多种算法可以完成，这里介绍其中一种：冒泡排序算法
    冒泡排序算法的原理如下：
    - 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
    - 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
    - 针对所有的元素重复以上的步骤，除了已排好序的元素。**


    [15，12,1]


    第一次;  循环了两次
    [12,15,1]
    [12,1,15]

    第二次：循环了一次
    [1,12,15]


    var arr = [122, -1, 5, 9, 7, 8, 9, 5, 2, 31, 1]
    for (var i = 0; i < arr.length - 1; i++) {
        for (var j = 0; j < arr.length - i; j++) {
            if (arr[j] > arr[j + 1]) {
                var temp = arr[j]
                arr[j] = arr[j + 1]
                arr[j + 1] = temp
            }
        }
    }
    console.log(arr)

    **9. 有一个数组，存放了一些数字，找出出现频率最高的数字**

    var arr = [1, 2, 3, 4, 5, 67, 8, 2, 3, 2, 2, 2, 2, 2]
    var obj = {}
    for (var i = 0; i < arr.length; i++) {
        if (obj[arr[i]]) {
            obj[arr[i]]++
        } else {
            obj[arr[i]] = 1
        }
    }
    var resulte
    for (const index in obj) {
        if (!resulte || obj[index] > resulte.fq) {
            resulte = {
                number: index,
                fq: obj[index]
            }
        }
    }
    console.log(`${resulte.number}出现频率最高，出现${resulte.fq}次`);