面试-简单算法题

简单算法：

1.反转字符串

编写一个函数，将输入的字符串反转。

function reverseString(str) {
  return str.split('').reverse().join('');
}

str.split(‘’)：使用 split(‘’) 方法将字符串 str 拆分成字符数组，每个字符都成为数组中的一个元素。例如，对于输入字符串 “hello”，拆分后的数组为 [‘h’, ‘e’, ‘l’, ‘l’, ‘o’]。

.reverse()：使用 reverse() 方法将数组中的元素顺序颠倒。对于上一步得到的数组 [‘h’, ‘e’, ‘l’, ‘l’, ‘o’]，通过 reverse() 方法得到的数组为 [‘o’, ‘l’, ‘l’, ‘e’, ‘h’]。

.join(‘’)：使用 join(‘’) 方法将数组中的元素拼接成一个字符串。对于上一步得到的数组 [‘o’, ‘l’, ‘l’, ‘e’, ‘h’]，通过 join(‘’) 方法得到的字符串为 “olleh”。

返回反转后的字符串。

2.查找数组内的最大值和最小值

编写一个函数，接受一个数字数组作为参数，返回数组中的最大值和最小值。
function findMinMax(arr) {
const min = Math.min(…arr);
const max = Math.max(…arr);
return { min, max };
}

3.数组去重

1) 使用Set数据结构

将数组转化为Set，由于Set的特性是不允许出现重复元素，因此会自动去除数组中的重复元素。然后再将Set转回为数组。

let arr = [1, 2, 3, 3, 4, 5, 5];
let uniqueArr = [...new Set(arr)];

2) 使用filter方法

利用filter方法和indexOf方法来过滤出不重复的元素。

let arr = [1, 2, 3, 3, 4, 5, 5];
let uniqueArr = arr.filter((value, index, self) => self.indexOf(value) === index);

解析：
声明了一个数组 arr，其中包含重复元素的数组：[1, 2, 3, 3, 4, 5, 5]。

使用filter方法对数组 arr 进行操作。filter方法接受一个回调函数作为参数，该回调函数会对数组中的每个元素进行处理。

回调函数接受三个参数：

value: 当前数组元素的值。
index: 当前数组元素的索引。
self: 原始数组本身。

在回调函数中，使用 self.indexOf(value) 来判断当前元素 value 在数组中第一次出现的位置。如果当前元素的索引和 self.indexOf(value) 返回的索引相等，说明当前元素是第一次出现，即不重复，则返回 true，保留在结果数组中，否则返回 false，在数组中被过滤掉。

最终得到的 uniqueArr 就是去除了重复元素的数组，即 [1, 2, 3, 4, 5]。

3） 使用reduce方法

通过reduce方法遍历数组，将不重复的元素加入结果数组中。

let arr = [1, 2, 3, 3, 4, 5, 5];
let uniqueArr = arr.reduce((acc, currentValue) => {
    if (!acc.includes(currentValue)) {
        acc.push(currentValue);
    }
    return acc;
}, []);

解析：
声明了一个数组 arr，其中包含重复元素的数组：[1, 2, 3, 3, 4, 5, 5]。

使用reduce方法对数组 arr 进行操作。reduce方法接受一个回调函数和一个初始值作为参数，该回调函数会对数组中的每个元素进行处理，并返回一个累加结果。

回调函数接受两个参数：

acc: 累加器，累积处理的结果。
currentValue: 当前数组元素的值。

在回调函数中，首先判断当前元素 currentValue 是否已经存在于累加器 acc 中，即判断 !acc.includes(currentValue)。如果当前元素不在累加器中，则将其添加到累加器中，通过 acc.push(currentValue) 实现。

最终返回累加器 acc，即去除了重复元素的数组。

初始值为一个空数组 []，这样reduce方法会从空数组开始逐个处理数组元素，将不重复的元素逐步累加到结果数组中。

最终得到的 uniqueArr 就是去除了重复元素的数组，即 [1, 2, 3, 4, 5]。

4）使用对象属性

利用对象的属性来存储元素，如果对象中不存在该属性，则将其存入结果数组中。

let arr = [1, 2, 3, 3, 4, 5, 5];
let uniqueArr = [];
let obj = {};
for (let i of arr) {
    if (!obj[i]) {
        uniqueArr.push(i);
        obj[i] = 1;
    }
}

这段代码使用了一个空对象 obj 来去重，并利用一个额外的数组 uniqueArr来保存去重后的结果。让我们来解析一下这段代码的执行过程：
obj[i] 的理解：
obj[i] 是使用变量 i 的值作为对象 obj 的属性名来进行访问的语法。

具体解释如下：

obj 是一个空对象，用于存储数组中出现过的元素。
在 for…of 循环中，let i of arr 会将数组 arr 中的每一个元素依次赋值给变量 i。
在循环体中，使用 obj[i] 就是尝试获取对象 obj 中属性名为 i 的属性的值。
如果 obj 中不存在属性名为 i 的属性，obj[i] 的值将是 undefined。
利用这一点，在条件判断中使用 if (!obj[i]) 可以判断当前元素 i 是否已经存在于对象 obj 中，如果不存在，则执行相应的操作。
在这段代码中，通过检查 obj[i] 是否为真来判断当前元素 i 是否已经存在于 obj 对象中。如果不存在，就将当前元素添加到 uniqueArr 数组中，并且在 obj 对象中为该元素设置一个属性，表示该元素已经出现过。

4.斐波那契数列

编写一个函数，接受一个数字n作为参数，返回斐波那契数列中第n个数字的值。
斐波那契数列是一个以 0 和 1 开始，后续的每一项都是前两项之和的数列。

function fibonacci(n) {
  if (n <= 1) {
    return n;
  }
  return fibonacci(n - 1) + fibonacci(n - 2);
}

这段代码是一个经典的递归实现斐波那契数列的函数。

具体解析如下：

函数名为 fibonacci，接收一个参数 n，表示要计算的斐波那契数列的第 n 个数字。
首先，函数检查输入的 n 值是否小于等于 1。若是，则直接返回 n。
如果 n 大于 1，函数会通过递归调用自身来计算第 n 个斐波那契数。
递归的终止条件是当 n 小于等于 1 时，直接返回 n。
在递归调用中，函数会依次计算第 n-1 和第 n-2 个斐波那契数，并将它们相加作为结果返回。
递归调用会一直向下延伸，直到达到终止条件，然后逐层返回结果，最终得到第 n 个斐波那契数的值。

5.回文字符串（正读和反读都一样）

编写一个函数，判断输入的字符串是否是回文字符串。

function isPalindrome(str) {
  const reversedStr = str.split('').reverse().join('');
  return str === reversedStr;
}

6.两个字符串是否是异位词

编写一个函数，判断两个字符串是否包含相同的字符，但字符的顺序可以不同。
异位词（anagram）指的是具有相同字母，但字母顺序不同的单词或短语。换句话说，如果两个字符串中的字符种类和数量相同，但是它们的排列顺序不同，那么这两个字符串就是异位词。
举例来说，“listen” 和 “silent” 就是异位词，因为它们都由相同的字母组成，只是顺序不同。

function isAnagram(str1, str2) {
  const sortedStr1 = str1.split('').sort().join('');
  const sortedStr2 = str2.split('').sort().join('');
  return sortedStr1 === sortedStr2;
}

解析：
具体解析如下：

函数名为 isAnagram，接收两个参数 str1 和 str2，分别表示要比较的两个字符串。
首先，函数将 str1 和 str2 分别转换为字符数组，然后对字符数组进行排序。
排序后，再将排序后的字符数组通过 join(‘’) 方法转换回字符串，得到 sortedStr1 和 sortedStr2，分别表示排序后的两个字符串。
最后，函数返回比较 sortedStr1 和 sortedStr2 是否相等的结果。如果它们相等，则说明原始的两个字符串是异位词，返回 true；否则返回 false。

7.数组求和

编写一个函数，接受一个数字数组作为参数，返回数组中所有数字的和。

const arr = [1, 2, 3, 4, 5];
const sum = arr.reduce((accumulator, currentValue) => accumulator + currentValue, 0);
console.log(sum); // 输出 15

解析：
具体解析如下：

arr 是一个包含整数的数组 [1, 2, 3, 4, 5]。
reduce() 方法被调用在 arr 数组上，传入了两个参数：
第一个参数是一个回调函数 (accumulator, currentValue) => accumulator + currentValue，用于对数组中的每个元素进行操作。
accumulator 是一个累加器，初始值为 0，在每次迭代中保存着累积的结果。
currentValue 是当前被处理的元素，从数组的第一个元素开始。
回调函数的逻辑是将当前元素的值与累加器的值相加，并返回新的累加器值。
第二个参数是 0，表示累加器的初始值。
reduce() 方法的执行过程如下：
初始时，累加器的值为 0。
对于数组中的每个元素，回调函数将当前元素的值与累加器的值相加，得到一个新的累加器值。
最终，reduce() 方法返回最后一次回调函数的返回值作为最终的累加器值。
在这段代码中，sum 变量存储了 reduce() 方法的返回值，即数组 arr 中所有元素的总和。
最后，通过 console.log(sum) 打印 sum 的值，输出结果为 15，表示数组中所有元素的总和为 15。

8.数组平均值

编写一个函数，接受一个数字数组作为参数，返回数组中所有数字的平均值。

unction calculateAverage(arr) {
    if (arr.length === 0) {
        return 0; // 避免除以0错误，空数组的平均值为0
    }
    
    const sum = arr.reduce((acc, current) => acc + current, 0);
    const average = sum / arr.length;
    
    return average;
}

// 示例数组
const numbers = [10, 20, 30, 40, 50];
const average = calculateAverage(numbers);
console.log("数组的平均值为：" + average);

9.查找最长单词

编写一个函数，接受一个字符串作为参数，返回字符串中最长的单词。

function findLongestWord(str) {
  const words = str.split(' ');
  let longestWord = '';
  for (let word of words) {
    if (word.length > longestWord.length) {
      longestWord = word;
    }
  }
  return longestWord;
}
 console.log('111', findLongestWord('I love coding and programming'))  // programming