美文网首页
FreeCodeCamp--中级算法记录

FreeCodeCamp--中级算法记录

作者: 爱吃的根号三 | 来源:发表于2017-08-21 10:51 被阅读54次

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

    相关文章

      网友评论

          本文标题:FreeCodeCamp--中级算法记录

          本文链接:https://www.haomeiwen.com/subject/yqktdxtx.html