数组练习

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

var len = +prompt("请输入数组的长度");
if (isNaN(len) || len < 0) {
  console.log("输入有误");
} else {
  //输入正确
  var arr = [];
  for (var i = 0; i < len; i++) {
    // 提示用户输入数组的这一项的值
    arr[i] = prompt("请输入数组第" + (i + 1) + "项的值");
  }
  console.log(arr);
}

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

var arr = [234, 6, 23, 211, 23];
var sum = 0;

for (var index in arr) {
  sum += arr[i];
}

console.log(sum);

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

var arr = [234, 6, 23, 211, 23];

for (var index in arr) {
  if (arr[index] % 2 !== 0) {
    console.log(arr[index]);
  }
}

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

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]);
  }
}

斐波拉契数列是这样一种数列：1 1 2 3 5 8 13 ...... 数列前两位为1，第n位=第n-1位+第n-2位让用户输入斐波拉契数列的长度，在控制台中打印该长度的斐波拉契数列

const len = +prompt("请输入斐波拉契数列长度");

if (isNaN(len) || len < 0) {
  // 输入错误
  console.log("输入有误");
} else {
  // 输入正确
  var arr = [];

  // 构造数列
  for (let i = 0; i < len; i++) {
    if (i === 0 || i === 1) {
      arr.push(1);
    } else {
      const num = arr[i - 1] + arr[i - 2];
      arr.push(num);
    }
  }

  console.log(arr.join(","));
}

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

var users = [
  {
    loginId: "abc",
    loginPwd: "123",
  },
  {
    loginId: "abc1",
    loginPwd: "1234",
  },
  {
    loginId: "abc2",
    loginPwd: "1235",
  },
  {
    loginId: "abc3",
    loginPwd: "1236",
  },
];

var loginId = prompt("请输入账号");
var loginPwd = prompt("请输入密码");

// 查找问题
var isFind = false;
for (var i = 0; i < users.length; i++) {
  var u = users[i];
  if (u.loginId === loginId && u.loginPwd === loginPwd) {
    isFind = true;
    break;
  }
}

if (isFind) {
  console.log("登录成功");
} else {
  console.log("登录失败");
}

初始化一个5*5的二维数组，数组每一项是一个数字，计算对角线之和

var arr = [
  [5, 2, 3, 1, 7],
  [8, 0, 6, 7, 8],
  [4, 0, 6, 2, 0],
  [3, 0, 6, 8, 1],
  [2, 0, 4, 5, 9],
];

// 对角线之和(主对角线+反对角线)
var sum = 0;
for (var i = 0; i < arr.length; i++) {
  // arr[i] 是一个数组
  for (var j = 0; j < arr[i].length; j++) {
    // arr[i][j]
    if (i === j || i + j === arr.length - 1) {
      sum += arr[i][j];
    }
  }
}

console.log(sum);

面试题-冒泡排序：初始化一个数字数组（数据随意），对该数组进行升序排序，然后输出结果

冒泡排序算法的原理如下：

比较相邻的元素。如果第一个比第二个大，就交换他们两个。
对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
针对所有的元素重复以上的步骤，除了已排好序的元素。

var arr = [234, 2, 6, 23, 211, 1];

// 算法
// 排序多少次 i代表排序次数
for (var i = 1; i < arr.length; i++) {
  // 第i次排序做什么? 两位比较，已经排好的不用管  j代表第几位
  for (var j = 0; j < arr.length - i; j++) {
    if (arr[j] > arr[j + 1]) {
      [arr[j], arr[j + 1]] = [arr[j + 1], arr[j]];
    }
  }

}

console.log(arr);

找出数组最大值

// 求最大值
var nums = [23, 6, 1, 1, 666, 324];
var max = nums[0]; //假设第一项最大

for (var i = 1; i < nums.length; i++) {
  if (nums[i] > max) {
    max = nums[i];
  }
}

console.log(max);

有一个数组，存放了一些数字，找出出现频率最高的数字
思路-使用映射对象的方式：
1. 准备一个对象，记录数组成员出现的次数
2. 遍历该对象，记录下该对象中出现最大次数的数据。

var arr = [2, 3, 4, 5, 234, 5, 5, 5, 5, 5, 5, 5, 5, 2, 2, 2, 2, 3, 3, 3, 5];

//构造记录对象
var record = {}; //数组映射对象
var result = null; //查找结果{element,frequency}

// 构造数组映射对象
for (var i = 0; i < arr.length; i++) {
  if (!record[arr[i]]) {
    record[arr[i]] = 1;
  } else {
    record[arr[i]]++;
  }
}

// 查找出现最多次数的元素
for (var k in record) {
  if (!result || record[k] > result.frequency) {
    result = {
      element: k,
      frequency: record[k],
    };
  }
}

console.log(
  `出现最高频率的元素：${result.element}，出现次数：${result.frequency}`,
);

数组练习 ​

数组练习