中级脚本算法挑战

地址：https://www.w3cschool.cn/codecamp/list?pename=intermediate_algorithm_scripting_camp

区间求值算法挑战 ：
我们会传递给你一个包含两个数字的数组。返回这两个数字和它们之间所有数字的和。
最小的数字并非总在最前面。

function sumAll(arr) {
    var left = arr[0]>arr[1]?arr[1]:arr[0];
    var right = arr[0]+arr[1]-left;
    var sum = 0;
    for(;left<=right;left++)
    {
        sum+=left;
    }
    return sum;
}

sumAll([1, 4]);

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

sumAll([1, 4]);

找出数组间差异算法挑战
比较两个数组，然后返回一个新数组，该数组的元素为两个给定数组中所有独有的数组元素。换言之，返回两个数组的差异。

function diff(arr1, arr2) {
    return arr1.filter(a=> arr2.indexOf(a)<0).concat(arr2.filter(a=> arr1.indexOf(a)<0));
}
diff([1, 2, 3, 5], [1, 2, 3, 4, 5]);

数字转罗马数字挑战：
将给定的数字转换成罗马数字。

function convert(num) {
 let result = "";
    let k = Math.floor(num / 1000);
    let h = Math.floor((num % 1000) / 100);
    let t = Math.floor((num % 100) / 10);
    let o = num % 10;
    let one = ['I', 'II', 'III', 'IV', 'V', 'VI', 'VII', 'VIII', 'IX'];
    let ten = ['X', 'XX', 'XXX', 'XL', 'L', 'LX', 'LXX', 'LXXX', 'XC'];
    let hundred = ['C', 'CC', 'CCC', 'CD', 'D', 'DC', 'DCC', 'DCCC', 'CM']
    let thousand = 'M';
    for (let i = 0; i < k; i++) {
        result += thousand;
    }
    if (h)
        result += hundred[h - 1];
    if (t)
        result += ten[t - 1];
    if (o)
        result += one[o - 1];
    return result;
}

convert(36);

对象搜索算法挑战
写一个 function方法，它遍历一个对象数组（第一个参数）并返回一个包含相匹配的属性-值对（第二个参数）的所有对象的数组。如果返回的数组中包含 source 对象的属性-值对，那么此对象的每一个属性-值对都必须存在于 collection 的对象中。
例如，如果第一个参数是 [{ first: "Romeo", last: "Montague" }, { first: "Mercutio", last: null }, { first: "Tybalt", last: "Capulet" }]，第二个参数是 { last: "Capulet" }，那么你必须从数组（第一个参数）返回其中的第三个对象，因为它包含了作为第二个参数传递的属性-值对。

function where(collection, source) {
    var result = [];
    for(let i = 0,j=collection.length;i<j;i++)
    {
        let obj = collection[i];
        let flag = true;
        for(let key in source)
        {
            if(obj[key]  != source[key])
            {
                flag = !flag;
                break;
            }
        }
        if(flag)
        {
           result.push(obj);
        }
    }
    return result;
}

where([{ first: "Romeo", last: "Montague" }, { first: "Mercutio", last: null }, { first: "Tybalt", last: "Capulet" }], { last: "Capulet" });

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

function myReplace(str, before, after) {
    if(before.slice(0,1).toUpperCase() == before.slice(0,1))
    {
        after = after.slice(0,1).toUpperCase() + after.slice(1);
    }
    else
    {
        after = after.slice(0,1).toLowerCase() + after.slice(1);
    }
    return str.replace(new RegExp(before,"gm"),after);
}

myReplace("A quick brown fox jumped over the lazy dog", "jumped", "leaped");

字符串移动插入算法挑战：
把指定的字符串翻译成 pig latin。
Pig Latin 把一个英文单词的第一个辅音或辅音丛（consonant cluster）移到词尾，然后加上后缀 "ay"。
如果单词以元音开始，你只需要在词尾添加 "way" 就可以了。
输入字符串保证是英文单词全部小写。

function translate(str) {
let y=['a','e','i','o','u']; //定义元音 
  let i=0; //保存辅音丛的长度
  while(i<str.length){  
    if(y.indexOf(str[i])=== -1){ // indexOf 比较结果为 -1时，则说明不存在，即当前比较的字母不为元音；
      i++;  // 记录辅音丛长度
    }
    else{
      break;
    }
  }
  if(i===0){
    return str+"way";    //元音开头
  }
   else{
    return str.substr(i)+str.substr(0,i)+"ay";    //辅音丛开头
  }
  return "";
}

translate("consonant");

字符配对算法挑战：
DNA 链缺少配对的碱基。依据每一个碱基，为其找到配对的碱基，然后将结果作为第二个数组返回。
Base pairs（碱基对） 是一对 AT 和 CG，为给定的字母匹配缺失的碱基。
在每一个数组中将给定的字母作为第一个碱基返回。
例如，对于输入的 GCG，相应地返回 [["G", "C"], ["C","G"],["G", "C"]]
字母和与之配对的字母在一个数组内，然后所有数组再被组织起来封装进一个数组。

function pair(str) {
    let result = [];
    for(let i =0,j=str.length;i<j;i++)
    {
        let arr = [str[i]];
        switch (str[i]) {
            case 'G':
                arr.push("C");
                break;
            case 'C':
                arr.push("G");
                break;
            case 'A':
                arr.push("T");
                break;
            case 'T':
                arr.push("A");
                break;   
            default:
                break;
        }
        result.push(arr);
    }
    return result;
}

pair("GCG");

字符串查询补充算法挑战：
从传递进来的字母序列中找到缺失的字母并返回它。
如果所有字母都在序列中，返回 undefined。

function fearNotLetter(str) {
    let result = "";
    let a = str[0].charCodeAt();
    for(let i=1,j=str.length;i<j;i++)
    {
        if(++a != str[i].charCodeAt())
        {
            result += String.fromCharCode(a);
            a = str[i].charCodeAt()
        }
    }
    return result==""?undefined:result;
}

fearNotLetter("abce");

输入检查算法挑战：
检查一个值是否是基本布尔类型，并返回 true 或 false。
基本布尔类型即 true 和 false。

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

boo(null);

数组去重算法挑战：
写一个 function，传入两个或两个以上的数组，返回一个以给定的原始数组排序的不包含重复值的新数组。
换句话说，所有数组中的所有值都应该以原始顺序被包含在内，但是在最终的数组中不包含重复值。
非重复的数字应该以它们原始的顺序排序，但最终的数组不应该以数字顺序排序。

function unite(arr1,... arrs) {
    var result = arr1.concat();
    for(let i=0,j=arrs.length;i<j;i++)
    {
        let array = arrs[i].filter( a=> result.indexOf(a) < 0 );
        for(let i=0,j=array.length;i<j;i++)
        {
            result.push(array[i]);
        }
    }
    return result;
}

unite([1, 3, 2], [5, 2, 1, 4], [2, 1]);

html符号转实体算法挑战：
将字符串中的字符 &、<、>、" （双引号）, 以及 ' （单引号）转换为它们对应的 HTML 实体。

function convert(str) {
// :)
    return str.replace(/&/g,"&amp;").replace(/</g,"&lt;").replace(/>/g,"&gt;").replace(/"/g,"&quot;").replace(/'/g,"&apos;");
}

convert("Dolce & Gabbana");

字符串连接算法挑战：
将字符串转换为 spinal case。Spinal case 是 all-lowercase-words-joined-by-dashes 这种形式的，也就是以连字符连接所有小写单词。

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

spinalCase('This Is Spinal Tap');

斐波纳契奇数求和算法挑战：
给一个正整数num，返回小于或等于num的斐波纳契奇数之和。
斐波纳契序列中的前两个数字是1和1.序列中的每个附加数字是前面两个数字的和。斐波纳契序列的前六个数字是1,1,2,3,5和8。
例如，sumFibs(4)应该返回 5，因为斐波纳契数列中所有小于4的奇数是 1、1、3。

function sumFibs(num) {
    let arr = [1,1];
    let result = [1,1];
    if(num<2)
    {
        return 0;
    }
    while(true)
    {
        let length = arr.length;
        let next = arr[length-1] + arr[length-2];
        if(next <= num)
        {
          arr.push(next);
          if( next % 2 == 1)
          {
            result.push(next);
          }
        }
        else
        {
            break;
        }
    }
    return result.reduce(function (accumulator, currentValue) { return accumulator + currentValue;});
}

sumFibs(4);

 质素求和算法挑战 ：
求小于等于给定数值的质数之和。
只有 1 和它本身两个约数的数叫质数。例如，2 是质数，因为它只能被 1 和 2 整除。1 不是质数，因为它只能被自身整除。
给定的数不一定是质数。

function sumPrimes(num) {
    var result = [];
    if(num<2)
    {
        return 0;
    }
    for(let i = 2;i <= num; i++ )
    {
        let flag = true;
        for(let j = 2,k = Math.floor(Math.sqrt(i));j<=k;j++)
        {
            if(i%j==0)
            {
                flag = false;
                break;
            }
        }
        if(flag){
            result.push(i);
        }
    }
    return result.reduce(function (a, c) { return a + c;});;
}

sumPrimes(10);

最小公倍数算法挑战:
找到所提供参数的最小公倍数，这两个参数可以均匀分配，以及这些参数之间范围内的所有最小公倍数。
范围是两个数字构成的数组，两个数字不一定按数字顺序排序。
例如对 1 和 3 —— 找出能被 1 和 3 和它们之间所有数字整除的最小公倍数。

function smallestCommons(arr) {
    let left = Math.min(arr[0],arr[1]);
    let right = Math.max(arr[0],arr[1]);
    let shift = left;
    let result = left;
    for(let i=left+1;i<=right;i++)
    {
        shift = result;
        while(true)
        {
           if(result % i == 0)
           {
               break;
           }
           result += shift;
        }
        
    }
    return result;
}


smallestCommons([1,5]);

function smallestCommons(arr) {
    let left = Math.min(arr[0],arr[1]);
    let right = Math.max(arr[0],arr[1]);
    let array = [];
    for(let i =left;i<=right;i++)
    {
        array.push(i);
    } 
    return array.reduce(function(a,c){let sum = a;while(true){if(sum%c==0){return sum } else {sum += a;}}})
}

数组验证算法挑战：
写一个 function，它查找数组（第一个参数）并返回数组中第一个通过某种方法（第二个参数）验证的元素。

function find(arr, func) {
    let array = arr.filter(a=>func(a));
    return array.length>0?array[0]:undefined;
}

find([1, 2, 3, 4], function(num){ return num % 2 === 0; });

数组取值算法挑战：
删除数组(第一个参数)的元素，从左边开始，直到回调函数（第二个参数）return true就停止。
第二个参数，func，是一个函数。用来测试数组的第一个元素，如果返回fasle，就从数组中抛出该元素(注意：此时数组已被改变)，继续测试数组的第一个元素，如果返回fasle，继续抛出，直到返回true。
最后返回数组的剩余部分，如果没有剩余，就返回一个空数组。

function drop(arr, func) {
    for(let i=0,j=arr.length;i<j;i++)
    {
        let shift = arr.shift();
        if(func(shift))
        {
            arr.unshift(shift);
            break;
        }
        else
        {
            arr.slice(1);
        }
    }
    console.log(arr)
    return arr;
}

drop([1, 2, 3], function(n) {return n < 3; });

数组平铺算法挑战：
对嵌套的数组进行平铺嵌套数组。你必须考虑到不同层级的嵌套。

function steamroller(arr) {
    let result = [];
    for(let i=0,j=arr.length;i<j;i++)
    {
        if(Array.isArray(arr[i]))
        {
            result = result.concat(steamroller(arr[i]));
        }
        else
        {
            result.push(arr[i]);
        }
    }
    return result;
}

steamroller([1, [2], [3, [[4]]]]);

二进制转字符算法挑战：
传入二进制字符串，翻译成英语句子并返回。
二进制字符串是以空格分隔的。

function binaryAgent(str) {
    let result = "";
    let arr = str.split(" ");
    return arr.reduce(function(a, c) {
        return a + String.fromCharCode(c.split("").reverse().reduce(function(a, c, i) {
            return Number(a) + c * Math.pow(2, i);
        }))
    },'');
}
binaryAgent("01000001 01110010 01100101 01101110 00100111 01110100 00100000 01100010 01101111 01101110 01100110 01101001 01110010 01100101 01110011 00100000 01100110 01110101 01101110 00100001 00111111");

数组元素判断算法挑战:
所有的东西都是真的！
完善编辑器中的every函数，如果集合(collection)中的所有对象都存在对应的属性(第二个参数)，并且属性(第二个参数)对应的值为真。函数返回ture。反之，返回false。

function every(collection, pre) {
    var result = [];
    let flag = true;
    for(let i = 0,j=collection.length;i<j;i++)
    {
        let obj = collection[i];
        if(obj[pre]  == undefined || obj[pre]==null || obj[pre]=='' || (typeof(obj[pre])=="number" && isNaN(obj[pre])) )
        {
            flag = !flag;
            break;
        }
       
    }
    return flag;
}

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

函数迭代可选参数算法挑战 ：
创建一个计算两个参数之和的 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" && typeof arguments[1]=="number"){
    return arguments[0]+arguments[1];
  }
  else if(arguments.length==1 && typeof arguments[0]=="number"){
    var x=arguments[0];
    return function(y){
      if(typeof y =="number"){
        return x+y;
      }
    };
  }
}

add(2,3);