算法是描述如何处理某个问题的一系列步骤。
要写一个有效的算法，你需要先将一个特定的问题分解为小的部分，并仔细思考如何用代码解决每个部分。

将摄氏度转换为华氏度

将摄氏度转换为华氏度的计算方式为：摄氏度乘以 9/5 然后加上 32。
输入参数 celsius 代表一个摄氏度的温度。 使用已定义的变量 fahrenheit，并赋值为相应的华氏度的温度值。 根据上述转换公式来进行转换。

  1. function convertToF(celsius) {
  2.   let fahrenheit = celsius*9/5+32;
  3.   return fahrenheit;
  4. }
  6. convertToF(30);

反转字符串

请反转传入函数的字符串。
在反转字符串之前，你可能需要将其切分成包含字符的数组。
函数的返回结果应为字符串。

  1. function reverseString(str) {
  2.   return str.split("").reverse().join("");
  3. }
  5. reverseString("hello");

计算整数的阶乘

返回一个给定整数的阶乘计算结果。
对于整数 n，n 的阶乘就是所有小于等于 n 的正整数的乘积。
阶乘通常用符号 n! 来表示。
例如：5! = 1 2 3 4 5 = 120

  1. function factorialize(num) {
  2. return Array(num).fill(0).reduce((acc,curr,idx)=>{
  3.   return acc*(idx+1)
  4. },1)
  5. }
  7. factorialize(5);

找出字符串中的最长单词

返回给出的句子中，最长单词的长度。
函数的返回值应是一个数字。

  1. function findLongestWordLength(str) {
  2.   return str.split(" ").reduce((acc,curr)=>{
  3.     return Math.max(acc,curr.length)
  4.   },0);
  5. }
  7. findLongestWordLength("The quick brown fox jumped over the lazy dog");

找出多个数组中的最大数字

请返回一个数组，该数组由参数中每个子数组中的最大数字组成。 为简单起见，给出的数组总会包含 4 个子数组。
别忘了，你可以通过 for 循环遍历一个数组，并用 arr[i]的写法来访问数组中的元素。

  1. function largestOfFour(arr) {
  2.   return arr.reduce((acc,curr)=>{
  3.     acc.push(Math.max(...curr))
  4.     return acc;
  5.   },[])
  6. }
  8. largestOfFour([[4, 5, 1, 3], [13, 27, 18, 26], [32, 35, 37, 39], [1000, 1001, 857, 1]]);

确定结尾

检查字符串（第一个参数 str）是否以给定的目标字符串（第二个参数 target）结束。
这个挑战 可以 用 ES2015 引入的 .endsWith() 方法来解决。但在这个挑战中，请使用 JavaScript 的字符串子串方法。

  1. function confirmEnding(str, target) {
  2.   //return str.endsWith(target)
  3.   return str.substring(str.length-target.length)==target;;
  4. }
  6. confirmEnding("Bastian", "n");

重复字符串

将一个给定的字符串 str（第一个参数）重复输出 num（第二个参数）次。 如果 num 不是正数，返回空字符串。

  1. function repeatStringNumTimes(str, num) {
  2.   if (num > 0) {
  3.     return Array(num).fill(str).reduce((acc, curr) => {
  4.       return acc + curr
  5.     }, "")
  6.   } else {
  7.     return ""
  8.   }
  9. }
  11. repeatStringNumTimes("abc", 3);

截断字符串

如果传入的字符串（第一个参数）的长度大于传入的值（第二个参数），请在这个位置截断它， 并在后面加上 …，然后返回结果。

  1. function truncateString(str, num) {
  2.   return str.length > num ? str.slice(0, num) + "..." : str;
  3. }
  5. truncateString("A-tisket a-tasket A green and yellow basket", 8);

按参数过滤数组

请写一个函数来检查数组（第一个参数 arr）中的元素，并返回数组中第一个通过校验测试的元素。 其中，“通过校验测试”指的是对于数组中的一个元素 x，若 func(x) 返回的结果为 true，则校验测试通过。 如果没有元素通过测试，请返回 undefined

  1. function findElement(arr, func) {
  2.   let num = arr.findIndex(item => func(item));
  3.   return arr[num];
  4. }
  6. findElement([1, 2, 3, 4], num => num % 2 === 0);

基本类型Boolean值检查

检查一个值是否是基本类型中的布尔值（boolean）类型。 函数应返回 true 或者 false。
基本类型中的布尔值为 true 或者 false。

  1. function booWho(bool) {
  2.   return typeof bool === "boolean";
  3. }
  5. booWho(null);

居中单词首字母大写

请将传入的字符串中，每个单词的第一个字母变成大写并返回。 注意除首字母外，其余的字符都应是小写的。

  1. function titleCase(str) {
  2.   return str.toLowerCase().split(" ").map((item => {
  3.     let first = item.charAt(0);
  4.     return first.toUpperCase() + item.substr(1)
  5.   })).join(" ")
  6. }
  8. titleCase("I'm a little tea pot");

Slice 与 Splice

本挑战的输入参数为两个数组和一个索引值。
将第一个数组中的所有元素依次复制到第二个数组中。
请注意，你需要从第二个数组索引值为 n 的地方开始插入。
最后，请返回插入元素后的数组。 作为输入参数的两个数组在函数执行前后应保持不变。

  1. function frankenSplice(arr1, arr2, n) {
  2.   let newArr = arr2.slice()
  3.   newArr.splice(n, 0, ...arr1)
  4.   return newArr;
  5. }
  7. frankenSplice([1, 2, 3], [4, 5, 6], 1);

过滤数组中的假值

从数组中移除所有假值（falsy values）。
JavaScript 中的假值有 false、null、0、””、undefined、NaN。
提示：可以考虑将每个值都转换为布尔值（boolean）。

  1. function bouncer(arr) {
  2.   return arr.filter(item => Boolean(item));
  3. }
  5. bouncer([7, "ate", "", false, 9]);

找出元素在排序后数组中的索引

数组（第一个参数）在排序后，将一个值（第二个参数）插入该数组，并使数组保持有序。返回这个新插入元素的最小索引值。 返回值应为一个数字。
例如，getIndexToIns([1,2,3,4], 1.5) 应该返回 1 因为1.5 大于 1（索引为 0）且小于 2（索引为 1）。
同样地，getIndexToIns([20,3,5], 19) 应该返回 2。 因为数组排序后会变成 [3,5,20]，而 19 小于 20（索引为 2）且大于 5（索引为 1）。

  1. function getIndexToIns(arr, num) {
  2.   return [...arr, num].sort((a, b) => a - b).findIndex(item => item === num);
  3. }
  5. getIndexToIns([40, 60], 50);

比较字符

如果数组里的第一个字符串包含了第二个字符串中的所有字母，则返回 true。
例如，[“hello”, “Hello”] 应该返回 true。因为在忽略大小写的情况下，第一个字符串包含了第二个字符串里出现的所有字母。
[“hello”, “hey”] 应该返回 false。因为 hello 并不包含字符 y。
最后，[“Alien”, “line”] 应该返回 true。因为 line 中的所有字母都出现在了 Alien 中。

  1. function mutation(arr) {
  2.   let list = arr.map(item => item.toLowerCase())
  3.   return list[1].split("").every(item => list[0].includes(item))
  4. }
  6. mutation(["hello", "hey"]);

分割数组

请编写一个函数，该函数将一个数组（第一个参数）拆分成若干长度为 size（第二个参数）的子数组，并将它们作为二维数组返回。

  1. function chunkArrayInGroups(arr, size) {
  2.   let list = []
  3.   for (let i = 0; i < arr.length; i += size) {
  4.     list.push(arr.slice(i, size + i))
  5.   }
  6.   return list
  7. }
  9. chunkArrayInGroups(["a", "b", "c", "d"], 2);