Project Euler 5 çözümü - İkiden fazla sayının en küçük ortak katı nasıl bulunur?

import math

def asal_mi(sayi): # Öncelikle sayıların asal olup olmadığını kontrol edeceğimiz fonksiyonu yazıyoruz.
    if sayi < 2:
        return False
    for i in range(2, math.isqrt(sayi) + 1):
        if sayi % i == 0:
            return False
    return True

def ilk_n_sayinin_ekoku(n): # 1'den n'ye kadar olan sayıların en küçük ortak katı
    if n < 1:
        return 1

    ekok = 1
    for p in range(2, n + 1):
        if asal_mi(p):
            # Logaritma yerine basit bir döngü ile en yüksek kuvveti bulabiliriz
            # Böylece ondalıklı sayılardan doğabilecek hataları engelleyebiliyoruz.
            en_yuksek_kuvvet = p
            while en_yuksek_kuvvet * p <= n:
                en_yuksek_kuvvet *= p

            ekok *= en_yuksek_kuvvet

    return ekok


n_degeri = 20
sonuc = ilk_n_sayinin_ekoku(n_degeri)
print(sonuc)

fn main() {
    let n_degeri: u64 = 20;
    let sonuc = ilk_n_sayinin_ekoku(n_degeri);
    println!("{}", sonuc);
}

fn asal_mi(sayi: u64) -> bool { // Asallık kontrolü yapan fonksiyonumuz
    if sayi < 2 { return false; }
    let limit = (sayi as f64).sqrt() as u64;
    for i in 2..=limit {
        if sayi % i == 0 { return false; }
    }
    true
}

fn ilk_n_sayinin_ekoku(n: u64) -> u64 {
    if n < 1 { return 1; }
    let mut ekok: u64 = 1;
 
    for p in 2..=n {
        if asal_mi(p) {
            let mut en_yuksek_kuvvet = p;
            while en_yuksek_kuvvet * p <= n {
                en_yuksek_kuvvet *= p;
            }
            ekok *= en_yuksek_kuvvet;
        }
    }
    ekok
}

#include <stdio.h>
#include <stdbool.h>
#include <math.h>

bool asal_mi(unsigned long long sayi) {
    if (sayi < 2) return false;
    unsigned long long limit = sqrt(sayi);
    for (unsigned long long i = 2; i <= limit; i++) {
        if (sayi % i == 0) return false;
    }
    return true;
}

unsigned long long ilk_n_sayinin_ekoku(unsigned long long n) {
    if (n < 1) return 1;
    unsigned long long ekok = 1;
 
    for (unsigned long long p = 2; p <= n; p++) {
        if (asal_mi(p)) {
            unsigned long long en_yuksek_kuvvet = p;
            while (en_yuksek_kuvvet * p <= n) {
                en_yuksek_kuvvet *= p;
            }
            ekok *= en_yuksek_kuvvet;
        }
    }
    return ekok;
}

int main() {
    unsigned long long n_degeri = 20;
    unsigned long long sonuc = ilk_n_sayinin_ekoku(n_degeri);
    printf("%llu\n", sonuc);
    return 0;
}

import math
from functools import reduce


def araligin_ekoku(baslangic, bitis):
    #Belirli bir aralıktaki (başlangıç ve bitiş dahil) ardışık sayıların EKOKunu bulur.
    sayilar = range(baslangic, bitis + 1)

    # reduce fonksiyonu, math.lcm işlemini listedeki tüm sayıları zincirleme uygular.
    # Örneğin lcm(lcm(sayi1, sayi2), sayi3) ... şeklinde devam eder.
    ekok_sonuc = reduce(math.lcm, sayilar)

    return ekok_sonuc


baslangic_degeri = 1
bitis_degeri = 20
sonuc_2 = araligin_ekoku(baslangic_degeri, bitis_degeri)

print(sonuc_2)

fn main() {
    let baslangic: u64 = 1;
    let bitis: u64 = 20;
    let sonuc = araligin_ekoku(baslangic, bitis);
    println!("{}", sonuc);
}

fn ebob(mut a: u64, mut b: u64) -> u64 {
    while b != 0 {
        let gecici = b;
        b = a % b;
        a = gecici;
    }
    a
}

fn iki_sayinin_ekoku(a: u64, b: u64) -> u64 {
    if a == 0 || b == 0 { return 0; }
    // Taşmayı önlemek için önce bölüp sonra çarpıyoruz
    (a / ebob(a, b)) * b
}

fn araligin_ekoku(baslangic: u64, bitis: u64) -> u64 {
    let mut guncel_ekok = baslangic;
    for i in (baslangic + 1)..=bitis {
        guncel_ekok = iki_sayinin_ekoku(guncel_ekok, i);
    }
    guncel_ekok
}

#include <stdio.h>

unsigned long long ebob(unsigned long long a, unsigned long long b) {
    while (b != 0) {
        unsigned long long gecici = b;
        b = a % b;
        a = gecici;
    }
    return a;
}

unsigned long long iki_sayinin_ekoku(unsigned long long a, unsigned long long b) {
    if (a == 0 || b == 0) return 0;
    // Yine taşmayı önlemek için aynı işlemi yapıyoruz
    return (a / ebob(a, b)) * b;
}

unsigned long long araligin_ekoku(unsigned long long baslangic, unsigned long long bitis) {
    unsigned long long guncel_ekok = baslangic;
    for (unsigned long long i = baslangic + 1; i <= bitis; i++) {
        guncel_ekok = iki_sayinin_ekoku(guncel_ekok, i);
    }
    return guncel_ekok;
}

int main() {
    unsigned long long baslangic = 1;
    unsigned long long bitis = 20;
    unsigned long long sonuc = araligin_ekoku(baslangic, bitis);
    printf("%llu\n", sonuc);
    return 0;
}