مجموعه الگوریتم جاوااسکریپت – سطح Junior

بررسی عدد اول

function isPrime(num) {
    if (num <= 1) return false;
    for (let i = 2; i < num; i++) {
        if (num % i === 0) return false;
    }
    return true;
}
console.log(isPrime(7)); // true

پیدا کردن بزرگترین عدد در یک آرایه

function findLargest(arr) {
    return Math.max(...arr);
}
console.log(findLargest([3, 5, 9, 2])); // 9

معکوس کردن یک رشته

function reverseString(str) {
    return str.split('').reverse().join('');
}
console.log(reverseString("hello")); // "olleh"

فاکتوریل یک عدد

function factorial(n) {
    if (n === 0) return 1;
    return n * factorial(n - 1);
}
console.log(factorial(5)); // 120

مجموع ارقام یک عدد

function sumOfDigits(num) {
    return num.toString().split('').reduce((sum, digit) => sum + parseInt(digit), 0);
}
console.log(sumOfDigits(123)); // 6

چک کردن عدد پالیندروم (واروخوانه)

function isPalindrome(num) {
    const str = num.toString();
    return str === str.split('').reverse().join('');
}
console.log(isPalindrome(121)); // true

ایجاد دنباله فیبوناچی

function fibonacci(n) {
    const sequence = [0, 1];
    for (let i = 2; i <= n; i++) {
        sequence.push(sequence[i - 1] + sequence[i - 2]);
    }
    return sequence;
}
console.log(fibonacci(5)); // [0, 1, 1, 2, 3]

فیبوناچی به صورت بازگشتی

function fibonacciRecursive(n) {
    if (n <= 1) return n;
    return fibonacciRecursive(n - 1) + fibonacciRecursive(n - 2);
}
console.log(fibonacciRecursive(5)); // 5

مرتب سازی حبابی

function bubbleSort(arr) {
    let swapped;
    do {
        swapped = false;
        for (let i = 0; i < arr.length - 1; i++) {
            if (arr[i] > arr[i + 1]) {
                [arr[i], arr[i + 1]] = [arr[i + 1], arr[i]];
                swapped = true;
            }
        }
    } while (swapped);
    return arr;
}
console.log(bubbleSort([3, 1, 5, 2])); // [1, 2, 3, 5]

مرتب سازی سریع

function quickSort(arr) {
    if (arr.length <= 1) return arr;
    const pivot = arr[arr.length - 1];
    const left = arr.filter((x) => x < pivot);
    const right = arr.filter((x) => x > pivot);
    return [...quickSort(left), pivot, ...quickSort(right)];
}
console.log(quickSort([3, 6, 8, 1, 5])); // [1, 3, 5, 6, 8]

جستجوی دودویی

function binarySearch(arr, target) {
    let start = 0, end = arr.length - 1;
    while (start <= end) {
        let mid = Math.floor((start + end) / 2);
        if (arr[mid] === target) return mid;
        else if (arr[mid] < target) start = mid + 1;
        else end = mid - 1;
    }
    return -1;
}
console.log(binarySearch([1, 2, 3, 4, 5], 3)); // 2

پیدا کردن کوچکترین عدد در یک آرایه

function findSmallest(arr) {
    return Math.min(...arr);
}
console.log(findSmallest([3, 5, 9, 2])); // 2

حذف عناصر تکراری از آرایه

function removeDuplicates(arr) {
    return [...new Set(arr)];
}
console.log(removeDuplicates([1, 2, 2, 3, 3])); // [1, 2, 3]

محاسبه توان عدد

function power(base, exponent) {
    return Math.pow(base, exponent);
}
console.log(power(2, 3)); // 8

الگوریتم Euclid برای یافتن بزرگترین مقسوم‌علیه مشترک (GCD)

function gcd(a, b) {
    while (b !== 0) {
        [a, b] = [b, a % b];
    }
    return a;
}
console.log(gcd(48, 18)); // 6

چک کردن تساوی آرایه ها

function arraysEqual(arr1, arr2) {
    if (arr1.length !== arr2.length) return false;
    return arr1.every((val, index) => val === arr2[index]);
}
console.log(arraysEqual([1, 2, 3], [1, 2, 3])); // true

چک کردن آناگرام (واروواژه) بودن دو رشته

function areAnagrams(str1, str2) {
    const sortedStr1 = str1.split('').sort().join('');
    const sortedStr2 = str2.split('').sort().join('');
    return sortedStr1 === sortedStr2;
}
console.log(areAnagrams("listen", "silent")); // true

پیدا کردن دومین بزرگترین عدد در آرایه

function secondLargest(arr) {
    let uniqueArr = [...new Set(arr)].sort((a, b) => b - a);
    return uniqueArr[1];
}
console.log(secondLargest([1, 3, 4, 5, 2])); // 4

تبدیل یک رشته به حروف کوچک

function toLowerCase(str) {
    return str.toLowerCase();
}
console.log(toLowerCase("Hello World")); // "hello world"

حذف اعداد تکراری از یک آرایه

function removeDuplicateNumbers(arr) {
    return arr.filter((item, index) => arr.indexOf(item) === index);
}
console.log(removeDuplicateNumbers([1, 2, 2, 3, 3, 4])); // [1, 2, 3, 4]