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 = ["&", "<", ">", """, "'"];
// 用正则表达式截取字符串中的字符
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];
}
}