JavaScript හි මතකය භාවිතා කරමින් වේගය ප්‍රශස්ත කිරීම

වේගය වැඩි කිරීම සඳහා මතකය පූජා කළ හැකි අවස්ථා තිබේ.

අපි උදාහරණයක් බලමු. පහත කේතය ලබා දී ඇති පරාසය තුළ friendly numbers සොයා ගනී:

console.log(getFriendly(9000));

function getFriendly(range) {
	let res = [];
	
	for (let i = 1; i <= range; i++) {
		for (let j = 1; j < range; j++) {
			if (isFriendly(i, j)) {
				res.push([i, j]);
			}
		}
	}
	
	return res;
}

function isFriendly(num1, num2) {
	let sum1 = getSum(getOwnDivisors(num1));
	let sum2 = getSum(getOwnDivisors(num2));
	
	return sum1 == num2 && sum2 == num1;
}

function getOwnDivisors(num) {
	let res = [];
	
	for (let i = 1; i < num; i++) {
		if (num % i === 0) {
			res.push(i);
		}
	}
	
	return res;
}

function getSum(arr) {
	let sum = 0;
	
	for (let elem of arr) {
		sum += elem;
	}
	
	return sum;
}

ඉහත කේතය ප්‍රශස්ත නොවේ. එය විශාල ක්‍රියා සංඛ්‍යාවක් සිදු කරන අතර 9000 දක්වා ඇති පරාසය සඳහා බ්‍රවුසර් පිටුව හුදෙක් එල්ලා යනු ඇත.

මෙම කේතයේ ගැටලුව නම්, අපි සෑම අංකයකටම එහි බෙදුම්කරුවන්ගේ එකතුව ගණනය කිරීම බොහෝ වතාවක්, අප පරීක්ෂා කරන සම්පූර්ණ සංඛ්‍යාව මෙන් බොහෝ වතාවක් කිරීමයි. මෙයින් අදහස් කරන්නේ අපගේ නඩුවේදී ඕනෑම අංකයක් සඳහා එහි බෙදුම්කරුවන්ගේ එකතුව 9000 වතාවක් සොයා ගැනීමට ලක්වනු ඇති බවයි. සියල්ල එල්ලා යාම පුදුමයක් නොවේ.

අපි ප්‍රශස්ත කිරීමට පෙළඹෙමු. පළමුව බෙදුම්කරුවන්ගේ එකතුව කෙලින්ම ගණනය කරන ශ්‍රිතයක් සාදමු, ඒවා අරාවක ගබඩා නොකර:

function getOwnDivisorsSum(num) {
	let sum = 0;
	
	for (let i = 1; i < num; i++) {
		if (num % i === 0) {
			sum += i;
		}
	}
	
	return sum;
}

දැන් මතකය පූජා කිරීමට කාලයයි. අපි ශ්‍රිතයක් සාදමු, එය කල්තියා වරක් ගණනය කරනු ඇත ලබා දී ඇති පරාසයේ සියලුම සංඛ්‍යාවල බෙදුම්කරුවන්ගේ එකතුව සහ ගබඩා කරනු ඇත ඒවා අරාවක.

අපගේ ශ්‍රිතයේ ප්‍රතිඵලය වනුයේ එක් අරාවක් ලබා දෙනු ඇත, එහි යතුර සංඛ්‍යාව වනු ඇත (එකකින් අඩු), සහ අගය - එහි බෙදුම්කරුවන්ගේ එකතුව. අපි අපේ කාර්යය ක්‍රියාත්මක කරමු:

function getAllSum(range) {
	let arr = [];
	
	for (let i = 1; i <= range; i++) {
		arr.push(getOwnDivisorsSum(i));
	}
	
	return arr;
}

දැන් friendly numbers පරීක්ෂා කිරීම සඳහා අපි සෑම අවස්ථාවකම ගණනය නොකරමු සංඛ්‍යාවල බෙදුම්කරුවන්ගේ එකතුව, නමුත් සරලව දැනටමත් ගණනය කළ එක අරාවෙන් ගනිමු:

function getFriendly(range) {
	let sums = getAllSum(range); // [1, 2, 6...]
	
	let res = [];
	
	for (let i = 0; i < sums.length; i++) {
		for (let j = i; j < sums.length; j++) {
			let sum1 = sums[i];
			let sum2 = sums[j];
			
			let num1 = i + 1;
			let num2 = j + 1;
			
			if (num1 == sum2 && num2 == sum1) {
				res.push([num1, num2]);
			}
		}
	}
	
	return res;
}

අපි සියල්ල එකට එකතු කර පහත කේතය ලබා ගනිමු:

console.log(getFriendly(9000));

function getFriendly(range) {
	let sums = getAllSum(range);
	
	let res = [];
	
	for (let i = 0; i < sums.length; i++) {
		for (let j = i; j < sums.length; j++) {
			let sum1 = sums[i];
			let sum2 = sums[j];
			
			let num1 = i + 1;
			let num2 = j + 1;
			
			if (num1 == sum2 && num2 == sum1) {
				res.push([num1, num2]);
			}
		}
	}
	
	return res;
}

function getAllSum(range) {
	let arr = [];
	
	for (let i = 1; i <= range; i++) {
		arr.push(getOwnDivisorsSum(i));
	}
	
	return arr;
}

function getOwnDivisorsSum(num) {
	let sum = 0;
	
	for (let i = 1; i < num; i++) {
		if (num % i === 0) {
			sum += i;
		}
	}
	
	return sum;
}

පහත කේතය අන්යෝන්ය වශයෙන් ප්‍රථමක වන ලබා දී ඇති පරාසයෙන් සංඛ්‍යා සොයා ගනී. එය ප්‍රශස්ත කරන්න:

console.log(getRelativelyPrime(10000));

function getRelativelyPrime(range) {
	let res = [];
	
	for (let i = 2; i <= range; i++) {
		for (let j = 2; j < range; j++) {
			if (isRelativelyPrime(i, j)) {
				res.push([i, j]);
			}
		}
	}
	
	return res;
}
function isRelativelyPrime(num1, num2) {
	let arr1 = getDivisors(num1);
	let arr2 = getDivisors(num2);
	let int  = getIntersect(arr1, arr2);
	
	if (int.length === 0) {
		return true;
	} else {
		return false;
	}
}
function getIntersect(arr1, arr2) {
	let result = [];
	
	for (let elem of arr1) {
		if (arr2.includes(elem)) {
			result.push(elem);
		}
	}
	
	return result;
}
function getDivisors(num) {
	let res = [];
	
	for (let i = 2; i <= num; i++) {
		if (num % i === 0) {
			res.push(i);
		}
	}
	
	return res;
}