javascript中级脚本算法

JavaScript初级脚本算法汇总
最新推荐文章于 2019-08-19 10:35:45 发布
原创 最新推荐文章于 2019-08-19 10:35:45 发布 · 249 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#JavaScript初级脚本算法 #用程序员的思维去思 #JavaScript

javascript中级脚本算法

区间求值算法

function sumAll(arr) {
	var arrMin = Math.min(arr[0], arr[1]),
		arrMax = Math.max(arr[0], arr[1]),
		i, sum = 0;
	for (i = arrMin; i <= arrMax; i++) 
		sum += i;
	return sum;
}
console.log(sumAll([1, 4]));	//	10
console.log(sumAll([4, 1]));	//	10

找出数组间差异算法

function diff(arr1, arr2) { 
	var newArr = [],
		newArr1 = [],
		newArr2 = [];
	newArr1 = arr1.filter(function(value) {
		return arr2.indexOf(value) === -1;
	});
	newArr2 = arr2.filter(function(value) {
		return arr1.indexOf(value) === -1;
	});
	newArr = newArr1.concat(newArr2);
	return newArr;
}
console.log(diff(["diorite", "andesite", "grass", "dirt", "pink wool", "dead shrub"], ["diorite", "andesite", "grass", "dirt", "dead shrub"]));	 //	["pink wool"]
console.log(diff(["andesite", "grass", "dirt", "pink wool", "dead shrub"], ["diorite", "andesite", "grass", "dirt", "dead shrub"]));			 // [pink wool", "diorite"]
console.log(diff(["andesite", "grass", "dirt", "dead shrub"], ["andesite", "grass", "dirt", "dead shrub"]));			 						 //	[]
console.log(diff([1, 2, 3, 5], [1, 2, 3, 4, 5])); 																								 //	[4]
console.log(diff([1, "calf", 3, "piglet"], [1, "calf", 3, 4])); 																			   	 //	["piglet", 4]
console.log(diff([], ["snuffleupagus", "cookie monster", "elmo"])); 																			 //	["snuffleupagus", "cookie monster", "elmo"]
console.log(diff([1, "calf", 3, "piglet"], [7, "filly"])); 																						 //	[1, "calf", 3, "piglet", 7, "filly"]

数字转罗马数字

function convert(num) {
	num = (num + '').split('').reverse();
	var i,
		sum = '',
		len = num.length,
		romanNumArr = [
			['I','II','III','IV','V','VI','VII','VIII','IX'],
   			['X', 'XX', 'XXX', 'XL', 'L', 'LX', 'LXX', 'LXXX', 'XC'],
			['C', 'CC', 'CCC', 'CD', 'D', 'DC', 'DCC', 'DCCC', 'CM'],
			['M', 'MM', 'MMM']
		];
	for (i = len - 1; i >= 0; i--)
		sum += romanNumArr[i][num[i] - 1] ? romanNumArr[i][num[i] - 1] : '';
	return sum;
};
console.log(convert(4));		//	IV
console.log(convert(99)); 		//	XCIX
console.log(convert(12)); 		//	XII
console.log(convert(16)); 		//	XVI
console.log(convert(44)); 		//	XLIV
console.log(convert(500)); 		//	D
console.log(convert(891)); 		//	DCCCXCI
console.log(convert(501)); 		//	DI
console.log(convert(649)); 		//	DCXLIX
console.log(convert(1000)); 	//	M
console.log(convert(1023)); 	//	MXXIII
console.log(convert(2014)); 	//	MMXIV
console.log(convert(3999)); 	//	MMMCMXCIX

对象搜索算法挑战

function where(collection, source) {
	var arr = [],
		status = false,
		i;
	for (i = 0; i < collection.length; i++) {
		for (j in source) {
			if (collection[i][j] !== source[j]) {
				status = false;
				break;
			}
			status = true;
		}
	if (status)
		arr.push(collection[i]);
	}
	return arr;
}
console.log(where([{ first: "Romeo", last: "Montague" }, { first: "Mercutio", last: null }, { first: "Tybalt", last: "Capulet" }], { last: "Capulet" }));		//	[{ first: "Tybalt", last: "Capulet" }]
console.log(where([{ "a": 1 }, { "a": 1 }, { "a": 1, "b": 2 }], { "a": 1 }));																					//	[{ "a": 1 }, { "a": 1 }, { "a": 1, "b": 2 }]
console.log(where([{ "a": 1, "b": 2 }, { "a": 1 }, { "a": 1, "b": 2, "c": 2 }], { "a": 1, "b": 2 }));															//	[{ "a": 1, "b": 2 }, { "a": 1, "b": 2, "c": 2 }]
console.log(where([{ "a": 1, "b": 2 }, { "a": 1 }, { "a": 1, "b": 2, "c": 2 }], { "a": 1, "c": 2 }));															//	[{ "a": 1, "b": 2, "c": 2 }]

字符串查询替换算法

function myReplace(str, before, after) {
	if (before.charAt(0) !== before.charAt(0).toLowerCase())
		after = after.charAt(0).toUpperCase() + after.slice(1);
	return str.replace(before, after);
}
console.log(myReplace("A quick brown fox jumped over the lazy dog", "jumped", "leaped")); 	//	"A quick brown fox leaped over the lazy dog"
console.log(myReplace("He is Sleeping on the couch", "Sleeping", "sitting")); 				//	"He is Sitting on the couch"
console.log(myReplace("Let us go to the store", "store", "mall")); 							//	"Let us go to the mall"
console.log(myReplace("Let us get back to more Coding", "Coding", "algorithms")); 			//	"Let us get back to more Algorithms"

字符串移动插入算法

function translate(str) {
	var vowels = ['a', 'e', 'i', 'o', 'u'];
	if (vowels.indexOf(str.charAt(0)) != -1) {
		return str + 'way';
	}
	while (vowels.indexOf(str.charAt(0)) == -1) {
		str = str.substr(1) + str.substring(0, 1);
	}
	return str + "ay";
}
console.log(translate("consonant")); //onsonantcay
console.log(translate("glove")); //oveglay
console.log(translate("eight")); //eightway

字符配对算法

function pair(str) {
	var creatArr = [['A', 'T'],['T', 'A'],['C', 'G'],['G', 'C']],
		returnArr = [],
		i, j;
	for (j = 0; j < str.length; j++) {
		for (i = 0; i < creatArr.length; i++) {
			if (creatArr[i][0].indexOf(str[j]) != -1)
				returnArr.push(creatArr[i]);
		}
	}
	return returnArr;
}
console.log(pair("GCG")); 		//	[["G", "C"],["C", "G"],["G", "C"]]
console.log(pair("ATCGA")); 	//	[["A", "T"], ["T", "A"], ["C", "G"], ["G", "C"], ["A", "T"]]
console.log(pair("TTGAG")); 	//	[["T", "A"], ["T", "A"], ["G", "C"], ["A", "T"], ["G", "C"]]
console.log(pair("CTCTA"));		//	[["C", "G"], ["T", "A"], ["C", "G"], ["T", "A"], ["A", "T"]]

字符串查询补充算法

function fearNotLetter(str) {
	var _return;
	for (var i = 0; i < str.length; i++) {
		if (str.charCodeAt(i + 1) - str.charCodeAt(i) > 1) {
			_return = String.fromCharCode(str.charCodeAt(i) + 1);
			break;
		} else {
			_return = undefined;
		}
	}
	return _return;
}
console.log(fearNotLetter("abce")); 				//	d
console.log(fearNotLetter("abcdefghjklmno")); 		//	i
console.log(fearNotLetter("bcd")); 					//	undefined。

输入检查算法

function boo(bool) {
	bool = typeof bool === 'boolean' ? true : false;
	return bool;
}
console.log(boo(true)); 		//	true
console.log(boo(false)); 		//	fasle
console.log(boo({"a": 1})); 	//	false
console.log(boo([].slice)); 	//	false
console.log(boo("true"));		//	false
console.log(boo("false"));		//	false
console.log(boo(NaN)); 			//	false

数组去重算法

function unite(arr1, arr2, arr3) {
	var returnArr = [];
	for (var i = 0; i < arguments.length; i++) {
		for (j = 0; j < arguments[i].length; j++) {
			if (returnArr.indexOf(arguments[i][j]) < 0)
				returnArr.push(arguments[i][j]);
		}
	}
	return returnArr;
}
console.log(unite([1, 3, 2], [5, 2, 1, 4], [2, 1])); 				//	[1, 3, 2, 5, 4]
console.log(unite([1, 3, 2], [1, [5]], [2, [4]])); 					//	[1, 3, 2, [5], [4]]
console.log(unite([1, 2, 3], [5, 2, 1])); 							//	[1, 2, 3, 5]
console.log(unite([1, 2, 3], [5, 2, 1, 4], [2, 1], [6, 7, 8])); 	//	[1, 2, 3, 5, 4, 6, 7, 8]

html符号转实体算法

function convert(str) {
	return str.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;').replace(/'/g, '&apos;');
}
console.log(convert("Dolce & Gabbana")); 				//	Dolce & ​amp; Gabbana
console.log(convert("Hamburgers < Pizza < Tacos")); 	//	Hamburgers & ​lt; Pizza & ​lt; Tacos
console.log(convert("Sixty > twelve")); 				//	Sixty & ​gt; twelve
console.log(convert('Stuff in "quotation marks"')); 	//  Stuff in & ​quot; quotation marks & ​quot; 
console.log(convert("Shindler's List")); 				//	Shindler & ​apos; s List
console.log(convert("<>")); 							//	& ​lt;& ​gt; 
console.log(convert("abc")); 							//  abc

字符串连接算法

function spinalCase(str) {
	var arr = str.split(/[\n\s\_]/g);
	if (arr.length <= 1)
		return str.replace(/([A-Z])/g, "-$1").toLowerCase();
	else
		return arr.join('-').toLowerCase();
}
console.log(spinalCase('This Is Spinal Tap')); //this-is-spinal-tap
console.log(spinalCase("The_Andy_Griffith_Show")); //the-andy-griffith-show
console.log(spinalCase("thisIsSpinalTap")); //this-is-spinal-tap

斐波纳契奇数求和算法

function sumFibs(num) {
	var a = 1,b = 1,c = 2,sum = 2;
	if (num == 1) 
		sum = 1;
	else {
		for (; c <= num; a = b, b = c, c = a + b) {
			if (c % 2 == 1) sum += c;
	}
	return sum;
}
console.log(sumFibs(4)); 			//	5
console.log(sumFibs(1000)); 		//	1785。
console.log(sumFibs(4000000));		//	4613732。
console.log(sumFibs(75024)); 		//	60696。
console.log(sumFibs(75025)); 		//	135721。

质素求和算法

function sumPrimes(num) {
	var sum = 0;
	for (var i = 2; i <= num; i++) {
		var j = 2;
		for (; i % j != 0; j++) {}
			if (i == j) sum += i;
	}
	return sum;
}
console.log(sumPrimes(10));		//	17
console.log(sumPrimes(977)); 	//	73156

最小公倍数算法

/**最小公倍数：
	* @param 公式法：由于两个数的乘积等于这两个数的最大公约数与最小公倍数的积。
	* 				即（a，b）×[a，b]=a×b。所以，求两个数的最小公倍数，可以先求出它们的最大公约数。
*/
function smallestCommons(arr) {
	var min = Math.min(...arr),
		max = Math.max(...arr);
	for (var i = min; i <= max; i++) {
		min *= i / gcd(i, min);
	}
	return min;
}
// 求最大公约数
function gcd(i, m) {
	if (i % m === 0) return m;
	return gcd(m, i % m);
}
/**例子
	* @param 例子1：[1，5]	1*2/1*3/1*4/2*5/1=60
	* @param 例子2：[5，9]	5*6/1*7/1*8/2*9/3=2520
	* @param 例子3：[1，13]	1*2/1*3/1*4/2*5/1*6/6*7/1*8/4*9/3*10/10*11/1*12/12*13/1=360360
	* @param 例子4：[18，20] 18*19/1*20/2=3420
*/
console.log(smallestCommons([1, 5])); 		//	60
console.log(smallestCommons([5, 9])); 		//	2520
console.log(smallestCommons([1, 13])); 		//	360360
console.log(smallestCommons([18, 20])); 	//	3420

数组验证算法挑战

function find(arr, func) {
	var num = arr.filter(func)[0];
	return num;
}
console.log(find([1, 2, 3, 4], function(num) {return num % 2 === 0;}));				//	2
console.log(find([1, 3, 5, 8, 9, 10], function (num) {return num % 2 === 0;}));		//	8
console.log(find([1, 3, 5, 9], function (num) { return num % 2 === 0; }));			//	undefined

数组取值算法

function drop(arr, func) {
	var newArr = [];
	for (i = 0; i < arr.length; i++) {
		if (func(arr[i])) {
			newArr = arr.slice(i);
			break;
		}
	}
	return newArr;
}
console.log(drop([1, 2, 3], function(n) {return n < 3;})); // [1,2,3]
console.log(drop([1, 2, 3, 9, 2], function(n) {return n > 2;})); //[3, 9, 2]
console.log(drop([0, 1, 0, 1], function (n) { return n === 1;}));// [1, 0, 1]

数组平铺算法

function steamroller(arr) {
	var result = [];
	(function steam(ifArr) {
		if (Array.isArray(ifArr)) {
			ifArr.forEach(function (val) {
				return steam(val);
			});
		} else {
			result.push(ifArr);
		}
	})(arr);
	return result;
}
console.log(steamroller([[["a"]], [["b"]]]));		//	["a", "b"]。
console.log(steamroller([1, [2], [3, [[4]]]]));		//	[1, 2, 3, 4]

二进制转字符算法

function binaryAgent(str) {
	var arr = str.split(' ');
	str = '';
	for (var i of arr) 
		str += String.fromCharCode(parseInt(i, 2));
	return str;
}
console.log(binaryAgent("01000001 01110010 01100101 01101110 00100111 01110100 00100000 01100010 01101111 01101110 01100110 01101001 01110010 01100101 01110011 00100000 01100110 01110101 01101110 00100001 00111111")); 	//	Aren't bonfires fun!?
console.log(binaryAgent("01001001 00100000 01101100 01101111 01110110 01100101 00100000 01000110 01110010 01100101 01100101 01000011 01101111 01100100 01100101 01000011 01100001 01101101 01110000 00100001"));			//	I love FreeCodeCamp!

数组元素判断算法

function every(collection, pre) {
	var bool = true;
	for (var i of collection) 
		if (!i[pre])  bool = false;
	return bool;
}
console.log(every([{ "user": "Tinky-Winky", "sex": "male" }, { "user": "Dipsy", "sex": "male" }, { "user": "Laa-Laa", "sex": "female" }, { "user": "Po", "sex": "female" }], "sex")); 												//	true
console.log(every([{ "user": "Tinky-Winky", "sex": "male", "age": 0 }, { "user": "Dipsy", "sex": "male", "age": 3 }, { "user": "Laa-Laa", "sex": "female", "age": 5 }, { "user": "Po", "sex": "female", "age": 4 }], "age"));		//	false

函数迭代可选参数算法

function add() {
	var arg = arguments,bool = true, i;
	for (i = 0; i < arg.length; i++) {
		if (typeof arg[i] !== 'number') {
			bool = false;
			break;
		}
	}
	if (bool) {
		switch (arg.length) {
			case 1:
				return (function () {
					if (typeof arguments[0] !== 'number') return undefined;
					else return arg[0] + arguments[0];
				});
				break;
			case 2:
				return arg[0] + arg[1];
				break;
			default:
				return undefined;
				break;
		}
	} else return undefined;
}
console.log(add(2, 3)); 					//	5
console.log(add('1', 1)); 					//	undefined
console.log(add("http://bit.ly/IqT6zt")); 	//	undefined
console.log(add(2)([3])); 					//	undefined
console.log(add(2)(3)); 					//	5

有写的不好的地方欢迎大家留言讨论。

AlgorithmScripting:中级算法脚本编写挑战。 资源
03-29
"AlgorithmScripting:中级算法脚本编写挑战"是一个旨在提升开发者在JavaScript中编写高效算法能力的资源。这个挑战可能包括一系列的问题和练习，旨在帮助学习者通过实际操作来加深对算法的理解，并提高他们的编程...
js初级脚本算法
weixin_34090643的博客
06-29 140
翻转字符串算法挑战 function reverseString(str){ str = str.split('').reverse().join(''); return str; } reverseString("hello"); 先把字符串转化成数组，再借助数组的reverse方法翻转数组顺序，最后把数组转化成字符串 阶乘算法 fun...
js中级脚本算法
aikudemn的博客
07-04 361
原文链接 摘要： 区间求值算法 function sumAll(arr) { var sum =0; if(arr[0] 区间求值算法 function sumAll(arr) { var sum =0; if(arr[0]1]){ for(var i=arr[0];i1];i++){ sum = sum + i; }
js高级脚本算法
chuanggangbo5551的博客
07-05 136
摘要：判断电话号码算法 function telephoneCheck(str) { var re=/^[1-9]\d{9}$|^[1-9]\d{2}-[0-9]\d{2}-[0-9]\d{3}$|^[1−9]\d2[1−9]\d2[0-9]\d{2}-[0-9]\d{3}$|^\([1-9...
算法练习5：设置首字母大写算法
照顾一生
05-03 186
返回一个字符串,确保字符串的每个单词首字母都大写，其余部分小写。 像'the'和'of'这样的连接符同理。 使用到的方法函数： toLowerCase()将一句话的所有字母转为小写 split()将一句话转换成字符串数组 toUpperCase()将每个单词的首字母转为大写 substring()截取单词中剩余的字母，然后拼接到大写字母之后 join()将数组里的每个单词重...
JavaScript初级脚本算法
ljxyaly的博客
09-13 2603
本人今年毕业自学前端到现在两个月，按照一般学习路径从html和css到javascript，最近在W3C和FreeCodeCamp上做脚本算法挑战（两个地方的算法题都是一样的）。在javascript这部分中，刚开始的时候是看书，主要针对javascript高级程序设计第三版中的前七章，好多属性和方法都是大概知道是什么意思，但是用起来就完全不是那么回事，因此通过这些算法挑战可以让自己熟悉一下这些内
掌握中级JavaScript算法脚本技巧
标题《javascript-algorithm:中级算法脚本》表明这是一个专注于JavaScript语言的算法学习资源，旨在帮助学习者掌握中级水平的编程算法。在IT领域，算法是编写高效、优化代码的核心，尤其对于前端工程师、全栈开发者...
中级JavaScript算法脚本编写挑战资源合集
了解如何在JavaScript中高效地处理异步操作、操作DOM、使用闭包以及理解原型链和继承等概念，对于中级脚本编写挑战至关重要。 4. 编程技巧与最佳实践 编程技巧不仅仅是算法和数据结构的运用，还包括代码重构、模块...
FCC中级算法脚本：掌握JavaScript编程
资源摘要信息:"FCC-intermediate-algorithm-scripting是免费代码训练营（FreeCodeCamp，简称FCC）提供的中级算法脚本课程的一部分，专注于JavaScript编程语言。FCC是一个专注于免费的编码课程平台，旨在通过完成各种...
freeCodeCamp中级算法脚本教程与实践
综合以上信息，freeCodeCamp的JavaScript中间算法脚本项目，其目标是通过实战练习帮助编程初学者提高算法解决问题的能力。它主要侧重于JavaScript语言，该语言在前端开发中扮演着核心角色。该项目被托管在GitHub上，...
javascript初级脚本算法
不丶甜的博客
04-15 344
初级脚本算法翻转字符串算法 翻转字符串算法 function reverseString(str) { str = str.split('').reverse().join(''); return console.log(str); } reverseString("hello");
JS的初级脚本算法——个人笔记
qq_43872529的博客
08-19 484
JS的初级脚本算法 一、 JS 翻转字符串的方法 要求： reverseString("hello") 应该返回 "olleh". 首先我们需要使用JS的以下方法： **split(’#’)**方法将字符串对象拆分为字符串数组，使用指定的分隔符字符串 # 来确定每次拆分的位置。 split()方法的相关内容 **reverse()**将阵列反转到位。第一个数组元素成为最后一...
JavaScript高级脚本算法编程练习（W3C学院）
Hrzhi的博客
07-31 1468
JavaScript脚本算法编程实战课程 目录 JavaScript脚本算法编程实战课程 1、判断电话号码算法挑战 2、集合交集算法挑战 3、 收银系统算法挑战 4、库存更新算法挑战 5、排列组合去重算法挑战 6、日期改写算法挑战 7、类及对象构建算法挑战 8、 轨道周期算法挑战 9、数据组合求值算法挑战 1、判断电话号码算法挑战 如果传入字符串是一个有效的美国电话号码，...
这16道初级脚本算法题，你敢说全都会吗？
Lunaqi的博客
06-10 1083
之前有同学在留言给小编说，对于算法部分，不是很了解！ 哦，那不好棒棒！ 所以我这么善良，当然会挖空心思帮大家找啦！今天就给大家分享16道面向前端方向的算法题及对应代码，大家好才是真的好。 所以说，如果你想看一些什么样的技术内容，那就可以在公众号回复， “我要提问” + 描述你想要的内容 小编看到后，一定第一时间关掉....但如果你说点好听的
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值