🧮 Algorytmy

Sortowanie bąbelkowe

fn bubbleSort(arr) {
    let n = size(arr);
    for (i in 0..<n) {
        for (j in 0..<(n - i - 1)) {
            if (arr[j] > arr[j + 1]) {
                let temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
    return arr;
}

let numbers = [64, 34, 25, 12, 22, 11, 90];
print(bubbleSort(numbers));
        

Wyszukiwanie binarne

fn binarySearch(arr, target) {
    let left = 0;
    let right = size(arr) - 1;

    while (left <= right) {
        let mid = floor((left + right) / 2);

        if (arr[mid] == target) {
            return mid;
        }

        if (arr[mid] < target) {
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }

    return -1;  // Nie znaleziono
}

let sorted = [1, 3, 5, 7, 9, 11, 13, 15];
print(binarySearch(sorted, 7));  // 3
        

Silnia (rekurencja)

fn factorial(n) {
    if (n <= 1) return 1;
    return n * factorial(n - 1);
}

print(factorial(10));  // 3628800
        

Fibonacci z memoizacją

let cache = {};

fn fib(n) {
    if (n <= 1) return n;

    let key = toString(n);
    if (cache[key] != null) {
        return cache[key];
    }

    cache[key] = fib(n - 1) + fib(n - 2);
    return cache[key];
}

for (i in 0..20) {
    print(`fib(${i}) = ${fib(i)}`);
}
        

Sito Eratostenesa

fn sieve(max) {
    let isPrime = [true] * (max + 1);
    isPrime[0] = false;
    isPrime[1] = false;

    for (i in 2..max) {
        if (isPrime[i]) {
            let j = i * 2;
            while (j <= max) {
                isPrime[j] = false;
                j = j + i;
            }
        }
    }

    return [i for i in 0..max if isPrime[i]];
}

print(sieve(50));
// [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47]
        

QuickSort

fn quickSort(arr) {
    if (size(arr) <= 1) return arr;

    let pivot = arr[0];
    let less = arr.filter(x => x < pivot);
    let equal = arr.filter(x => x == pivot);
    let greater = arr.filter(x => x > pivot);

    return quickSort(less).concat(equal).concat(quickSort(greater));
}

print(quickSort([3, 6, 8, 10, 1, 2, 1]));
        