FCC 2.算法和数据结构 2. 6 算法基础

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

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

字符串的 split( ) : 把字符串分割为子字符串数组
arr.reverse（ ）反转数组
arr.join （ ） 将数组合并成为字符串，以（ ） 分隔。

返回一个给定整数的阶乘。
若 n 是一个整数，n 的阶乘就是所有小于等于 n 的正整数的乘积。
n 的阶乘通常用符号 n! 来表示。
例如： 5! = 1 * 2 * 3 * 4 * 5 = 120
只有非负整数会被作为函数的输入参数。
如果你有任何疑问，可以访问 Read-Search-Ask 。请你独立解决挑战中的问题。

function factorialize(num) {
for(var i = 1,jc = 1;i <= num;i++){
    jc *= i;
  }
  return jc;
}
factorialize(5);

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

function findLongestWordLength(str) {
let arrStr = [];
arrStr = str.split(' ') ;
let max=0;
for(let i = 0 ; i < arrStr.length ; i++)
{
if(arrStr[i].length > max) max=arrStr[i].length; 
}
return max;
}
 
function findLongestWordLength(str) {
return str.split(' ').reduce(function(x,y){
return Math.max(x,y.length);
},0);
}


// 第2步使用reduce方法，取到str.Split数组中最长的元素的length，并且返回
// reduce( function , 0); 0表示从数组arr[0]开始。起始位置
/*function(x,y) x表示最后需要的值max , y 代表的是数组每一项 */
// reduce( )不改变原始数组，从左到右工作；每个数组元素上运行函数，返回单个值；一般做累加操作。
findLongestWordLength("The quick brown fox jumped over the lazy dog");

function largestOfFour(arr) {
// You can do this!
var arr2 = [];
for(var i=0;i<arr.length;i++){
for(var j=0;j<arr[i].length;j++){
if(arr[i][j]>arr[i][0]){
arr[i][0]=arr[i][j];
}
}
arr2.push(arr[i][0]);
}
return arr2;
}
 
largestOfFour([[4, 5, 1, 3], [13, 27, 18, 26], [32, 35, 37, 39], [1000, 1001, 857, 1]]);

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

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

function repeatStringNumTimes(str, num) {
let newStr="";
if(num<=0) return ""; 
while(num--){
newStr=newStr.concat(str);
}
// repeat after me
// return str.repeat(num);
console.log(newStr);
return newStr;
}

repeatStringNumTimes(“abc”, 3);
concat() 方法用于连接两个或多个字符串。
该方法没有改变原有字符串，但是会返回连接两个或多个字符串新字符串。

function truncateString(str, num) {
// Clear out that junk in your trunk
if(str.length>num){
str=str.substr(0,num)+"...";
}
return str;
}
truncateString("A-tisket a-tasket A green and yellow basket", 8);

• str.substr(start[, length]) 抽取指定数目的字符：
• str.substring(start

请写一个函数来检查一个数组（第一个参数）中的元素，并返回数组中第一个通过校验测试（第二个参数，一个接受一个参数并返回一个布尔值的函数）的元素。如果没有元素通过测试，则返回 undefined。
如果你有任何疑问，可以访问 Read-Search-Ask 。你可以与他人结对编程。请你独立解决挑战中的问题

function findElement(arr, func) {
	let num = 0;
		for(var i = 0; i < arr.length; i++) {
			num = arr[i];
			if (func(num)) {
				return num;
			}
		}
}
findElement([1, 2, 3, 4], num => num % 2 === 0);

检查一个值是否是原始的布尔值（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(' ');
// return str;
// return str.toLowerCase().replace(/(^|\s)\S/g, (L) => L.toUpperCase());
}
titleCase("I'm a little tea pot");

本挑战的输入参数为：两个数组和一个索引值。
请利用数组的 slice 和 splice 方法，将第一个数组中的所有元素依次复制到第二个数组中。
请从第二个数组中索引值为 n 的地方开始插入。
返回插入元素后的数组。输入的两个数组在函数执行前后要保持不变。
slice()
选取数组的一部分，并返回一个新数组。
splice()
从数组中添加或删除元素。这种方法会改变原始数组。

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

function bouncer(arr) {
// Don't show a false ID to this bouncer.
    return arr.filter(Boolean);
}
bouncer([7, "ate", "", false, 9]);

filter() 方法创建一个新的数组，新数组中的元素是通过检查指定数组中符合条件的所有元素。
注意： filter() 不会对空数组进行检测。
注意： filter() 不会改变原始数组。

返回数组（第一个参数）被排序后，将一个值（第二个参数）插入到该数组中而使数组保持有序的最小的索引。返回的值应该是一个数字。
例如，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) {
// Find my place in this sorted array.
arr.sort(function(a,b){return a-b});
for(let i=0; i<arr.length; i++){
if(arr[i]>=num) return i;
}
return arr.length;
}
console.log(getIndexToIns([5, 3, 20, 3], 5));

sort() 方法用于对数组的元素进行排序。
排序顺序可以是字母或数字，并按升序或降序。
默认排序顺序为按字母升序。
注意：当数字是按字母顺序排列时"40"将排在"5"前面。
使用数字排序，你必须通过一个函数作为参数来调用。
函数指定数字是按照升序还是降序排列。

输入参数是一个有两个字符串元素的数组。如果第一个字符串中包含了第二个字符串中的所有字母，则返回 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"]);

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;
}
chunkArrayInGroups(["a", "b", "c", "d"], 2);