Intermediate Algorithm Scripting FreeCodeCamp中级算法

Intermediate Algorithm Scripting

1. Sum All Numbers in a Range

function sumAll(arr) {
    var maxVal = Math.max(arr[0], arr[1]);
    var minVal = Math.min(arr[0], arr[1]);

    var arrC = [];
    for (var i = minVal; i <= maxVal; i++) {
    arrC.push(i);
    }
    return arrC.reduce(function (preVal, currentVal) {
    return preVal + currentVal;
    }, 0);
}

2. Diff Two Arrays 取两个数组中不相同的元素

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

function diff(arr1, arr2) {
    var newArr = [];
    for (var i = 0; i < arr1.length; i++) {
        var isHave = arr2.indexOf(arr1[i]);
        if (isHave < 0) {
            newArr.push(arr1[i]);
        }
    }

    for (var j = 0; j < arr2.length; j++) {
        var isHave2 = arr1.indexOf(arr2[j]);
        if (isHave2 < 0) {
            newArr.push(arr2[j]);
        }
    }
    return newArr;
}

3.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();
}

4.whrer are you

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

function where(collection, source) {
    var arr = [];
    // 属性数组
    var keysArr = Object.keys(source);
    return collection.filter(function (val) {
        // 判断是否包含对应的属性
        return keysArr.every(function (key) {
            return (val.hasOwnProperty(key) && val[key] === source[key]);
        });
    });
}

5. Search and Replace

function myReplace(str, before, after) {
    // 首字母是不是大写
    if (before[0] === before[0].toUpperCase()) {
        after = after[0].toUpperCase() + after.slice(1);
    }
    return str.replace(before, after);
}

6.Pig Latin 把指定的字符串翻译成 pig latin。 知道元音辅音就好算

function translate(str) {
    var myStr = '';
    var regex = /[aeiou]/gi;
    if(str[0].match(regex)){
        myStr = str + 'way';
    } else {
        var index = str.indexOf(str.match(regex)[0]);
        myStr = str.substr(index) + str.substring(0,index) + 'ay';
    }
    return myStr;
}

7. DNA Pairing AT CG，有局限性，不够好

function pair(str) {
    // 分割字符串
    // 每一个进行匹配
    // 组成一个二维数组返回
    var resultArr = [];
    str.split('').map(function (val) {
        var arr = [];
        if (val === "A") {
            arr.push("A");
            arr.push("T");
        }
        if (val === "T") {
            arr.push("T");
            arr.push("A");
        }
        if (val === "C") {
            arr.push("C");
            arr.push("G");
        }
        if (val === "G") {
            arr.push("G");
            arr.push("C");
        }
        resultArr.push(arr);
    });
    return resultArr;
}

8. Missing letters 分割字符串，

// 分割  转码 ，拿到第一个和最后一个， 组成一个数组， 判断原本分割后的缺失的码，
function fearNotLetter(str) {
    // 转码
    var arr = str.split('').map(function (val) {
        return val.charCodeAt(0);
    });
    var wordArr = [];
    // 获得连续字母
    for (var i = str.charCodeAt(0); i < str.charCodeAt(str.length - 1); i++) {
        wordArr.push(i);
    }
    var resultArr = wordArr.filter(function (val) {
       return arr.every(function (tar) {
         return val !== tar;
       });
    });

    if (resultArr.length == 0) {
        return undefined;
    }

    // 转为字母
    return resultArr.map(function (ch) {
       return String.fromCharCode(ch);
    }).join('');
}

9. Boo who 检查一个值是否是基本布尔类型，并返回 true 或 false。

function boo(bool) {
    if (bool === true || bool === false) {
        return true;
    }
    return false;
}

10. Sorted Union

// 方法一：
function unite(arr1, arr2, arr3) {
    // 转化为数组
    var args = Array.prototype.slice.call(arguments);
    // reduce 参数数组
    return args.reduce(function (pre, cur) {
        // 遍历下一个数组，如果当前的数组没有该元素，就添加到当前数组中
        for (var i = 0; i < cur.length; i++) {
            if (pre.indexOf(cur[i]) < 0) {
                pre.push(cur[i]);
            }
        }
        return pre;
    });
}

11.Convert HTML Entities 这种写法有局限性

/*
* 将字符串中的字符 &、<、>、” （双引号）, 以及 ’ （单引号）转换为它们对应的 HTML 实体。
* */

function convert(str) {
    var arr = ["&", "<", ">",'"', "'"];
    var fuArr = ["&amp;", "&lt;", "&gt;", "&quot;", "&apos;"];
    // 用正则表达式截取字符串中的字符
    var reg = /[&<>"']/g;
    var ssArr = str.match(reg);
    if (ssArr) {
        for (var i = 0; i < ssArr.length; i++) {
            var index = arr.indexOf(ssArr[i]);
            str = str.replace(ssArr[i], fuArr[index]);
        }
    }
    return str;
}

12. Spinal Tap Case

function spinalCase(str) {
    // 1. 正则表达式提取纯文本
    str = str.replace('-', ' ');
    str = str.replace(/[\W\^_]/g, ' ');
    var arr = str.split('');

    // 2. 根据大写分割为单词
    var sss = '';
    arr.map(function (val, index, arr) {
        var cindex = val.charCodeAt(0);
        if (cindex < 65 + 26) {
            // 如果是大写，在前面加个空格，用来分割
            sss += " " + val;
        } else {
            sss += val;
        }
    });

    // 3. 通过空格来进行分割
    // 3. 删除两端的空格
    sss = sss.trim();
    var arr2 = sss.split(' ');
    // 4.转为小写
    arr2 = arr2.map(function (val) {
        return val.toLowerCase();
    });

    arr2 = arr2.filter(function(val){
        return val !== "";
    });
    // 4.拼接，返回
    return arr2.join('-');
}

13. Sum All Odd Fibonacci Numbers

/*
* 给一个正整数num，返回小于或等于num的斐波纳契奇数之和。

斐波纳契数列中的前几个数字是 1、1、2、3、5 和 8，随后的每一个数字都是前两个数字之和。

例如，sumFibs(4)应该返回 5，因为斐波纳契数列中所有小于4的奇数是 1、1、3。
* */

function sumFibs(num) {
    // 小于3 结果是数字本身
    if (num < 3) {
        return num;
    }
    var arr = [1, 1];
    // 一直加，直到接近前后两个数字
    for (var i = 2; i < Number.POSITIVE_INFINITY; i++) {
        arr[i] = arr[i - 2] + arr[i - 1];
        if (arr[i - 1] >= num) {
            break;
        }
    }
    // 取下标，然后截取数组
    var index = (num <=  arr[arr.length - 1] && arr[arr.length - 2] <= num) ? arr.length -1 : arr.length - 2;
    // 过滤偶数
    var resultArr = arr.splice(0, index).filter(function (val) {
        return (val % 2) === 1;
    });
    // 相加
    return resultArr.reduce(function (pre, current) {
        return pre + current;
    });
}

14. Sum All Primes 求小于等于给定数值的质数之和。

/*
* 求小于等于给定数值的质数之和。

只有 1 和它本身两个约数的数叫质数。例如，2 是质数，因为它只能被 1 和 2 整除。1 不是质数，因为它只能被自身整除。

给定的数不一定是质数。
* */

function sumPrimes(num) {
    // 求出范围内的所有质数
    var arr = [];
    if (num < 2) {
        return 0;
    }

    if (num === 2) {
        return 2;
    }

    for (var i = 2; i <= num; i++) {
        if (i === 2) {
            arr.push(2);
        } else {
            var isHave = false;
            for (var j = 2; j < i; j++){
                // 如果能被整除，那就不是质数了
                if ( i % j === 0) {
                    isHave = true;
                    break;
                }
            }
            if (!isHave) {
                arr.push(i);
            }
        }
    }
    // 求所有质数的和  reduce
    return arr.reduce(function (pre, cur) {
        return pre + cur;
    });
}

15. Smallest Common Multiple 找出能被两个给定参数和它们之间的连续数字整除的最小公倍数。 拿出所有奇数中的质数

function smallestCommons(arr) {
    arr=arr.sort(function(a,b){
        return a - b;
    });
    var num=arr[0];
    for(var i= arr[0]+1;i<=arr[1];i++){
        num*=i/gcd(num,i);
    }
    return num;
    }
    function gcd(m,n){
        if(m%n===0)return n;   return gcd(n,m%n);
}

16. Finders Keepers

function find(arr, func) {
    for(var i = 0; i < arr.length; i++){
        var result = func(arr[i]);
        if (result === true) {
            return arr[i];
        }
    }
}

17 . Drop it

function drop(arr, func) {
    var resultArr = arr.filter(function(val){
        var result = func(val);
        if (result) {
            return val;
        }
    });
    // 拿到第一个元素
    if(resultArr.length <= 0){
        return [];
    }
    var index =  arr.indexOf(resultArr[0]);
    return  arr.splice(index);
}

18.Steamroller

function steamroller(arr) {
    var resultArr = [];
    arr.map(function(val){
        return my(val);
    });

    return resultArr;
    function my(a) {
        if(Array.isArray(a)) {
            return a.map(function(b){
                return my(b);
            });
        }
        resultArr.push(a);
    }
}

19. Binary Agents

/*
* 传入二进制字符串，翻译成英语句子并返回。

二进制字符串是以空格分隔的。
* */

function binaryAgent(str) {
    // 1. 分割二进制字符串
    var arr = str.split(' ');
    // 2.转化为10进制
    var numArr = arr.map(function (val) {
        return parseInt(val , 2);
    });
    // 转化为 ASII码  把ASII码转为字符串连接起来
    return numArr.map(function (tar) {
        return String.fromCharCode(tar);
    }).join('');
}

20. Everything Be True

function every(collection, pre) {
    return collection.every(isHaveProperty);

    function isHaveProperty (element, index, arr) {
        return element.hasOwnProperty(pre) && element[pre] !== undefined && Boolean(element[pre]);
    }
}

21.Arguments Optional

/*
* 创建一个计算两个参数之和的 function。如果只有一个参数，则返回一个 function，该 function 请求一个参数然后返回求和的结果。
* */

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];
    }
}