Ước Số – Bội Số – UCLN – BCNN và Các Bài Toán Ứng Dụng

int main(){
    long long n, cnt = 0;
    cin >> n;
    for(long long i=1;i<=n;i++)
        if(n % i == 0) cnt++;
    cout << cnt;
}

def count_divisors_naive(n):
    return sum(1 for i in range(1, n+1) if n % i == 0)

for(long long i = 1; i*i <= n; i++){
    if(n % i == 0){
        cnt++;
        if(i != n/i) cnt++;
    }
}

import math

def count_divisors(n):
    cnt = 0
    for i in range(1, int(math.sqrt(n)) + 1):
        if n % i == 0:
            cnt += 1
            if i != n // i:
                cnt += 1
    return cnt

print(count_divisors(100))  # 9

#include <bits/stdc++.h>
using namespace std;

// Đếm số ước bằng phân tích thừa số
long long count_divisors(long long n) {
    long long ans = 1;
    for (long long p = 2; p * p <= n; p++) {
        if (n % p == 0) {
            int exp = 0;
            while (n % p == 0) {
                n /= p;
                exp++;
            }
            ans *= (exp + 1);
        }
    }
    if (n > 1) ans *= 2; // n còn lại là số nguyên tố
    return ans;
}

int main() {
    long long n;
    cin >> n;

    cout << count_divisors(n);
    return 0;
}

import math

def count_divisors(n):
    ans = 1
    p = 2
    while p * p <= n:
        if n % p == 0:
            exp = 0
            while n % p == 0:
                n //= p
                exp += 1
            ans *= (exp + 1)
        p += 1
    if n > 1:
        ans *= 2
    return ans

# main
n = int(input())
print(count_divisors(n))

    #include <bits/stdc++.h>
    using namespace std;
    
    int gcd_naive(int a, int b) {
        int limit = min(a, b);
        for (int d = limit; d >= 1; d--) {
            if (a % d == 0 && b % d == 0)
                return d;
        }
        return 1; // nếu không có ước chung lớn hơn
    }
    
    int main() {
        int a, b;
        cin >> a >> b;
        cout << gcd_naive(a, b);
        return 0;
    }
    

    def gcd_naive(a, b):
        limit = min(a, b)
        for d in range(limit, 0, -1):
            if a % d == 0 and b % d == 0:
                return d
        return 1
    
    # main
    a, b = map(int, input().split())
    print(gcd_naive(a, b))
    

#include <bits/stdc++.h>
using namespace std;

// Hàm phân tích thừa số trả về map {prime -> exponent}
map<int,int> factorize(long long n) {
    map<int,int> res;
    for (long long i = 2; i * i <= n; i++) {
        while (n % i == 0) {
            res[i]++;
            n /= i;
        }
    }
    if (n > 1) res[n]++;
    return res;
}

long long gcd_factor(long long a, long long b) {
    auto fa = factorize(a);
    auto fb = factorize(b);

    long long g = 1;
    for (auto &p : fa) {
        int prime = p.first;
        if (fb.count(prime)) {
            int times = min(p.second, fb[prime]);
            while (times--) g *= prime;
        }
    }
    return g;
}

int main() {
    long long a, b;
    cin >> a >> b;
    cout << gcd_factor(a, b);
    return 0;
}

def factorize(n):
    res = {}
    i = 2
    while i * i <= n:
        while n % i == 0:
            res[i] = res.get(i, 0) + 1
            n //= i
        i += 1
    if n > 1:
        res[n] = 1
    return res

def gcd_factor(a, b):
    fa = factorize(a)
    fb = factorize(b)

    g = 1
    for p in fa:
        if p in fb:
            times = min(fa[p], fb[p])
            g *= p ** times
    return g

# main
a, b = map(int, input().split())
print(gcd_factor(a, b))

#include <bits/stdc++.h>
using namespace std;

int gcd_euclid(int a, int b) {
    while (b != 0) {
        int r = a % b; 
        a = b;
        b = r;
    }
    return a;
}

int main() {
    int a, b;
    cin >> a >> b;
    cout << gcd_euclid(a, b);
    return 0;
}

def gcd_euclid(a, b):
    while b != 0:
        a, b = b, a % b
    return a

# main
a, b = map(int, input().split())
print(gcd_euclid(a, b))

#include <bits/stdc++.h>
#include <numeric>     // chứa std::gcd. Đưa để giới thiệu, không cần viết
using namespace std;

int main(){
    long long a, b;
    cin >> a >> b;

    long long g = gcd(a, b);   // hoặc std::gcd(a, b)
    cout << g;
}

import math

a, b = map(int, input().split())
print(math.gcd(a, b))

long long lcm_naive(long long a, long long b){
    long long x = max(a, b);
    while(true){
        if(x % a == 0 && x % b == 0)
            return x;
        x += max(a, b);
    }
}

int main(){
    long long a, b;
    cin >> a >> b;
    cout << lcm_naive(a, b);
}

def lcm_naive(a, b):
    x = max(a, b)
    while True:
        if x % a == 0 and x % b == 0:
            return x
        x += max(a, b)

a, b = map(int, input().split())
print(lcm_naive(a, b))

long long gcd(long long a, long long b){
    while(b != 0){
        long long r = a % b;
        a = b;
        b = r;
    }
    return a;
}

long long lcm(long long a, long long b){
    return a / gcd(a, b) * b;
}

int main(){
    long long a, b;
    cin >> a >> b;
    cout << lcm(a, b);
}

def gcd(a, b):
    while b != 0:
        a, b = b, a % b
    return a

def lcm(a, b):
    return a // gcd(a, b) * b

a, b = map(int, input().split())
print(lcm(a, b))

#include <bits/stdc++.h>
using namespace std;

int main(){
    long long a, b;
    cin >> a >> b;
    cout << lcm(a, b);  // từ 
}