FreeCodeCamp 中级算法记录

最新推荐文章于 2021-05-19 16:37:59 发布

weixin_33889245

最新推荐文章于 2021-05-19 16:37:59 发布

阅读量163

点赞数

原文链接：https://juejin.im/post/5a31d58cf265da4327183cae

版权

##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);
复制代码

转载于:https://juejin.im/post/5a31d58cf265da4327183cae

weixin_33889245

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
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;...
复制链接

扫一扫