1、區間求值算法（Sum All Numbers in a Range）

我們會傳遞給你一個包含兩個數字的數組。返回這兩個數字和它們之間所有數字的和。
最小的數字并非總在最前面。
對你有幫助的資源:
Math.max() 函數返回一組數中的最大值。
Math.min() 函數返回一組數中的最小值。

//思路：先找出最大值和最小值，循環算和
function sumAll(arr) {
  var sum = 0;
  var min = Math.min(arr[0],arr[1]);
  var max = Math.max(arr[0],arr[1]);
  for(var i = min;i<=max;i++){
    sum+=i;
  }
  return sum;
}
sumAll([1, 4]);

2、找出數組間差異算法（Diff Two Arrays）

比較兩個數組，然后返回一個新數組，該數組的元素為兩個給定數組中所有獨有的數組元素。換言之，返回兩個數組的差異。
對你有幫助的資源:
Array.indexOf() 方法返回在數組中可以找到一個給定元素的第一個索引，如果不存在，則返回-1。
Array.concat() 方法用于合并兩個或多個數組。此方法不會更改現有數組，而是返回一個新數組。

//思路：分別對比兩個數組中的元素，不同的加入新數組中，然后將不同的元素連接成一個新數組
function diff(arr1, arr2) {
  var newArr = [];
  var arr3 = [];  
  for (var i=0;i<arr1.length;i++) {  
    if(arr2.indexOf(arr1[i]) === -1)     //對比
      arr3.push(arr1[i]);  
  }  
   var arr4 = [];  
  for (var j=0;j<arr2.length;j++) {  
    if(arr1.indexOf(arr2[j]) === -1)    //對比
      arr4.push(arr2[j]);  
  }  
   newArr = arr3.concat(arr4);     //連接
  // Same, same; but different.
  return newArr;
}
diff([1, 2, 3, 5], [1, 2, 3, 4, 5]);

3、數字轉羅馬數字（Roman Numeral Converter）

所有返回的 羅馬數字 都應該是大寫形式。
對你有幫助的資源:
Array.prototype.forEach() 方法對數組的每個元素執行一次提供的函數。

//思路：將數字對應的羅馬數字建立對應的數組，將數字數組循環跟要轉化的數字進行對比，找出對應區間對應的羅馬數字
function convert(num) {
 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"];  
  var str = '';  
  nums.forEach(function(item,index,array){    //循環對比要轉化的數字
    while(num >= item){  
      str += romans[index];    //轉化成對應的羅馬數字
      num -= item;  
    }  
  });  
 return str.toUpperCase();   //全部轉化成大寫
}
convert(36);

4、對象搜索算法（Where art thou）

寫一個 function，它遍歷一個對象數組（第一個參數）并返回一個包含相匹配的屬性-值對（第二個參數）的所有對象的數組。如果返回的數組中包含 source 對象的屬性-值對，那么此對象的每一個屬性-值對都必須存在于 collection 的對象中。
例如，如果第一個參數是[{ first: "Romeo", last: "Montague" }, { first: "Mercutio", last: null }, { first: "Tybalt", last: "Capulet" }]，第二個參數是{ last: "Capulet" }，那么你必須從數組（第一個參數）返回其中的第三個對象，因為它包含了作為第二個參數傳遞的屬性-值對。
對你有幫助的資源:
Object.keys() 方法會返回一個由一個給定對象的自身可枚舉屬性組成的數組，數組中屬性名的排列順序和使用 for...in 循環遍歷該對象時返回的順序一致 （兩者的主要區別是 一個 for-in 循環還會枚舉其原型鏈上的屬性）。
語法

function where(collection, source) {
  var arr = [];
  var arrSource=Object.keys(source);//把source的屬性轉化為數組  
  var i='',j=0;
  for(i in collection){//循環collection的元素
    var count=0;
    for(j=0;j<arrSource.length;j++){//針對source的屬性進行循環，查找這個collection元素中是否有指定的source的屬性
      if(collection[i][arrSource[j]]&&source[arrSource[j]]==collection[i][arrSource[j]]){
        count++;
      } 
    }
    //判斷：如果完全包含，這個collection的元素就被允許添加到里邊。
    if(count==arrSource.length){
       arr.push(collection[i]);
    }
  }
  return arr;
}
where([{ first: "Romeo", last: "Montague" }, { first: "Mercutio", last: null }, { first: "Tybalt", last: "Capulet" }], { last: "Capulet" });

5、查詢替換算法(Search and Replace)

使用給定的參數對句子執行一次查找和替換，然后返回新句子。
第一個參數是將要對其執行查找和替換的句子。
第二個參數是將被替換掉的單詞（替換前的單詞）。
第三個參數用于替換第二個參數（替換后的單詞）。
注意：替換時保持原單詞的大小寫。例如，如果你想用單詞 "dog" 替換單詞 "Book" ，你應該替換成 "Dog"。

//思路：確定好了要替換的單詞和原來的單詞之后用replace方法直接替換
function myReplace(str, before, after) {
 if(before[0] === before[0].toUpperCase()){  //如果原單詞大寫，替換的單詞也要大寫
    after = after[0].toUpperCase() + after.slice(1);
  }
  str = str.replace(before,after);  
  return str;
}
myReplace("A quick brown fox jumped over the lazy dog", "jumped", "leaped");

6、字符串移動插入算法（Pig Latin）

把指定的字符串翻譯成 pig latin。
Pig Latin 把一個英文單詞的第一個輔音或輔音叢（consonant cluster）移到詞尾，然后加上后綴 "ay"。
如果單詞以元音開始，你只需要在詞尾添加 "way" 就可以了。
對你有幫助的資源:
String.substr() 方法返回一個字符串中從指定位置開始到指定字符數的字符。

//思路：用indexOf方法判斷元素的第一個字母是不是元音，如果是就直接加way，如果不是就用substr方法截取將第一個字母移到最后再加ay
function translate(str) {
var vowel = ["a", "e", "i", "o", "u"];
if (vowel.indexOf(str[0]) != -1) {
return str + "way";
}
while (vowel.indexOf(str[0]) == -1) {
str = str.substr(1) + str.substr(0, 1);
}
return str + "ay";
}
translate("consonant");

7、字符配對算法（DNA Pairing）

DNA 鏈缺少配對的堿基。依據每一個堿基，為其找到配對的堿基，然后將結果作為第二個數組返回。
Base pairs（堿基對） 是一對 AT 和 CG，為給定的字母匹配缺失的堿基。
在每一個數組中將給定的字母作為第一個堿基返回。
例如，對于輸入的 GCG，相應地返回 [["G", "C"], ["C","G"],["G", "C"]]
字母和與之配對的字母在一個數組內，然后所有數組再被組織起來封裝進一個數組。
對你有幫助的資源:
Array.prototype.map() 方法創建一個新數組，其結果是該數組中的每個元素都調用一個提供的函數后返回的結果。

//思路：將字符串分割成數組，然后將每一個元素進行配對
function pair(str) {
  var arr = str.split("");
    var pair = '';
    var result = arr.map(function(item,index,array){
        switch(item){
            case 'A':
                pair = 'T';
                break;
            case 'T':
                pair = 'A';
                break;
            case 'C': 
                pair = 'G';
                break;
            case 'G':
                pair = 'C';
                break;
        }
        return [item,pair];
    });
    return result;
}
pair("GCG");

8、字符串查詢補充算法（）

從傳遞進來的字母序列中找到缺失的字母并返回它。
如果所有字母都在序列中，返回 undefined。

/*思路：
（1）如果傳進來的不是一個按順序來的字母隊列，需要給他轉成鍵碼，排序，再轉化為字符串。這段是題目之外的要求。
（2）接下來查找字符串排序后在a-z中的索引，然后根據索引用substring切割出來，用以比較（strCompare）
（3）遍歷這個數組，找到沒有的，*/
function fearNotLetter(str) {
var arrCover=[];
  for(var i=0;i<str.length;i++){
    arrCover.push(str[i].charCodeAt());
  }//轉化為鍵碼
  arrCover.sort(function(a,b){
    return a-b;
  });//重新排序
  str='';//清空
  for(i=0;i<arrCover.length;i++){
    str+=(String.fromCharCode(arrCover[i]));
  }//把轉化出來的數組重新給字符串
  //獲取索引
  var strAll='abcdefghijklmnopqrstuvwxyz';
  var indexOver=strAll.indexOf(str.charAt(str.length-1));
  var indexStart=strAll.indexOf(str.charAt(0));
  //切割出用以比較的字符串
  var strCompare=strAll.substring(indexStart,indexOver+1);
  var newStr='';
  if(strCompare==str){
    return undefined;
  }
  for(i=0;i<strCompare.length;i++){
    if(str.indexOf(strCompare[i])==-1){
      newStr+=strAll[i];
    }
  }
  console.log(newStr);
  return newStr;
}
fearNotLetter("abce");

9、輸入檢查算法（Boo who）

檢查一個值是否是基本布爾類型，并返回 true 或 false。

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

10、數組去重算法（Sorted Union）

寫一個 function，傳入兩個或兩個以上的數組，返回一個以給定的原始數組排序的不包含重復值的新數組。
換句話說，所有數組中的所有值都應該以原始順序被包含在內，但是在最終的數組中不包含重復值。
非重復的數字應該以它們原始的順序排序，但最終的數組不應該以數字順序排序。
這是一些對你有幫助的資源:
Arguments object

//思路：循環逐個進行對比，符合條件的放入數組中
function unite(arr1, arr2, arr3) {
var newArr=[];
  for(var i=1;i<arguments.length;i++){
    for(var j=0;j<arguments[i].length;j++){
      if(arguments[0].indexOf(arguments[i][j])==-1){
        newArr.push(arguments[i][j]);
      }
    }
  }
  newArr=arguments[0].concat(newArr);
  console.log(newArr);
  return newArr;
}
unite([1, 3, 2], [5, 2, 1, 4], [2, 1]);

11、html符號轉實體算法（Convert HTML Entities）

將字符串中的字符&、<、>、"（雙引號）, 以及'（單引號）轉換為它們對應的 HTML 實體。
對你有幫助的資源:
HTML Entities

//思路：將數組分割成數組時候，每個元素進行檢查，如果是符號就轉化成相應的實體
function convert(str) {
  var i=0;
  var arr=str.split("");
  for(i=0;i<arr.length;i++){
    switch(arr[i]){
      case '&':
        arr.splice(i,1,'&amp;');
        break;
      case '>':
        arr.splice(i,1,'&gt;');
        break;
      case '<':
        arr.splice(i,1,'&lt;');
        break;
      case "'":
        arr.splice(i,1,'&apos;');
        break;
      case '"':
        arr.splice(i,1,'&quot;');
        break;
    }
  }
  str=arr.join('');
  return str;
}
convert("Dolce & Gabbana");

12、字符串連接算法（Spinal Tap Case）

將字符串轉換為 spinal case。Spinal case 是 all-lowercase-words-joined-by-dashes 這種形式的，也就是以連字符連接所有小寫單詞。

function spinalCase(str) {
str=str.replace(/([A-Z]+)/g,' $1');//在大寫字母前面加個空格。用$來選擇小括號  
  str=str.replace(/\s+|_+/g,'-');//空格全部替換為- 
  if(str[0]=='-'){
    str=str.substring(1);
  }//去掉可能大寫開頭前面的-
  str=str.replace(/--/g,'-');//把中段的--（兩個）替換為一個-。(因為下劃線+大寫導致生成了兩個-)
  str=str.toLowerCase();//轉換小寫
rn str;
}
spinalCase('This Is Spinal Tap')
spinalCase("This Is Spinal Tap") 應該返回 "this-is-spinal-tap"。
spinalCase("thisIsSpinalTap") 應該返回 "this-is-spinal-tap"。
spinalCase("The_Andy_Griffith_Show") 應該返回 "the-andy-griffith-show"。
spinalCase("Teletubbies say Eh-oh") 應該返回 "teletubbies-say-eh-oh"。

13、斐波納契奇數求和算法(Sum All Odd Fibonacci Numbers)

給一個正整數num，返回小于或等于num的斐波納契奇數之和。
斐波納契數列中的前幾個數字是 1、1、2、3、5 和 8，隨后的每一個數字都是前兩個數字之和。
例如，sumFibs(4)應該返回 5，因為斐波納契數列中所有小于4的奇數是 1、1、3。
提示：此題不能用遞歸來實現斐波納契數列。因為當num
較大時，內存會溢出，推薦用數組來實現。
參考文檔：博客園，Issue

function sumFibs(num) {
var fibo = [1, 1];  //定義數組，存放奇數1
  var oddSum = 2;  //定義固定和為2
  while(true){
    var item = fibo[0] + fibo[1];   //
    if(num < item){  //當數字小于2的時候，直接返回2
      return oddSum;
    }
    if(item % 2){   //算奇數，算和
      oddSum += item;    
    }
    fibo[0] = fibo[1];
    fibo[1] = item;
  }
}
sumFibs(4);

15、質素求和算法(Sum All Primes)

求小于等于給定數值的質數之和。
只有 1 和它本身兩個約數的數叫質數。例如，2 是質數，因為它只能被 1 和 2 整除。1 不是質數，因為它只能被自身整除。
給定的數不一定是質數。

function sumPrimes(num) {
var arr=[2];
  var sum=0;
  for(var i=2;i<=num;i++){
    var bCheck=true;//假定為真
    for(var j=0;j<arr.length;j++){//循環數組
      if(i%arr[j]==0){//如果可以被質數整除
        bCheck=false;//判定為false
        break;//退出循環，用不著繼續判斷了。
      }
    }
    if(bCheck){
      arr.push(i);
    }
  }
  console.log(arr);
  for(var k=0;k<arr.length;k++){
    sum+=arr[k];
  }//求和
  return sum;
}
sumPrimes(10);

16、最小公倍數算法（Smallest Common Multiple）

找出能被兩個給定參數和它們之間的連續數字整除的最小公倍數。
范圍是兩個數字構成的數組，兩個數字不一定按數字順序排序。
例如對 1 和 3 —— 找出能被 1 和 3 和它們之間所有數字整除的最小公倍數。
如果你被卡住了，記得開大招 Read-Search-Ask 。嘗試與他人結伴編程、編寫你自己的代碼。
對你有幫助的資源:
Smallest Common Multiple

/*思路：
（1）在此之前要了解歐拉算法求最大公約數。
簡單的說，求兩個數的最大公約數，用大數對小數求模，如果能被整除，則小數是這兩個數的最大公約數。
如果不能整除，就用小數對余數再次求模，循環此過程直到返回能除盡的那個除數。就是最大公約數。
比如20和15，用20除以15余數為5，然后用15除以余數5，能夠整除，所以返回出來的除數5為這兩個數的最大公約數。
（2）有了最大公約數，就可以求最小公倍數。
最小公倍數的求法是：彼此之間的乘積除以最大公約數。
因為是求幾個連續自然數之間的公倍數，所以，求出前兩個最小公倍數之后，用這個最小公倍數和下一個值比較。
然后就得出了新的最小公倍數。主要用的是遞歸的思想。*/
function smallestCommons(arr) {
  arr=arr.sort(function(a,b){
    return a-b;
  });
  function fun(m,n){
    if(m%n===0) return n;
    return fun(n,m%n);
  }
  var num=arr[0];
  for(var i=arr[0]+1;i<=arr[1];i++){
    num*=i/fun(num,i);
  }
  return num;
}
smallestCommons([1,5]);

17、數組驗證算法(Finders Keepers)

寫一個 function，它遍歷數組 arr，并返回數組中第一個滿足 func 返回值的元素。
舉個例子，如果 arr 為 [1, 2, 3]，func 為 function(num) {return num === 2; }，那么 find 的返回值應為 2。
find([1, 3, 5, 8, 9, 10], function(num) { return num % 2 === 0; }) 應該返回 8。
find([1, 3, 5, 9], function(num) { return num % 2 === 0; }) 應該返回 undefined。

//思路：這題相比前面的簡單很多了。注意：用break強制跳出循環。
function find(arr, func) {
  var num = 0;
  for(var i=0;i<arr.length;i++){
    if(func(arr[i])===true){
      num=arr[i];
      break;
    }
  }
  if(num===0){
    return undefined;  
  }
  return num;
}
find([1, 2, 3, 4], function(num){ return num % 2 === 0; });

18、數組取值算法（Drop it）

隊友該賣就賣，千萬別舍不得。
當你的隊伍被敵人包圍時，你選擇拯救誰、拋棄誰非常重要，如果選擇錯誤就會造成團滅。
如果是AD或AP，優先拯救。
因為AD和AP是隊伍輸出的核心。
其次應該拯救打野。
因為打野死了對面就可以無所顧慮地打龍。
最后才是輔助或上單。
因為輔助和上單都是肉，死了也不會對團隊造成毀滅性影響，該賣就賣。
但真實中的團戰遠比這要復雜，你的隊伍很可能會被敵人分割成2個或3個部分。
當你救了一個重要的人時，很可能其他隊友也會因此獲救。
舉個例子：
輔助和AD經常是在一起的，打野和中單在一起，上單經常一個人。
你救了AD，輔助也經常因此獲救。
讓我們來丟棄數組(arr)的元素，從左邊開始，直到回調函數return true就停止。
第二個參數，func，是一個函數。用來測試數組的第一個元素，如果返回fasle，就從數組中拋出該元素(注意：此時數組已被改變)，繼續測試數組的第一個元素，如果返回fasle，繼續拋出，直到返回true。
最后返回數組的剩余部分，如果沒有剩余，就返回一個空數組。

//思路：遍歷這個數組，然后用func判斷返回的是布爾值，根據布爾值插入一個占位的字符串‘false’。待循環結束之后用filter過濾掉就行了。
function drop(arr, func) {
  // Drop them elements.
  for(var i=0;i<arr.length;i++){
    if(func(arr[i])===false){
      arr.splice(i,1,'false');
    }else{
      break;
    }
  }
  arr=arr.filter(function(a){
    return a!='false';
  });
  console.log(arr);
  return arr;
}
drop([1, 2, 3], function(n) {return n < 3; });

19、數組簡化算法（Steamroller）

對嵌套的數組進行扁平化處理。你必須考慮到不同層級的嵌套。
steamroller([[["a"]], [["b"]]]) 應該返回 ["a", "b"]。
steamroller([1, [2], [3, [[4]]]]) 應該返回 [1, 2, 3, 4]。
steamroller([1, [], [3, [[4]]]]) 應該返回 [1, 3, 4]。
steamroller([1, {}, [3, [[4]]]]) 應該返回 [1, {}, 3, 4]。

//思路：還是用遞歸的辦法。判斷數組用isArray。算是遞歸方法的簡單實例。
function steamroller(arr) {
  // I'm a steamroller, baby
  var newArr=[];
  function fun(a){
    for(var j=0;j<a.length;j++){
      if(Array.isArray(a[j])===true){
        fun(a[j]);    
      }else{
        newArr.push(a[j]);      
      }
    }
    return newArr;
  }
  fun(arr); 
  console.log(newArr);
  return newArr;
}
steamroller([1, [2], [3, [[4]]]]);

20、二進制轉字符算法（Binary Agents）

傳入二進制字符串，翻譯成英語句子并返回。
二進制字符串是以空格分隔的。

function binaryAgent(str) {
 var arr=str.split(' ');
  var arr10=[];
  var newStr='';
  for(var i=0;i<arr.length;i++){
    arr10.push(parseInt(arr[i],2));
  }
  for(var j=0;j<arr10.length;j++){
    newStr+=String.fromCharCode(arr10[j]);
  }
  return newStr;
}
binaryAgent("01000001 01110010 01100101 01101110 00100111 01110100 00100000 01100010 01101111 01101110 01100110 01101001 01110010 01100101 01110011 00100000 01100110 01110101 01101110 00100001 00111111");

21、數組元素判斷算法(Everything Be True)

所有的東西都是真的！
完善編輯器中的every函數，如果集合(collection)中的所有對象都存在對應的屬性(pre)，并且屬性(pre)對應的值為真。函數返回ture。反之，返回false。
記?。耗阒荒芡ㄟ^中括號來訪問對象的變量屬性(pre)。
提示：你可以有多種實現方式，最簡潔的方式莫過于Array.prototype.every()。

//思路：這個看起來很復雜，其實只要做個json的for-in循環，就可以實現。
function every(collection, pre) {
  var i='';
  var bCheck=true;//假設為真
  for(i in collection){
    if(!collection[i][pre]){
      bCheck=false;
    }
  }
  return bCheck;
}
every([{"user": "Tinky-Winky", "sex": "male"}, {"user": "Dipsy", "sex": "male"}, {"user": "Laa-Laa", "sex": "female"}, {"user": "Po", "sex": "female"}], "sex");

22、函數迭代可選參數算法（Arguments Optional）

創建一個計算兩個參數之和的 function。如果只有一個參數，則返回一個 function，該 function 請求一個參數然后返回求和的結果。
例如，add(2, 3) 應該返回 5，而 add(2) 應該返回一個 function。
調用這個有一個參數的返回的 function，返回求和的結果：
var sumTwoAnd = add(2);
sumTwoAnd(3) 返回 5。
如果兩個參數都不是有效的數字，則返回 undefined。
對你有幫助的資源:
Closures 閉包

/*思路：這個其實就是call()方法。jquery的鏈式操作就是這樣實現的。
函數鏈式操作原理：返回函數本身。當然也可以返回一個別的函數。
function show(str){
    alert(str);
    return show;//關鍵
}
show('abc')('bcd')；
上述代碼將彈出兩個框，abc，和bcd。只要你想，可以無限地寫下去。
你可以返回一個函數，那么下次操作時，得到的就是這個函數。*/
function add(x) {
 if (arguments.length === 1 && typeof x === "number") {
   return function (y) { 
     if (typeof y === "number"){
       return x + y;
     }  
   }; 
 }else {
    if (typeof x !== "number"|| typeof arguments[1] !== "number") {
      return undefined;
    }
    return arguments[0] + arguments[1];
  } 
} 
add(2,3);

寫在最后：有更好的方法歡迎交流(^__)