JS算法基础

——来源freecodecamp

将摄氏温度转换成华氏温度

将摄氏度转换为华氏度的算法为：摄氏度 × 9/5 + 32

输入参数 celsius代表一个摄氏温度值。请你根据上述转换公式，将已定义好的 fahrenheit变量赋值为对应的华氏温度的值。

你不需要顾虑 function 和 return 语句，它们会在之后的挑战中予以介绍。现在，你只需要使用你已学过的运算符。

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

convertToF(30);

翻转字符串

反转给出的字符串。

你在反转字符串前可能需要将其切分成字符的数组。

你的结果必须是一个字符串。

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

reverseString("hello");

我们需要掌握
str.split()
arr.reverse()
arr.join()

数字的阶乘

返回一个给定整数的阶乘。

若 n 是一个整数，n 的阶乘就是所有小于等于 n 的正整数的乘积。

n 的阶乘通常用符号 n!来表示。

例如： 5! = 1 * 2 * 3 * 4 * 5 = 120

只有非负整数会被作为函数的输入参数。

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

factorialize(5);

//第二种方法是用arguments的属性callee指向拥有这个对象的函数
function factorial(num){
    if(num <= 1) {
         return 1;      
    }else{
          return num * arguments.callee(num-1);   
    }
}

查找字符串中最长的单词

返回给出的句子中最长的单词的长度。

你的返回应该是一个数字。

function findLongestWordLength(str) {
  var words = str.split(' ');
  var maxLength = 0;

  for (var i = 0; i < words.length; i++) {
    if (words[i].length > maxLength) {
      maxLength = words[i].length;
    }
  }

  return maxLength;
}

返回数组中最大的数字

返回一个数组，它要由给出的所有子数组中的最大值组成。简单起见，给出的数组总会包含4个子数组。

记得你可以在一个简单的 for 循环中遍历一个数组，并用 arr[i]这样的语法来访问数组中的元素。

function largestOfFour(arr) {
            var results = [];
            for (var i = 0; i < arr.length; i++) {
                var largestNumber = arr[i][0];
                for (var j = 1; j < arr[i].length; j++) {
                if (arr[i][j] > largestNumber) {
                    largestNumber = arr[i][j];
                }
                }

                results[i] = largestNumber;
                
            }               
            return results;
        }

算法基础：检查字符串的结尾

检查一个字符串（第一个参数， str）是否以给定的字符串（第二个参数 target）结束。

本题目可以用 ES2015 引入的 .endsWith()方法来解决。但本挑战的目的是让你使用 JavaScript 的一个 substring 方法。

function confirmEnding(str, target) {
  // "Never give up and good luck will find you."
  // -- Falcor
  return str.endsWith(target);
}

confirmEnding("Bastian", "n");

function confirmEnding(str, target) {
  // "Never give up and good luck will find you."
  // -- Falcor
  
  return str.slice(str.length - target.length) === target;
}

confirmEnding("He has to give me a new name", "name");

重复字符串

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

function repeatStringNumTimes(str, num) {
  var accumulatedStr = '';

  while (num > 0) {
    accumulatedStr += str;
    num--;
  }

  return accumulatedStr;
}

截断字符串

如果一个字符串（第一个参数）的长度大于给出的值（第二个参数），则截断它并在其后加上 …。返回被截断的字符串。

function truncateString(str, num) {
  // Clear out that junk in your trunk
  if (str.length > num && num > 3) {
    return str.slice(0, num) + '...';
  } else if (str.length > num && num <= 3) {
    return str.slice(0, num) + '...';
  } else {
    return str;
  }

}

truncateString("A-tisket a-tasket A green and yellow basket", 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…”。

发现者与看护者

请写一个函数来检查一个数组（第一个参数）中的元素，并返回数组中第一个通过校验测试（第二个参数，一个接受一个参数并返回一个布尔值的函数）的元素。如果没有元素通过测试，则返回 undefined。

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

真假测试

检查一个值是否是原始的布尔值（boolean）类型。返回 true 或者 false。

布尔值原始类型为 true 或者 false。

function booWho(bool) {
  // What is the new fad diet for ghost developers? The Boolean.
  return typeof bool === 'boolean';
}

booWho(null);

单词的首字母大写

将给出的字符串中所有单词的第一个字母变成大写，并返回得到的字符串。请确保其余的字母是小写的。

出于练习的目的，“ the ”“ of ”等虚词的首字母也要大写。

function titleCase(str) {
  let newArr = str.toLowerCase().split(' ');
  for(let i=0;i<newArr.length;i++){
    newArr[i] = newArr[i].slice(0,1).toUpperCase() + newArr[i].slice(1);
  }
  return newArr.join(' ');
}

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

function titleCase(str) {
  return str.toLowerCase().replace(/(^|\s)\S/g, (L) => L.toUpperCase());
}

slice 和 splice

本挑战的输入参数为：两个数组和一个索引值。

请利用数组的 slice和 splice方法，将第一个数组中的所有元素依次复制到第二个数组中。

请从第二个数组中索引值为 n的地方开始插入。

返回插入元素后的数组。输入的两个数组在函数执行前后要保持不变。

function frankenSplice(arr1, arr2, n) {
  // It's alive. It's alive!
  let newArr = arr2.slice();
  for(let i=0; i<arr1.length; i++){
    newArr.splice(n, 0, arr1[i]);
    n++;
  }
  return newArr;
}

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

去除数组中的假值

从一个数组中移除所有假值（falsy values）。

JavaScript 中的假值有 false、null、0、""、undefined和 NaN。

提示：请尝试将每一个值转换为一个布尔值（boolean）。

function bouncer(arr) {
  // Don't show a false ID to this bouncer.
  return arr.filter(Boolean);
}

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）。

function getIndexToIns(arr, num) {
  arr.sort(function(a, b) {
    return a - b;
  });

  for (var a = 0; a < arr.length; a++) {
    if (arr[a] >= num)
      return a;
  }

  return arr.length;
}

集合之间的关系

输入参数是一个有两个字符串元素的数组。如果第一个字符串中包含了第二个字符串中的所有字母，则返回 true。

例如，[“hello”, “Hello”]应该返回 true 因为第一个字符串中包含了第二个字符串中出现的所有字母（忽略大小写）。

而 [“hello”, “hey”]应该返回 false 因为第一个字符串 “hello” 没有包含字母 “y”。

最后，[“Alien”, “line”], 应该返回 true，因为 “line” 中的所有字母都被包含在 “Alien” 中。

function mutation(arr) {
  let newArr1 = arr[0].toLowerCase().split('');
  let newArr2 = arr[1].toLowerCase().split('');
  let len1 = newArr1.length;
  let len2 = newArr2.length;
  for(let i=0;i<len2;i++){
    if(newArr1.indexOf(newArr2[i])== -1){
      return false;
    }
  }
  return true;
}

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

猴子吃香蕉（将一维数组分割为二维数组）

请写一个函数，将一个数组（第一个参数）分割成一组长度为 size（第二个参数）的数组，然后在一个二维数组中返回这些结果。

function chunkArrayInGroups(arr, size) {

  var temp = [];
  var result = [];

  for (var a = 0; a < arr.length; a++) {
    if (a % size !== size - 1)
      temp.push(arr[a]);
    else {
      temp.push(arr[a]);
      result.push(temp);
      temp = [];
    }
  }

  if (temp.length !== 0)
    result.push(temp);
  return result;
}

function chunkArrayInGroups(arr, size) {
  // Break it up.
  var arr2 = [];
  for (var i = 0; i < arr.length; i+=size) {
	arr2.push(arr.slice(i , i+size));
  }
  return arr2;
}

function chunkArrayInGroups(arr, size) {
      // Break it up.
      var newArr = [];
      var i = 0;

      while (i < arr.length) {
        newArr.push(arr.slice(i, i+size));
        i += size;
      }
      return newArr;
    }
    chunkArrayInGroups(["a", "b", "c", "d"], 2);

function chunkArrayInGroups(arr, size) {
	if (arr.length <= size){
		return [arr];
	}
	else {
		return [arr.slice(0,size)].concat(chunkArrayInGroups(arr.slice(size),size));
	}
}