জাভাস্ক্রিপ্টে মেমোরির বিনিময়ে গতি অপ্টিমাইজেশন

এমন পরিস্থিতি আছে যখন কার্যকারিতা বাড়ানোর জন্য র‍্যান্ডম অ্যাক্সেস মেমোরি খরচ করা যেতে পারে।

এর একটি উদাহরণ দেখা যাক। নিম্নলিখিত কোডটি একটি নির্দিষ্ট সীমার মধ্যে বন্ধুত্বপূর্ণ সংখ্যা খুঁজে পায়:

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

এখন বন্ধুত্বপূর্ণতা পরীক্ষা করার জন্য আমরা প্রতিবার ভাজকের যোগফল গণনা করব না সংখ্যার, বরং আমরা সহজভাবে ইতিমধ্যে গণনাকৃতটি অ্যারে থেকে নিয়ে নেব:

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