FreeCodeCamp部分题目汇总

https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Array
https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Object
https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/String
>>Sum All Numbers in a Range我们会传递给你一个包含两个数字的数组。返回这两个数字和它们之间所有数字的和。最小的数字并非总在最前面。
 

function sumAll(arr) {
   for(var i=Math.min(arr[0],arr[1])+1;i<Math.max(arr[0],arr[1]);i++){
     arr.push(i);
   }
  return arr.reduce((accumulator, currentValue) => accumulator + currentValue);
}
sumAll([1, 4]);

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

function diff(arr1, arr2) {
  var arr=arr1.filter((elem)=>arr2.indexOf(elem)==-1);
  var arr2=arr2.filter((elem)=>arr1.indexOf(elem)==-1);
  return arr.concat(arr2);
}
diff([1, 2, 3, 5], [1, 2, 4, 5]);

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

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

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

function where(collection, source) {
  var arr = [];
  var obj = source;
  for(var i = 0; i < collection.length; i ++){
    var flag = 1;
     for(var j in obj){
       if(!collection[i].hasOwnProperty(j) || collection[i][j] !== obj[j])
         flag = 0;
     }
    if(flag == 1)
      arr.push(collection[i]);
  }
  return arr;
}
where([{ first: "Romeo", last: "Montague" }, { first: "Mercutio", last: null }, { first: "Tybalt", last: "Capulet" }], { last: "Capulet" });

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

function myReplace(str, before, after) {
  var arr = str.split(" ");
  for(var i = 0; i < arr.length; i ++){
    if(arr[i].toLowerCase() == before.toLowerCase()){
        if(arr[i][0]>='A'&&arr[i][0]<='Z'){
          var brr = after.split("");
          brr[0] = brr[0].toUpperCase();
          arr[i] = brr.join("");
        }
      else 
        arr[i]=after;
         
    }
  }
  return arr.join(" ");
}
myReplace("A quick brown fox jumped over the lazy dog", "jumped", "leaped");

>>Binary Agents传入二进制字符串，翻译成英语句子并返回。二进制字符串是以空格分隔的。

function binaryAgent(str) {
  var arr=str.split(" ");
  arr=arr.map(item=>String.fromCharCode(parseInt(item,2)));
  console.log(arr);
  return arr.join("");
}
binaryAgent("01000001 01110010 01100101 01101110 00100111 01110100 00100000 01100010 01101111 01101110 01100110 01101001 01110010 01100101 01110011 00100000 01100110 01110101 01101110 00100001 00111111");

>>Everything Be True所有的东西都是真的！完善编辑器中的every函数，如果集合(collection)中的所有对象都存在对应的属性(pre)，并且属性(pre)对应的值为真。函数返回ture。反之，返回false。记住：你只能通过中括号来访问对象的变量属性(pre)。提示：你可以有多种实现方式，最简洁的方式莫过于Array.prototype.every()。
 

function every(collection, pre) {
  // Is everyone being true?
  return collection.every(item=>item.hasOwnProperty(pre)&&item[pre]);
}
every([{"user": "Tinky-Winky", "sex": "male"}, {"user": "Dipsy", "sex": "male"}, {"user": "Laa-Laa", "sex": "female"}, {"user": "Po", "sex": "female"}], "sex");

>>Arguments Optional创建一个计算两个参数之和的 function。如果只有一个参数，则返回一个 function，该 function 请求一个参数然后返回求和的结果。例如，add(2, 3) 应该返回 5，而 add(2) 应该返回一个 function。调用这个有一个参数的返回的 function，返回求和的结果：var sumTwoAnd = add(2);sumTwoAnd(3) 返回 5。如果两个参数都不是有效的数字，则返回 undefined。
 

function add() {
  if(typeof arguments[0] !== "number" || (arguments.length > 1 && typeof arguments[1] !== "number")){
    return undefined;
  }
  if(arguments.length == 1){
    var arg0 = arguments[0];
    return function(num){
      if(typeof num !== "number"){
        return undefined;
      }
      return arg0 + num;
    };
  }else{
    return arguments[0] + arguments[1];
  }
}
add(2,3);

>>Validate US Telephone Numbers如果传入字符串是一个有效的美国电话号码，则返回 true.

用户可以在表单中填入一个任意有效美国电话号码. 下面是一些有效号码的例子(还有下面测试时用到的一些变体写法):555-555-5555
(555)555-5555
(555) 555-5555
555 555 5555
5555555555
1 555 555 5555
在本节中你会看见如 800-692-7753 or 8oo-six427676;laskdjf这样的字符串. 你的任务就是验证前面给出的字符串是否是有效的美国电话号码. 区号是必须有的. 如果字符串中给出了国家代码, 你必须验证其是 1. 如果号码有效就返回 true ; 否则返回 false.
 

function telephoneCheck(str) {
  // Good luck!
  //正则表达式
  //^1?表示以1开头，1匹配0次或1次
  //\d{3}匹配一个0-9的数字三次
  //\(\d{3}\)匹配（一个0-9的数字三次），比上面多一个括号，左右括号分别需要加上转义字符\
  // ?表示空格匹配0次或1次
  //[ -]?表示空格或者连字符-匹配0次或1次
  //\d{4}$表示已4位数字结尾($)
  var re=/^1? ?(\d{3}|\(\d{3}\))[ -]?\d{3}[ -]?\d{4}$/;
  return re.test(str);
}

telephoneCheck("6505552368");

>>Symmetric Difference创建一个函数，接受两个或多个数组，返回所给数组的 对等差分(symmetric difference) (△ or ⊕)数组.给出两个集合 (如集合 A = {1, 2, 3} 和集合 B = {2, 3, 4}), 而数学术语 "对等差分" 的集合就是指由所有只在两个集合其中之一的元素组成的集合(A △ B = C = {1, 4}). 对于传入的额外集合 (如 D = {2, 3}), 你应该安装前面原则求前两个集合的结果与新集合的对等差分集合 (C △ D = {1, 4} △ {2, 3} = {1, 2, 3, 4}).
 

function sym() {
    var result=[],i;
    var check=[];
    for(i=0;i<arguments.length;i++){
    check=arguments[i].filter(function(ele,index,arr){
        return arr.indexOf(ele)===index;
    });     //去重
    result=result.concat(check).filter(function(v){
        return result.indexOf(v)===-1||check.indexOf(v)===-1;
      });   //对差等分元素
    }
    return result;
}
sym([1, 2, 3], [5, 2, 1, 4]);

>>Inventory Update依照一个存着新进货物的二维数组，更新存着现有库存(在 arr1 中)的二维数组. 如果货物已存在则更新数量 . 如果没有对应货物则把其加入到数组中，更新最新的数量. 返回当前的库存数组，且按货物名称的字母顺序排列.
 

function updateInventory(arr1, arr2) {
    // 请保证你的代码考虑到所有情况
  var arr=[];
    for(var i=0;i<arr1.length;i++){
      for(var j=0;j<arr2.length;j++){
        if(arr1[i][1]==arr2[j][1]){
          arr1[i][0]+=arr2[j][0];
        }
      }
    }
    for(var i=0;i<arr2.length;i++){
      var flag=0;
      for(var j=0;j<arr1.length;j++){
        if(arr1[i][1]==arr2[j][1]){
            flag=1;
        }
      }
      if(flag===0)
        arr.push(arr2[i]);
    }
  
  arr1=arr1.concat(arr);
 return arr1.sort(function(a,b){
   return a[1].localeCompare(b[1]);
 });
}

// 仓库库存示例
var curInv = [
    [21, "Bowling Ball"],
    [2, "Dirty Sock"],
    [1, "Hair Pin"],
    [5, "Microphone"]
];

var newInv = [
    [2, "Hair Pin"],
    [3, "Half-Eaten Apple"],
    [67, "Bowling Ball"],
    [7, "Toothpaste"]
];
updateInventory(curInv,newInv);

>>Make a Person用下面给定的方法构造一个对象.方法有 getFirstName(), getLastName(), getFullName(), setFirstName(first), setLastName(last), and setFullName(firstAndLast).

function Person(fullName){
    
    this.getFirstName=function(){
        return fullName.split(' ')[0];
    };
    this.getLastName=function(){
        return fullName.split(' ')[1];
    };
    this.getFullName=function(){
        return fullName;
    };

    this.setFirstName=function(first){
        var arr=fullName.split(' ');
        arr.splice(0,1,first);
        fullName=arr.join(' ');   
    };
    this.setLastName=function(last){
        var arr=fullName.split(' ');
        arr.splice(1,1,last); 
        fullName=arr.join(' ');  
    };
    this.setFullName=function(firstAndLast){
        fullName=firstAndLast;
    };

}
var bob = new Person('Bob Ross');
bob.getFullName();

>>Pairwise有一个能力数组[7,9,11,13,15]，按照最佳组合值为20来计算，只有7+13和9+11两种组合。而7在数组的索引为0，13在数组的索引为3，9在数组的索引为1，11在数组的索引为2。所以我们说函数：pairwise([7,9,11,13,15],20) 的返回值应该是0+3+1+2的和，即6。

 

function pairwise(arr, arg) {
  var ans=[];
  for(var i=0;i<arr.length;i++){
    for(var j=i+1;j<arr.length;j++){
      if(arr[i]+arr[j]==arg){
        ans.push(i,j);
        delete arr[i];
        delete arr[j];
        break;
      }
    }
  }
  if(ans.length==0)return 0;
  return ans.reduce((a,b)=>a+b);
}
pairwise([], 100) ;