freeCodeCamp （JavaScript基础算法题）

1、将摄氏度转换为华氏度

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

function convertToF(celsius) {
  let fahrenheit = (celsius * 9)/5 +32;
  return fahrenheit;
}

convertToF(30);

2、反转字符串

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

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

reverseString("hello");

3、计算整数的阶乘

返回一个给定整数的阶乘计算结果。
对于整数 n，n 的阶乘就是所有小于等于 n 的正整数的乘积。
阶乘通常用符号 n! 来表示。
例如：5! = 1 * 2 * 3 * 4 * 5 = 120
在这个挑战中，只有非负整数会作为参数传入函数。

function factorialize(num) {
  if(num < 0){
    return -1;
  }else if (num == 0){
    return 1;
  }else {
return num * factorialize(num -1);
  }
}
factorialize(5);

4、找出字符串中的最长单词

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

function findLongestWordLength(str) {
  let myStr=str.split(' ');
  let longest = 0;
  for(var i = 0;i < myStr.length ; i++){
    if(longest < myStr[i].length){
    longest=myStr[i].length;
    }
  }
  return longest;
}

findLongestWordLength("The quick brown fox jumped over the lazy dog");

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

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

function largestOfFour(arr) {
  let arr1 = [];
  for(let i = 0; i < arr.length ; i++){
    arr1.push(Math.max.apply(null,arr[i]));
  }
  return arr1;
}

largestOfFour([[4, 5, 1, 3], [13, 27, 18, 26], [32, 35, 37, 39], [1000, 1001, 857, 1]]);

6、确认结尾

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

function confirmEnding(str, target) {
  return str.substr(-target.length)===target;
}

confirmEnding("Bastian", "n");

7、重复输出字符串

将一个给定的字符串 str（第一个参数）重复输出 num（第二个参数）次。 如果 num 不是正数，返回空字符串。 在这个挑战中，请不要使用 JavaScript 内置的 .repeat() 方法。

function repeatStringNumTimes(str, num) {
  let arr = "";
  let i = 0;
     while (i < num ){
      arr+=str;
      i++;
    }
  return arr;
}

repeatStringNumTimes("abc", 3);

8、截断字符串

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

truncateString("A-tisket a-tasket A green and yellow basket", 8) 应返回 A-tisket...。
truncateString("Peter Piper picked a peck of pickled peppers", 11) 应返回 Peter Piper...。
truncateString("A-tisket a-tasket A green and yellow basket", "A-tisket a-tasket A green and yellow basket".length) 应返回 A-tisket a-tasket A green and yellow basket。
truncateString("A-tisket a-tasket A green and yellow basket", "A-tisket a-tasket A green and yellow basket".length + 2) 应返回 A-tisket a-tasket A green and yellow basket。
truncateString("A-", 1) 应返回字符串 A...。
truncateString("Absolutely Longer", 2) 应返回 Ab...。

function truncateString(str, num) {
  let string = "";
  if(num < str.length){
    return str.slice(0,num)+"...";
  }
  return str;
}

truncateString("A-tisket a-tasket A green and yellow basket", 8);

9、按参数过滤数组

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

function findElement(arr, func) {
  for(let i = 0;i<arr.length;i++){
    if(func(arr[i])){
      return arr[i];
    }
  }
    return undefined;
}

findElement([1, 2, 3, 4], num => num % 2 === 0);

10、基本类型布尔值的检查

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

function booWho(bool) {
  return typeof(bool) == 'boolean';
}

booWho(null);

11、句中单词首字母大写

请将传入的字符串中，每个单词的第一个字母变成大写并返回。 注意除首字母外，其余的字符都应是小写的。
在这个挑战中，我们还需要将诸如 the 和 of 之类的连接词大写。

function titleCase(str) {
  let arr = str.toLowerCase().split(" "); //先将所有字符转换为小写
  for(let i = 0; i < arr.length; i++){
    arr[i] = arr[i][0].toUpperCase()+arr[i].slice(1); //将第一个字符转换为大写 再加上除第一个字符外的其他字符
  }
  return arr.join(" "); //将数组中的元素以空格为分隔符拼接为字符串
}

titleCase("I'm a little tea pot");

12、Slice 与 Splice

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

function frankenSplice(arr1, arr2, n) {
  let newarr = arr2.slice();
   newarr.splice(n,0,...arr1);
   return newarr;
}

frankenSplice([1, 2, 3], [4, 5, 6], 1);

13过滤数组中的假值

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

/**
使用Boolean将所有元素转换为布尔类型，jia
*/
function bouncer(arr) {
  let narr = [];
  for(let i = 0 ; i < arr.length ; i++){
    if(Boolean(arr[i])){
      narr.push(arr[i]);
    }
  }
  return narr;
}

bouncer([7, "ate", "", false, 9]);

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

数组（第一个参数）在排序后，将一个值（第二个参数）插入该数组，并使数组保持有序。返回这个新插入元素的最小索引值。 返回值应为一个数字。
例如，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）。

function getIndexToIns(arr, num) {
  arr.push(num); //将num加入数组中
  arr.sort((a,b) => (a - b)); //对数组按从小到大重新排序，如果降序可以写成  arr.sort((a,b) => (b - a))
  return arr.indexOf(num); //获取索引位置
}

getIndexToIns([40, 60], 50);

15、比较字符串

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

function mutation(arr) {
  let arr1 = arr[0].toLowerCase();
  let arr2 = arr[1].toLowerCase();
  for(let i = 0; i< arr2.length; i++){
    if(arr1.indexOf(arr2[i]) === -1){
      return false;
    }
  }
  return true;
}

mutation(["hello", "hey"]);

16、分割数组

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

chunkArrayInGroups(["a", "b", "c", "d"], 2) 应返回 [["a", "b"], ["c", "d"]]。
chunkArrayInGroups([0, 1, 2, 3, 4, 5], 3) 应返回 [[0, 1, 2], [3, 4, 5]]。
chunkArrayInGroups([0, 1, 2, 3, 4, 5], 2) 应返回 [[0, 1], [2, 3], [4, 5]]。
chunkArrayInGroups([0, 1, 2, 3, 4, 5], 4) 应返回 [[0, 1, 2, 3], [4, 5]]。
chunkArrayInGroups([0, 1, 2, 3, 4, 5, 6], 3) 应返回 [[0, 1, 2], [3, 4, 5], [6]]。
chunkArrayInGroups([0, 1, 2, 3, 4, 5, 6, 7, 8], 4) 应返回 [[0, 1, 2, 3], [4, 5, 6, 7], [8]]。
chunkArrayInGroups([0, 1, 2, 3, 4, 5, 6, 7, 8], 2) 应返回 [[0, 1], [2, 3], [4, 5], [6, 7], [8]]。

function chunkArrayInGroups(arr, size) {
  let count = arr.length/size;
  let arr1 = [];
  for(let i = 0 ;i < count; i++){
    console.log(arr);
    arr1.push(arr.splice(0,size));
  }
  return arr1;
}

chunkArrayInGroups(["a", "b", "c", "d"], 2);