JavaScript-算法基础

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

function convertToF(celsius) {
      let fahrenheit = (celsius * (9/5)) + 32;
      if ( typeof fahrenheit !== 'undefined' ) {
        return fahrenheit;
      } else {
        return 'fahrenheit not defined';
      }
}
convertToF(30);  //86

翻转字符串

反转给出的字符串，在反转字符串前需要将其切分成字符的数组，结果必须是一个字符串。

function reverseString(str) {
    return str.split("").reverse().join("");
}
reverseString("hello");  //返回 "olleh"

数字的阶乘

返回一个给定整数的阶乘。
若 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);  //120

查找字符串中最长的单词

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

function findLongestWordLength(str) {
    var array = str.split(" ");
    var len = [];
    for(var i = 0; i < array.length; i++) {
        len.push(array[i].length);
    }
    len.sort(function(a, b) {
        return b - a;
    });
    return len[0];
}

参考方法一：

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;
}
findLongestWordLength("The quick brown fox jumped over the lazy dog");  //6

参考方法二：

function findLongestWordLength(str) {
    return str.split(' ').reduce(function(x, y) {
        return Math.max(x, y.length)
    }, 0);
}
findLongestWordLength("The quick brown fox jumped over the lazy dog");

参考方法三：

function findLongestWordLength(str) {
    str = str.split(" ");
    if(str.length == 1) {
        return str[0].length;
    }
    if(str[0].length >= str[1].length) {
        str.splice(1,1);
        return findLongestWordLength(str.join(" "));
    }
    if(str[0].length <= str[1].length) {
        return findLongestWordLength(str.slice(1, str.length).join(" "));
    }
}
findLongestWordLength("The quick brown fox jumped over the lazy dog");

第一行将字符串拆分为单个单词。然后检查是否str只有1个元素，那么这是最长的元素，我们返回它。如果第一个元素的长度大于第二个元素的长度（或等于），删除第二个元素并递归调用该函数。如果第二个元素的长度大于第一个元素，那么删除第一个元素并递归调用该函数。

返回数组中最大的数字

返回一个数组，它要由给出的所有子数组中的最大值组成。

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

function largestOfFour(arr) {
    let newArray = [];
    for(let i = 0; i < arr.length; i++) {
        newArray.push(Math.max(...arr[i]));
    }
    return newArray;
}
largestOfFour([[4, 5, 1, 3], [13, 27, 18, 26], [32, 35, 37, 39], [1000, 1001, 857, 1]]);

参考方法一：

function largestOfFour(arr) {
    var results = [];
    for (var n = 0; n < arr.length; n++) {
        var largestNumber = arr[n][0];
        for (var sb = 1; sb < arr[n].length; sb++) {
            if (arr[n][sb] > largestNumber) {
                largestNumber = arr[n][sb];
            }
        }
        results[n] = largestNumber;
    }
    return results;
}
largestOfFour([[4, 5, 1, 3], [13, 27, 18, 26], [32, 35, 37, 39], [1000, 1001, 857, 1]]);

参考方法二：

function largestOfFour(arr) {
    return arr.map(function(group){
        return group.reduce(function(prev, current) {
            return (current > prev) ? current : prev;
        });
    });
}
largestOfFour([[4, 5, 1, 3], [13, 27, 18, 26], [32, 35, 37, 39], [1000, 1001, 857, 1]]);

参考方法三：

function largestOfFour(arr) {
    return arr.map(Function.apply.bind(Math.max, null));
}
largestOfFour([[4, 5, 1, 3], [13, 27, 18, 26], [32, 35, 37, 39], [1000, 1001, 857, 1]]);

检查字符串的结尾

检查一个字符串（第一个参数， str）是否以给定的字符串（第二个参数 target）结束。
可以用 ES2015 引入的 .endsWith()方法来解决，也可以使用 JavaScript 的一个 substring 方法。

function confirmEnding(str, target) {
    return str.substring(str.length - target.length) == target;
}
confirmEnding("Bastian", "n"); //true
confirmEnding("Congratulation", "on"); //true
confirmEnding("Open sesame", "game");// false

也可以用slice()方法、substr()方法

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

重复字符串

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

function repeatStringNumTimes(str, num) {
    let str2 = "";
    for(let i = num; i > 0; i--){
        str2 += str;
    }
    return str2;
}
repeatStringNumTimes("abc", 3);

参考方法一：

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

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

  return accumulatedStr;
}

参考方法二：

function repeatStringNumTimes(str, num) {
  if(num < 0)
    return "";
  if(num === 1)
    return str;
  else
    return str + repeatStringNumTimes(str, num - 1);
}

参考方法三：

function repeatStringNumTimes(str, num) {
  return num > 0 ? str.repeat(num) : '';;
}

repeatStringNumTimes("abc", 3);

截断字符串

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

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

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

增加条件：
插入到字符串尾部的三个点号也计入字符串的长度。
如果指定的参数num小于或等于3，则添加的三个点号不会计入字符串的长度。

function truncateString(str, num) {
    if(num <= 3){
        return str.slice(0, num) + "...";
    }else if(num >= str.length) {
        return str;
    }else {
        return str.slice(0, num - 3) + "...";
    }
    
}

参考方法一：

function truncateString(str, num) {
  if (str.length > num && num > 3) {
    return str.slice(0, (num - 3)) + '...';
  } else if (str.length > num && num <= 3) {
    return str.slice(0, num) + '...';
  } else {
    return str;
  }
}

参考方法二：

function truncateString(str, num) {
  if (str.length <= num) {
    return str;
  } else {
    return str.slice(0, num > 3 ? num - 3 : num) + '...';
  }
}

检查数组中的元素

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

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

真假值测试

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

function booWho(bool) {
    return typeof bool === 'boolean';
}
booWho(null);  //false
booWho(true); // true

单词的首字母大写

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

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

function titleCase(str) {
    let arr = str.toLowerCase().split(" ").map((item) => item.slice(0,1).toUpperCase() + item.slice(1));
    return arr.join(" ");
}
titleCase("I'm a little tea pot");  //I'm A Little Tea Pot
titleCase("sHoRt AnD sToUt"); // Short And Stout

参考方法一

String.prototype.replaceAt = function(index, character) {
    return this.substr(0, index) + character + this.substr(index+character.length);
};

function titleCase(str) {
    var newTitle = str.split(' ');
    var updatedTitle = [];
    for (var st in newTitle) {
        updatedTitle[st] = newTitle[st].toLowerCase().replaceAt(0, newTitle[st].charAt(0).toUpperCase());
    }
    return updatedTitle.join(' ');
}

参考方法二

function titleCase(str) {
  var convertToArray = str.toLowerCase().split(" ");
  var result = convertToArray.map(function(val){
      return val.replace(val.charAt(0), val.charAt(0).toUpperCase());
  });
  return result.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) {
    let arr = arr2.slice();
    for (let i=0;i<arr1.length; i++) {
        arr.splice(n+i,0,arr1[i]);
    }
    return arr;
}
frankenSplice([1, 2, 3], [4, 5, 6], 1);

去除数组中的假值

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

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

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

function bouncer(arr) {
	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.push(num);
    arr.sort((a,b) => a-b);
    return arr.indexOf(num);
}
getIndexToIns([40, 60], 50);  //1
getIndexToIns([3, 10, 5], 3);  //0

其他参考方法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;
}

其他参考方法2

function getIndexToIns(arr, num) {
  var times = arr.length; 
  var count = 0; 
  for (var i = 0; i < times; i++){
    if(num > arr[i]){ count++; } } 
    return count; 
}
getIndexToIns([40, 60], 50);

其他参考方法3

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

  var i = 0;
  while (num > arr[i]) {
    i++;
  }
  return i;
}
getIndexToIns([40, 60], 50);

其他参考方法4

function getIndexToIns(arr, num) {
  var index = arr.sort((curr, next) => curr > next)
    .findIndex((currNum)=> num <= currNum);
  return index === -1 ? arr.length : index;
}

getIndexToIns([40, 60], 500);

其他参考方法5

function getIndexToIns(arr, num) {
    return arr.concat(num).sort((a,b) => a-b).indexOf(num);
}
getIndexToIns([1,3,4],2);

集合之间的关系

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

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

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

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

function mutation(arr) {
    var arr0 = arr[0].toLowerCase();
    var arr1 = arr[1].toLowerCase().split("");
    for(var i = 0; i < arr1.length; i++) {
        if(arr0.indexOf(arr1[i]) < 0) {
            return false;
        }
    }
    return true;
}
mutation(["hello", "hey"]); //false

其他方法

function mutation(arr) {
  return arr[1].toLowerCase()
    .split('')
    .every(function(letter) {
      return arr[0].toLowerCase()
        .indexOf(letter) != -1;
    });
}

分割数组

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

function chunkArrayInGroups(arr, size) {
    var newArray = [];
    var num = Math.ceil(arr.length/size);
    for(var i = 0; i < num; i++) {
        newArray.push(arr.slice(i * size, (i + 1) * size));
    }
    return newArray;
}
chunkArrayInGroups(["a", "b", "c", "d"], 2);  //[["a", "b"], ["c", "d"]]

chunkArrayInGroups([0, 1, 2, 3, 4, 5, 6], 3); //[[0, 1, 2], [3, 4, 5], [6]]。

参考方法一

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) {
  var arr2 = [];
  for (var i = 0; i < arr.length; i+=size) {
    arr2.push(arr.slice(i , i+size));
  }
  return arr2;
}

参考方法三

function chunkArrayInGroups(arr, size) {
  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) {
  var newArr = [];
  while (arr.length) {
    newArr.push(arr.splice(0,size));
  }
  return newArr;
}

参考方法五

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