FreeCodeCamp 中級演算法記錄

##1.Sum All Numbers in a Range 一個陣列。返回最大最小的兩個數字和它們之間所有數字的和。

function sumAll(arr) {
  var max = Math.max.apply(this,arr);
  var min = Math.min.apply(this,arr);
  var sum=0;
  for(var i = min;i<=max;i++){
    sum +=i;
}
 return sum;
}

sumAll([1, 4]);
複製程式碼

##2.Diff Two Arrays 比較兩個陣列，然後返回一個新陣列，該陣列的元素為兩個給定陣列中所有獨有的陣列元素

function diff(arr1, arr2) {
  var newArr = [],arr3=[];
  newArr = arr1.filter(function(value){
      return arr2.indexOf(value)>=0;
  });console.log(newArr);
  arr3  = arr1.concat(arr2);
  newArr = arr3.filter(function(value){
      return newArr.indexOf(value)<0;
  });
  return newArr;
}
複製程式碼

##3.Roman Numeral Converter 將給定的數字轉換成羅馬數字。 所有返回的 羅馬數字 都應該是大寫形式。

function convert(num) {
  const romanNum = [1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1],
        roman = ["M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"];
  let i = 0,
      str = "";
  while (num > 0) {
    if (num < romanNum[i]) {
        i++;
    } else {
        str += roman[i];
        num -= romanNum[i];
    }
}
return str;
}

convert(36);
複製程式碼

###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 sourceKeys = Object.keys(source),
      arr = [];
  collection.forEach(function(obj) {
      for (var i = 0; i < sourceKeys.length; i++) {
          if (!obj.hasOwnProperty(sourceKeys[i])) {
              return false;
          } else {
              if (source[sourceKeys[i]] !== obj[sourceKeys[i]]) {
                  return false;
              }
          }
      }
    arr.push(obj);
  }, this);

  return arr;
}

where([{ first: "Romeo", last: "Montague" }, { first: "Mercutio", last: null }, { first: "Tybalt", last: "Capulet" }], { last: "Capulet" });
複製程式碼

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

function myReplace(str, before, after) {
    if (/[A-Z]/.test(before[0])) {
        after = after[0].toUpperCase() + after.slice(1);
    }
    return str.replace(before, after);
}

myReplace("A quick brown fox jumped over the lazy dog", "jumped", "leaped");
複製程式碼

###6.Pig Latin 把一個英文單詞的第一個子音或子音叢（consonant cluster）移到詞尾，然後加上字尾 "ay"。 如果單詞以母音開始，你只需要在詞尾新增 "way" 就可以了。

function translate(str) {
    var i = 0,
        newStr = '';
    if (/[aeiou]/.test(str[0])) {
        str += "way";
    } else {
        while (i < str.length) {
            if (/[aeiou]/.test(str[i])) {
               return str.substr(i) + str.substr(0, i) + "ay";
            } else {
                i++;
            }
        }
    }
    return str;
}

translate("consonant");
複製程式碼

###7.DNA Pairing 在每一個陣列中將給定的字母作為第一個鹼基返回。 例如，對於輸入的 GCG，相應地返回 [["G", "C"], ["C","G"],["G", "C"]] 字母和與之配對的字母在一個陣列內，然後所有陣列再被組織起來封裝進一個陣列。

function pair(str) {
    var pairs = [],
        DNA = {
            A: "T",
            T: "A",
            C: "G",
            G: "C"
        },
        dnaArr = str.split("");
    dnaArr.forEach(function(item) {
        var newArr = [item];newArr.push(DNA[item]);
        pairs.push(newArr);
    });
    return pairs;
}

pair("GCG");
複製程式碼

###8.Missing letters 從傳遞進來的字母序列中找到缺失的字母並返回它。 如果所有字母都在序列中，返回 undefined。

function fearNotLetter(str) {
    var length = str.length,
        first = str.charCodeAt(0),
        last = str.charCodeAt(length - 1),
        newStr = "";
    if (last - first === length - 1) {
        newStr = undefined;
    } else {
        for (var i = 1; i < last - first; i++) {
            console.log(str.charCodeAt(i) - str.charCodeAt(i - 1));
            if (str.charCodeAt(i) - str.charCodeAt(i - 1) !== 1) {
                newStr = String.fromCharCode(str.charCodeAt(i) - 1);
            }
        }
    }
    return newStr;
}

fearNotLetter("abce");
複製程式碼

###9.Boo who 檢查一個值是否是基本布林型別，並返回 true 或 false。 基本布林型別即 true 和 false。

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

boo(null);
複製程式碼

###10.Sorted Union 寫一個 function，傳入兩個或兩個以上的陣列，返回一個以給定的原始陣列排序的不包含重複值的新陣列。 換句話說，所有陣列中的所有值都應該以原始順序被包含在內，但是在最終的陣列中不包含重複值。 非重複的數字應該以它們原始的順序排序，但最終的陣列不應該以數字順序排序。

function unite(arg) {
    let arr = Array.prototype.slice.call(arguments); 
    let newArr = arr.reduce(function(a,b){
        return a.concat(b);
    },[]);
    let newArr2= []
    for(let i=0;i<newArr.length;i++){
        if(newArr2.indexOf(newArr[i])<0){
            newArr2.push(newArr[i]);
        }
    }
    return newArr2;
  }

  unite([1, 3, 2], [5, 2, 1, 4], [2, 1]);
複製程式碼

###11.Convert HTML Entities 將字串中的字元 &、<、>、" （雙引號）, 以及 ' （單引號）轉換為它們對應的 HTML 實體。

function convert(str) {
    return str.replace(/[&<>"']/g, function($0) {
        return "&" + {"&":"amp", "<":"lt", ">":"gt", '"':"quot", "'":"apos"}[$0] + ";";
    });
}
複製程式碼

###12.Spinal Tap Case 將字串轉換為 spinal case。Spinal case 是 all-lowercase-words-joined-by-dashes 這種形式的，也就是以連字元連線所有小寫單詞。

function spinalCase(str) {
    return str.replace(/([A-Z])/g," $1")
              .replace(/^\s/,"")
              .replace(/[_]/g," ")
              .replace(/\s+/g,"-")
              .toLowerCase();
  }

  spinalCase('This Is Spinal Tap');
複製程式碼

###13.Sum All Odd Fibonacci Numbers 給一個正整數num，返回小於或等於num的斐波納契奇數之和。 斐波納契數列中的前幾個數字是 1、1、2、3、5 和 8，隨後的每一個數字都是前兩個數字之和。 例如，sumFibs(4)應該返回 5，因為斐波納契數列中所有小於4的奇數是 1、1、3。 提示：此題不能用遞迴來實現斐波納契數列。因為當num較大時，記憶體會溢位，推薦用陣列來實現。

  function sumFibs(num) {
    var fib = [1,1],
    sum = 2;
    while(true){
        var item = fib[0] + fib[1]; 
        if(item>num){
            return sum;
        }
        if(item % 2){
            sum += item;
        }
        fib[0] = fib[1];
        fib[1] = item;
   }
}

  sumFibs(4);
複製程式碼

###14.Sum All Primes 求小於等於給定數值的質數之和。

function sumPrimes(num) {
    let arr= [2],sum=2;
    if(num<=2){
        return num;
    }
    for(var i=3;i<=num;i++){
        if(arr.every(item => i%item !=0)){
            arr.push(i);
            sum+=i;
        }
    }
    return sum;
  }

  sumPrimes(10);
複製程式碼

###15.Smallest Common Multiple 找出能被兩個給定引數和它們之間的連續數字整除的最小公倍數。 範圍是兩個數字構成的陣列，兩個數字不一定按數字順序排序。 例如對 1 和 3 —— 找出能被 1 和 3 和它們之間所有數字整除的最小公倍數。

function smallestCommons(arr) {
    let min = Math.min.apply(this,arr),
        max = Math.max.apply(this,arr),
        val=min;
    for(let i= min;i<=max;i++){
        sum *=i/gcd(val,i);
    }
    return sum;
}

function gcd(a,b) {
    if(a%b){
        return gcd(b,a%b);
    }else{
      return b;
    }
}

smallestCommons([1,5]);
複製程式碼

###16.Finders Keepers 寫一個 function，它遍歷陣列 arr，並返回陣列中第一個滿足 func 返回值的元素。舉個例子，如果 arr 為 [1, 2, 3]，func 為 function(num) {return num === 2; }，那麼 find 的返回值應為 2。

function find(arr, func) {
    return arr.find(func);
  }

find([1, 2, 3, 4], function(num){ return num % 2 === 0; });
複製程式碼

###17.Drop it

function drop(arr, func) {
    // Drop them elements.
    while(arr.length>0 && !(func.call(this,arr[0]))){
        arr.shift();
    }
    return arr;
  }

  drop([1, 2, 3], function(n) {return n < 3; });
複製程式碼

###18.Steamroller 對巢狀的陣列進行扁平化處理。你必須考慮到不同層級的巢狀。

function steamroller(arr) {
  // I'm a steamroller, baby 
  var result = [];
  for(var i = 0; i < arr.length; i++){
    if(Array.isArray(arr[i])){
      result = result.concat(steamroller(arr[i]));
    }else{
      result.push(arr[i]);
    }
  }
  return result;
}

steamroller([1, [2], [3, [[4]]]]);
複製程式碼

###19.Binary Agents 傳入二進位制字串，翻譯成英語句子並返回。

function binaryAgent(str) {
    let arr = str.split(" ");
    let newArr = arr.map((x) =>{
        return parseInt(x,2);
    })
    return String.fromCharCode.apply(this,newArr);
}

 binaryAgent("01000001 01110010 01100101 01101110 00100111 01110100 00100000 01100010 01101111 01101110 01100110 01101001 01110010 01100101 01110011 00100000 01100110 01110101 01101110 00100001 00111111");
複製程式碼

###20.Everything Be True 完善編輯器中的every函式，如果集合(collection)中的所有物件都存在對應的屬性(pre)，並且屬性(pre)對應的值為真。函式返回ture。反之，返回false。

function every(collection, pre) {
    // Is everyone being true?
    return collection.every((x) =>{
        return x[pre];
    })
  }

every([{"user": "Tinky-Winky", "sex": "male"}, {"user": "Dipsy", "sex": "male"}, {"user": "Laa-Laa", "sex": "female"}, {"user": "Po", "sex": "female"}], "sex");
複製程式碼

###21.Arguments Optional 建立一個計算兩個引數之和的 function。如果只有一個引數，則返回一個 function，該 function 請求一個引數然後返回求和的結果。

例如，add(2, 3) 應該返回 5，而 add(2) 應該返回一個 function。 呼叫這個有一個引數的返回的 function，返回求和的結果： var sumTwoAnd = add(2); sumwoAnd(3) 返回 5。

如果兩個引數都不是有效的數字，則返回 undefined。

function add() {
  let arg = Array.prototype.slice.call(arguments),
    result = arg.every((x) => {
      return Number.isFinite(x);
    });
  if (result) {
    if (arg.length === 2) {
      return arg[0] + arg[1];
    } else {
      var a = arg[0];
      return function (b) {
        if (Number.isFinite(b)) {
          return a + b;
        } else {
          return undefined;
        }
      }
    }
  } else {
    return undefined;
  }
}
add(2, 3);
複製程式碼