【freeCodeCamp】 Intermediate Algorithm Scripting

1. Sum All Numbers in a Range

我们会传递给你一个包含两个数字的数组。返回这两个数字和它们之间所有数字的和。最小的数字并非总在最前面。

function sumAll(arr) {
  var sum = 0;
  arr.sort(function(a,b){
    return a-b;
  });
  for(var i=arr[0];i<=arr[1];i++){
    sum += i;
  }
  return sum;
}

sumAll([1, 4]);    // 10

2. Diff Two Arrays 

比较两个数组，然后返回一个新数组，该数组的元素为两个给定数组中所有独有的数组元素。换言之，返回两个数组的差异。

function diff(arr1, arr2) {
  var newArr1 = arr1.filter(function(item){
    return arr2.indexOf(item) == -1;
  });
  var newArr2 = arr2.filter(function(item){
    return arr1.indexOf(item) == -1;
  });
  return newArr1.concat(newArr2);
}

diff([1, 2, 3, 5], [1, 2, 3, 4, 5]);  // [4]

3. Roman Numeral Converter

将给定的数字转换成罗马数字。所有返回的 罗马数字 都应该是大写形式。

function convert(num) {
  var str = '';
  var nums = [1000,900,500,400,100,90,50,40,10,9,5,4,1];
  var romans =["m","cm","d","cd","c","xc","l","xl","x","ix","v","iv","i"];
  nums.forEach(function(item,index){
    while(num>=item){
      str += romans[index];
      num -= item;
    }
  });
  return str.toUpperCase();
}

convert(36);  // XXXVI

4. Where art thou 

写一个 function，它遍历一个对象数组（第一个参数）并返回一个包含相匹配的属性-值对（第二个参数）的所有对象的数组。如果返回的数组中包含 source 对象的属性-值对，那么此对象的每一个属性-值对都必须存在于 collection 的对象中。

例如，如果第一个参数是 [{ first: "Romeo", last: "Montague" }, { first: "Mercutio", last: null }, { first: "Tybalt", last: "Capulet" }]，第二个参数是 { last: "Capulet" }，那么你必须从数组（第一个参数）返回其中的第三个对象，因为它包含了作为第二个参数传递的属性-值对。

function where(collection, source) {
  var arr = [];
  var obj = {};
  for(var i=0;i<collection.length;i++){
    var flag = true;
    for(var key in source){
      if(collection[i].hasOwnProperty(key) && source[key] === collection[i][key]){
        continue;
      } else {
        flag = false;
      }
    }
    if(flag){
      arr.push(collection[i]);
    }
  }
  return arr;
}

where([{ first: "Romeo", last: "Montague" }, { first: "Mercutio", last: null }, { first: "Tybalt", last: "Capulet" }], { last: "Capulet" });    // [{ first: "Tybalt", last: "Capulet" }]

5. Search and Replace

使用给定的参数对句子执行一次查找和替换，然后返回新句子。

第一个参数是将要对其执行查找和替换的句子。第二个参数是将被替换掉的单词（替换前的单词）。第三个参数用于替换第二个参数（替换后的单词）。注意：替换时保持原单词的大小写。例如，如果你想用单词 "dog" 替换单词 "Book" ，你应该替换成 "Dog"。

function myReplace(str, before, after) {
  var reg = /[A-Z]/;
  after =  reg.test(before.slice(0,1)) ? after.slice(0,1).toUpperCase().concat(after.slice(1)) : after;
  return str.split(before).join(after);
}

myReplace("A quick brown fox jumped over the lazy dog", "jumped", "leaped");    // A quick brown fox leaped over the lazy dog

6. Pig Latin 

把指定的字符串翻译成 pig latin。

Pig Latin 把一个英文单词的第一个辅音或辅音丛（consonant cluster）移到词尾，然后加上后缀 "ay"。如果单词以元音开始，你只需要在词尾添加 "way" 就可以了。

function translate(str) {
  var arr = ['a','e','i','o','u'];
  if(arr.indexOf(str[0]) != -1){
    return str + 'way';
  }
  while(arr.indexOf(str[0]) == -1){
    str = str.slice(1) + str.slice(0,1);
  }
  return str + 'ay';
}

translate("paragraphs");  // aragraphspay

7. DNA Pairing

DNA 链缺少配对的碱基。依据每一个碱基，为其找到配对的碱基，然后将结果作为第二个数组返回。

Base pairs（碱基对） 是一对 AT 和 CG，为给定的字母匹配缺失的碱基。在每一个数组中将给定的字母作为第一个碱基返回。

例如，对于输入的 GCG，相应地返回 [["G", "C"], ["C","G"],["G", "C"]]

字母和与之配对的字母在一个数组内，然后所有数组再被组织起来封装进一个数组。

function pair(str) {
  var result = [];
  for(var i=0;i<str.length;i++){
    var arr = [str[i]];
    switch(str[i]){
      case 'T':arr.push('A');break;
      case 'A':arr.push('T');break;
      case 'G':arr.push('C');break;
      case 'C':arr.push('G');break;  
      default:break; 
    }
    result.push(arr);
  }
  return result;
}

pair("GCG");  // [["G", "C"], ["C","G"],["G", "C"]]

8. Missing letters

从传递进来的字母序列中找到缺失的字母并返回它。

如果所有字母都在序列中，返回 undefined。

function fearNotLetter(str) {
  str = str.split('').sort().join('');
  var code = str.charCodeAt(0);
  var newStr = '';
  while(code<str.charCodeAt(str.length-1)){
    var a = String.fromCharCode(code);
    if(str.indexOf(a) == -1){
      newStr += a;
    }
    code++;
  }
  if(newStr.length === 0){
    return undefined;
  }
  return newStr;
}

fearNotLetter("abce");  // d

9. Boo who

检查一个值是否是基本布尔类型，并返回 true 或 false。基本布尔类型即 true 和 false。

function boo(bool) {
  if(bool === true || bool === false){
    return true;
  }
  return false;
}

boo(null);  // false

10. Sorted Union

写一个 function，传入两个或两个以上的数组，返回一个以给定的原始数组排序的不包含重复值的新数组。

换句话说，所有数组中的所有值都应该以原始顺序被包含在内，但是在最终的数组中不包含重复值。

非重复的数字应该以它们原始的顺序排序，但最终的数组不应该以数字顺序排序。

function unite(arr1, arr2, arr3) {
  var newArr = arr3 == undefined ? arr1.concat(arr2) : arr1.concat(arr2,arr3,...arguments);
  return [...new Set(newArr)];
}

unite([1, 2, 3], [5, 2, 1]);    // [1, 2, 3, 5]
unite([1, 2, 3], [5, 2, 1, 4], [2, 1], [6, 7, 8]);  // [1, 2, 3, 5, 4, 6, 7, 8]

11. Convert HTML Entities

将字符串中的字符 &、<、>、" （双引号）, 以及 ' （单引号）转换为它们对应的 HTML 实体。

function convert(str) {
  var arr = str.split('');
  for(var i=0;i<arr.length;i++){
    switch(arr[i]){
      case '<':
        arr[i] = '&lt;';
        break;
      case '>':
        arr[i] = '&gt;';
        break;
      case '&':
        arr[i] = '&amp;';
        break;
      case '"':
        arr[i] = '&quot;';
        break;
      case "'":
        arr[i] = '&apos;';
        break;
      default:break;
    }
  }
  return arr.join('');
}

convert("Dolce & Gabbana");  // Dolce &amp; Gabbana

12. Spinal Tap Case

将字符串转换为 spinal case。Spinal case 是 all-lowercase-words-joined-by-dashes 这种形式的，也就是以连字符连接所有小写单词。

function spinalCase(str) {
  var reg = /\s+|_+/g;
  str = str.replace(/([a-z])([A-Z])/g,'$1 $2');
  return str.replace(reg,'-').toLowerCase();
}

spinalCase('This Is Spinal Tap');  // this-is-spinal-tap