Wiki › Thuật toán › Toán học › Chia khối theo thương và tổng floor

Chia khối theo thương và tổng floor

Tính các tổng dạng sum f(i) * floor(n/i) trong O(sqrt n) bằng chia khối theo thương (kể cả hai biến và hàm trần), và thuật toán floor_sum kiểu Euclid tính sum floor((a*i+b)/m) trong O(log m) để đếm điểm nguyên dưới đường thẳng.

huunguyen huunguyen Updated Tháng 11. 17, 2026 Đọc 21 phút 4 lượt xem

Rất nhiều công thức số học có dạng ∑i=1nf(i)⌊ni⌋: tổng số ước của 1..n, tổng các phần dư nmodi, số cặp nguyên tố cùng nhau qua hàm Möbius, tổng gcd qua hàm Euler. Tính trực tiếp tốn O(n), quá chậm khi n=1012. Chia khối theo thương (division blocking) dựa trên một quan sát đơn giản: ⌊n/i⌋ chỉ nhận không quá 2n giá trị khác nhau, và các i cùng thương tạo thành một đoạn liên tiếp, nên cả tổng chỉ còn O(n) khối. Trang này cũng trình bày một công cụ "họ hàng": thuật toán floor_sum tính ∑i=0n−1⌊ai+bm⌋ trong O(logm) bằng một vòng lặp giống thuật toán Euclid, dùng để đếm điểm nguyên dưới một đường thẳng.

Ý tưởng / Trực giác

Vì sao chỉ có O(n) giá trị. Chia các i∈[1,n] làm hai nhóm:

  • i≤n: có không quá n số i, nên không quá n giá trị thương.
  • i>n: thương ⌊n/i⌋<n, nên cũng chỉ có không quá n giá trị.

Tổng cộng không quá 2n giá trị phân biệt.

Vì sao biên phải của khối là r=⌊n/⌊n/l⌋⌋. Hàm i↦⌊n/i⌋ không tăng, nên các i có cùng thương q đứng liền nhau. Với q≥1:

⌊ni⌋≥q⟺ni≥q⟺i≤nq⟺i≤⌊nq⌋.

Vậy ⌊n/q⌋ là chỉ số lớn nhất còn có thương ≥q. Bắt đầu khối tại l với q=⌊n/l⌋, khối kết thúc tại r=⌊n/q⌋, rồi khối sau bắt đầu ở r+1.

Tổng có trọng số. Trong khối [l,r] thương là hằng số q, nên

∑i=lrf(i)⌊ni⌋=q·(F(r)−F(l−1)),F(x)=∑i=1xf(i).

Chỉ cần tính nhanh tổng tiền tố F của trọng số: f(i)=1 thì F(x)=x; f(i)=i thì F(x)=x(x+1)/2; f=μ hoặc f=φ thì sàng sẵn mảng tiền tố (xem Hàm nhân tính), còn khi n quá lớn để sàng thì dùng các kỹ thuật tính tiền tố hàm nhân tính dưới tuyến tính như ở trang Đếm số nguyên tố, vốn cũng chỉ cần giá trị tại các điểm ⌊n/i⌋.

Hai biến. Với tổng chứa đồng thời ⌊n/i⌋ và ⌊m/i⌋, một khối phải giữ nguyên cả hai thương, nên lấy biên phải nhỏ hơn:

r=min(⌊n⌊n/l⌋⌋,⌊m⌊m/l⌋⌋).

Mỗi điểm cắt khối là một điểm cắt của dãy n/i hoặc của dãy m/i, nên số khối không quá 2n+2m.

floor_sum: đếm điểm nguyên theo hai chiều. Với a,b≥0, m≥1, đặt

S(n,m,a,b)=∑i=0n−1⌊ai+bm⌋.

Đây là số điểm nguyên (i,j) với 0≤i<n, 1≤j và mj≤ai+b, tức số điểm nguyên nằm dưới đường thẳng y=(ax+b)/m (không tính trục hoành). Thuật toán lặp hai bước:

  1. Tách phần nguyên. Nếu a≥m, viết a=⌊a/m⌋m+(amodm): mỗi số hạng được cộng thêm ⌊a/m⌋·i, tổng là ⌊a/m⌋·n(n−1)2. Tương tự nếu b≥m thì cộng ⌊b/m⌋·n. Sau bước này a,b<m.
  2. Đếm theo hàng thay vì theo cột. Đặt ymax=an+b và K=⌊ymax/m⌋ (số hàng j có điểm). Nếu K=0 thì mọi số hạng còn lại bằng 0, dừng. Ngược lại, ở hàng j (1≤j≤K), các cột hợp lệ là ⌈mj−ba⌉≤i≤n−1, nên số điểm là n−⌈mj−ba⌉=⌊an+b−mja⌋=⌊ymax−mja⌋. Đổi biến j′=K−j (chạy từ 0 đến K−1), ta có ymax−mj=(ymaxmodm)+mj′, do đó S(n,m,a,b)=(phần đã tách)+S(K, a, m, ymaxmodm).

Bài toán mới có mô-đun là a và hệ số là m: cặp (m,a) biến thành (a,m), rồi ở vòng sau bước 1 rút m về mmoda. Đó đúng là một bước của thuật toán Euclid, nên số vòng lặp là O(logmin(a,m)).

Ví dụ chạy tay

Các khối của n=10.

i 1 2 3 4 5 6 7 8 9 10
⌊10/i⌋ 10 5 3 2 2 1 1 1 1 1

Mảng dưới đây chạy từng khối, ô i chứa giá trị ⌊10/i⌋:

array
10
10 5 3 2 2 1 1 1 1 1
step l = 1: q = 10/1 = 10, r = 10/10 = 1
highlight red 1
pointer l 1
pointer r 1
step l = 2: q = 5, r = 10/5 = 2
highlight orange 2
pointer l 2
pointer r 2
step l = 3: q = 3, r = 10/3 = 3
highlight green 3
pointer l 3
pointer r 3
step l = 4: q = 2, r = 10/2 = 5
highlight blue 4..5
pointer l 4
pointer r 5
step l = 6: q = 1, r = 10/1 = 10, xong
highlight purple 6..10
pointer l 6
pointer r 10
khối [l,r] q ∑1·q ∑i·q
[1,1] 10 10 1·10=10
[2,2] 5 5 2·5=10
[3,3] 3 3 3·3=9
[4,5] 2 2·2=4 (4+5)·2=18
[6,10] 1 5·1=5 (6+⋯+10)·1=40
tổng 27 87

27=∑i≤10⌊10/i⌋ là tổng số ước của 1..10 (1+2+2+3+2+4+2+4+3+4), còn 87=∑i≤10i⌊10/i⌋ là tổng các tổng ước σ(1)+⋯+σ(10). Chỉ 5 khối thay vì 10 số hạng; với n=1012 là khoảng 2·106 khối thay vì 1012 số hạng.

Đếm cặp nguyên tố cùng nhau với n=m=10. Theo nghịch đảo Möbius, số cặp (i,j)∈[1,n]×[1,m] có gcd(i,j)=1 là ∑dμ(d)⌊n/d⌋⌊m/d⌋. Với μ(1..10)=1,−1,−1,0,−1,1,−1,0,0,1, tiền tố Mertens M(d)=1,0,−1,−1,−2,−1,−2,−2,−2,−1:

khối [l,r] ⌊10/l⌋2 M(r)−M(l−1) đóng góp
[1,1] 100 1−0=1 100
[2,2] 25 0−1=−1 −25
[3,3] 9 −1−0=−1 −9
[4,5] 4 −2−(−1)=−1 −4
[6,10] 1 −1−(−2)=1 1

Tổng 100−25−9−4+1=63. Nếu n=10, m=6 thì các khối hai biến là [1,1],[2,2],[3,3],[4,5],[6,6] (khối [6,10] của n bị cắt tại min(n,m)=6), cho đáp án 38.

floor_sum với n=5, m=3, a=2, b=1. Các số hạng ⌊(2i+1)/3⌋ với i=0..4 là 0,1,1,2,3, tổng 7. Bảng dưới vẽ các điểm được đếm (ô #), cột là i=0..4, hàng trên cùng là j=3:

grid
....#
...##
.####
label 1,5 j=3
label 2,5 j=2
label 3,5 j=1

Đếm theo cột: 0+1+1+2+3=7. Đếm theo hàng: hàng j=1,2,3 có lần lượt 4,2,1 điểm, đúng bằng ⌊(11−3j)/2⌋ với ymax=2·5+1=11. Thuật toán chạy như sau:

vòng (n,m,a,b) tách a≥m tách b≥m ymax trạng thái mới
1 (5,3,2,1) không không 11 n=3, b=2, đổi chỗ: (3,2,3,2)
2 (3,2,3,2) +3·1=3, a=1 +3·1=3, b=0 3 n=1, b=1, đổi chỗ: (1,1,2,1)
3 (1,1,2,1) +0, a=0 +1·1=1, b=0 0 ymax<m, dừng

Kết quả 3+3+1=7. Ở vòng 2, S(3,2,3,2)=⌊2/2⌋+⌊5/2⌋+⌊8/2⌋=1+2+4=7: đúng là đếm hàng j=3,2,1 của hình trên theo thứ tự ngược.

Cài đặt

Duyệt khối một biến. Chương trình đọc n, in từng khối l r q, rồi in ∑⌊n/i⌋ và ∑i⌊n/i⌋ (chính xác với n≤109). Với đầu vào 10 nó in đúng năm khối ở bảng trên và dòng cuối 27 87.

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

int main() {
    long long n;
    cin >> n;
    long long divisorCountSum = 0;   // sum_{i=1}^{n} floor(n/i)
    long long divisorSigmaSum = 0;   // sum_{i=1}^{n} i * floor(n/i), exact for n <= 1e9
    for (long long l = 1, r; l <= n; l = r + 1) {
        long long q = n / l;
        r = n / q;                   // last i with floor(n/i) == q
        cout << l << ' ' << r << ' ' << q << '\n';
        divisorCountSum += (r - l + 1) * q;
        // sum of i over [l, r] is (l + r) * (r - l + 1) / 2
        divisorSigmaSum += (l + r) * (r - l + 1) / 2 * q;
    }
    cout << divisorCountSum << ' ' << divisorSigmaSum << '\n';
}
Python
import sys


def main():
    n = int(sys.stdin.readline())
    count_sum = 0  # sum_{i=1}^{n} floor(n/i)
    sigma_sum = 0  # sum_{i=1}^{n} i * floor(n/i)
    l = 1
    while l <= n:
        q = n // l
        r = n // q  # last i with floor(n/i) == q
        print(l, r, q)
        count_sum += (r - l + 1) * q
        sigma_sum += (l + r) * (r - l + 1) // 2 * q
        l = r + 1
    print(count_sum, sigma_sum)


main()

Khối hai biến: đếm cặp nguyên tố cùng nhau. Đọc Q truy vấn (n,m), sàng μ tuyến tính, lấy tiền tố rồi chia khối theo cả ⌊n/d⌋ và ⌊m/d⌋. Với đầu vào 4 / 10 10 / 5 5 / 3 7 / 6 6 chương trình in 63, 19, 16, 23.

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

int main() {
    int Q;
    cin >> Q;
    vector<pair<int, int>> qs(Q);
    int maxN = 1;
    for (auto& [n, m] : qs) {
        cin >> n >> m;
        maxN = max(maxN, min(n, m));
    }
    // Linear sieve for Mobius, then prefix sums M[d] = mu(1) + ... + mu(d)
    vector<int> mu(maxN + 1, 0), primes;
    vector<bool> composite(maxN + 1, false);
    mu[1] = 1;
    for (int i = 2; i <= maxN; i++) {
        if (!composite[i]) { primes.push_back(i); mu[i] = -1; }
        for (int p : primes) {
            if ((long long)i * p > maxN) break;
            composite[i * p] = true;
            if (i % p == 0) { mu[i * p] = 0; break; }
            mu[i * p] = -mu[i];
        }
    }
    vector<long long> M(maxN + 1, 0);
    for (int d = 1; d <= maxN; d++) M[d] = M[d - 1] + mu[d];

    for (auto [n, m] : qs) {
        // pairs (i, j), 1 <= i <= n, 1 <= j <= m, gcd = 1
        // = sum_d mu(d) * floor(n/d) * floor(m/d), grouped by blocks of (n/d, m/d)
        long long ans = 0;
        int lim = min(n, m);
        for (int l = 1, r; l <= lim; l = r + 1) {
            r = min(n / (n / l), m / (m / l));   // both quotients stay constant on [l, r]
            ans += (M[r] - M[l - 1]) * (long long)(n / l) * (m / l);
        }
        cout << ans << '\n';
    }
}
Python
import sys


def main():
    data = sys.stdin.read().split()
    Q = int(data[0])
    qs = [(int(data[1 + 2 * k]), int(data[2 + 2 * k])) for k in range(Q)]
    max_n = max(1, max(min(n, m) for n, m in qs))
    # Linear sieve for Mobius, then prefix sums M[d]
    mu = [0] * (max_n + 1)
    mu[1] = 1
    composite = [False] * (max_n + 1)
    primes = []
    for i in range(2, max_n + 1):
        if not composite[i]:
            primes.append(i)
            mu[i] = -1
        for p in primes:
            if i * p > max_n:
                break
            composite[i * p] = True
            if i % p == 0:
                mu[i * p] = 0
                break
            mu[i * p] = -mu[i]
    M = [0] * (max_n + 1)
    for d in range(1, max_n + 1):
        M[d] = M[d - 1] + mu[d]

    out = []
    for n, m in qs:
        ans = 0
        lim = min(n, m)
        l = 1
        while l <= lim:
            r = min(n // (n // l), m // (m // l))  # both quotients constant on [l, r]
            ans += (M[r] - M[l - 1]) * (n // l) * (m // l)
            l = r + 1
        out.append(ans)
    print("\n".join(map(str, out)))


main()

floor_sum. Đọc q bộ (n,m,a,b) và in ∑i=0n−1⌊(ai+b)/m⌋. Với đầu vào 3 / 5 3 2 1 / 4 10 6 3 / 1000000000 999999937 999999929 999999921 chương trình in 7, 3, 499999995999999705.

C++
#include <bits/stdc++.h>
using namespace std;
using ull = unsigned long long;

// sum_{i=0}^{n-1} floor((a*i + b) / m), requires n, m >= 1 and a, b >= 0.
// Euclid-like: reduce a, b below m, then swap the roles of a and m.
// Values are kept below 2^64 as long as n, m, a, b < 2^32 (AtCoder Library style).
ull floor_sum(ull n, ull m, ull a, ull b) {
    ull ans = 0;
    while (true) {
        if (a >= m) {                 // floor((a i + b)/m) gets (a/m) * i extra
            ans += n * (n - 1) / 2 * (a / m);
            a %= m;
        }
        if (b >= m) {                 // and (b/m) extra on every term
            ans += n * (b / m);
            b %= m;
        }
        ull y_max = a * n + b;        // the line value just past the last column
        if (y_max < m) break;         // every remaining term is 0
        // count the same lattice points row by row: n' = y_max/m, b' = y_max%m, swap m and a
        n = y_max / m;
        b = y_max % m;
        swap(m, a);
    }
    return ans;
}

int main() {
    int q;
    cin >> q;
    while (q--) {
        ull n, m, a, b;
        cin >> n >> m >> a >> b;
        cout << floor_sum(n, m, a, b) << '\n';
    }
}
Python
import sys


def floor_sum(n, m, a, b):
    """sum_{i=0}^{n-1} (a*i + b) // m, with n, m >= 1 and a, b >= 0."""
    ans = 0
    while True:
        if a >= m:
            ans += n * (n - 1) // 2 * (a // m)
            a %= m
        if b >= m:
            ans += n * (b // m)
            b %= m
        y_max = a * n + b
        if y_max < m:
            break
        n, b = divmod(y_max, m)
        m, a = a, m
    return ans


def main():
    data = sys.stdin.read().split()
    q = int(data[0])
    out = []
    for k in range(q):
        n, m, a, b = map(int, data[1 + 4 * k: 5 + 4 * k])
        out.append(floor_sum(n, m, a, b))
    print("\n".join(map(str, out)))


main()

Độ phức tạp

Thao tác Thời gian Bộ nhớ
Duyệt khối ⌊n/i⌋, i=1..n O(n) lần tính tiền tố F O(1)
Khối hai biến ⌊n/i⌋,⌊m/i⌋ O(n+m) O(1)
Đếm cặp nguyên tố cùng nhau, Q truy vấn O(N+QN) với N=maxmin(n,m) O(N) cho sàng
floor_sum O(logmin(a,m)) sau khi tách amodm O(1)

Vì sao duyệt khối là O(n)? Mỗi vòng lặp xử lý trọn một giá trị thương, và theo lập luận hai nhóm ở trên có không quá 2n giá trị. Nếu tiền tố F(r) tính được trong O(1) (công thức đóng hoặc mảng sàng sẵn) thì cả tổng là O(n).

Vì sao floor_sum là O(log)? Mỗi vòng biến cặp (m,a) thành (a,mmoda) ở vòng sau, giống hệt một bước Euclid, nên số vòng bị chặn bởi số bước Euclid trên (m,a), tức O(logmin(a,m)). Mỗi vòng O(1) phép tính.

⚠️ Lỗi thường gặp

  • Chia cho 0 khi chặn trên khác n. Nếu tổng chạy i=1..m với m>n (ví dụ ∑i≤mnmodi), thì khi l>n ta có ⌊n/l⌋=0 và n/(n/l) chia cho 0. Cách tránh: chỉ chia khối tới min(n,m), phần i>n có thương 0 xử lý riêng (ở đó nmodi=n). Với hai biến, dừng ở min(n,m) vì sau đó một trong hai thương bằng 0.
  • Nhầm biên khối của hàm trần. Áp nguyên công thức r=n/⌈n/l⌉ cho ⌈n/i⌉ là sai: với n=10, l=3 thì ⌈10/3⌉=4 nhưng 10/4=2<l, vòng lặp đi lùi hoặc lặp vô hạn. Cách đúng là dùng ⌈n/i⌉=⌊(n−1)/i⌋+1 và chia khối trên n−1, cẩn thận khi ⌊(n−1)/l⌋=0 (từ đó trở đi thương trần bằng 1):

    for (long long l = 1, r; l <= n; l = r + 1) {
        long long k = (n - 1) / l;              // ceil(n/l) = k + 1
        r = (k == 0) ? n : min(n, (n - 1) / k);
        // every i in [l, r] has ceil(n/i) == k + 1
    }
    

    Với n=10 các khối là [1,1]→10, [2,2]→5, [3,3]→4, [4,4]→3, [5,9]→2, [10,10]→1.

  • Tràn số khi nhân trong khối. (r−l+1)·q thì an toàn (≤n), nhưng (l+r)(r−l+1)2·q với n=1012 vượt 263. Lấy modulo trước khi nhân, hoặc dùng __int128. Với công thức x(x+1)/2 theo modulo, chia 2 trên số nguyên trước khi lấy modulo (một trong x, x+1 chẵn) chứ không chia sau khi đã lấy modulo.
  • Nhân q với số hạng sai. Trong khối [l,r] phải dùng F(r)−F(l−1), không phải F(r)−F(l) hay f(l)·(r−l+1). Quên điều này chỉ sai khi khối dài hơn 1, nên test với n nhỏ (khối toàn độ dài 1) không phát hiện được; hãy so với brute force ở n≈100.
  • sqrt số thực lệch. Lời giải kiểu 2∑i≤k⌊n/i⌋−k2 cần k=⌊n⌋ chính xác; với n gần 1012 trở lên sqrt có thể lệch 1. Chỉnh lại bằng while (k * k > n) k--; while ((k + 1) * (k + 1) <= n) k++;. Duyệt khối với r=n/(n/l) thì không cần căn nên tránh được lỗi này.
  • floor_sum với đối số âm. Phép / của C++ cắt về 0, không làm tròn xuống, và phiên bản không dấu ở trên giả sử a,b≥0. Nếu b<0 (hoặc a<0), chuẩn hoá trước: cộng một bội của m vào b rồi trừ lại phần đã cộng, ví dụ ⌊(x+km)/m⌋=⌊x/m⌋+k; với a<0 thay a bằng amodm (dương) và bù ⌊a/m⌋·n(n−1)2.
  • floor_sum tràn 64 bit. Bản unsigned long long an toàn khi n,m<232 và đáp án vừa 64 bit; khi đầu vào có a≫m, đáp án thật có thể lớn hơn 264 và kết quả chỉ đúng theo modulo 264. Nếu đề yêu cầu modulo p, hãy lấy modulo ở các phép cộng phần tách, còn phép biến đổi (n,m,a,b) vẫn giữ số nguyên thật.

Biến thể / Mở rộng

  • Số ước và tổng ước của 1..n: ∑x≤nd(x)=∑i⌊n/i⌋ và ∑x≤nσ(x)=∑ii⌊n/i⌋. Tổng phần dư ∑i≤m(nmodi)=∑i(n−i⌊n/i⌋) quy về cùng dạng.
  • Tổng có thương lồng nhau: ⌊⌊n/a⌋/b⌋=⌊n/(ab)⌋, nên tập {⌊n/i⌋} đóng với phép "chia tiếp". Đây là lý do các thuật toán tính tiền tố hàm nhân tính (Mertens, đếm số nguyên tố kiểu Lucy, min25) chỉ cần lưu giá trị tại O(n) điểm ⌊n/i⌋; xem Đếm số nguyên tố.
  • Möbius và Euler: #{gcd(i,j)=1}=∑dμ(d)⌊n/d⌋⌊m/d⌋, ∑i,j≤ngcd(i,j)=∑dφ(d)⌊n/d⌋2, #{gcd(a1..ak)=1}=∑dμ(d)⌊n/d⌋k. Nền tảng tích Dirichlet và nghịch đảo Möbius ở Hàm nhân tính; bản chất "cộng trừ theo ước" là bao hàm loại trừ.
  • Tối ưu trên khối: khi cần max hoặc min của biểu thức chứa ⌊n/x⌋, giá trị tối ưu thường nằm ở biên các khối, nên chỉ cần thử O(n) ứng viên.
  • Điểm nguyên dưới đường thẳng và số dư tuyến tính: số i<n có (ai+b)modm≤c bằng S(n,m,a,b)−S(n,m,a,b+m−c−1)+n. Tổng ∑(ai+b)modm=∑(ai+b)−m·S(n,m,a,b). Tổng quát hơn, các tổng ∑i⌊·⌋, ∑⌊·⌋2 cũng có truy hồi kiểu Euclid ("universal Euclidean"). Khai triển liên phân số của a/m trong thuật toán chính là đường đi trên cây Stern-Brocot.

Bài tập luyện

  • Tổng số ước (dhbb25dx4110_tongsouoc): (Trung bình) Tổng số ước của các số trong [L,R] với R≤1012: đáp án D(R)−D(L−1) với D(n)=∑⌊n/i⌋, đúng bài mẫu đầu tiên của kỹ thuật.
  • Đếm cặp nguyên tố cùng nhau trên lưới (coprgrid): (Trung bình) Đếm cặp (i,j)∈[1,n]×[1,m] nguyên tố cùng nhau qua ∑μ(d)⌊n/d⌋⌊m/d⌋, luyện khối hai biến với tiền tố Möbius.
  • Jzzhu và Thanh Sô Cô La (jzzchoco): (Khó) Tối đa ⌊n/a⌋·⌊m/b⌋ với a+b cố định; nghiệm tối ưu nằm ở biên khối, chỉ thử O(n+m) ứng viên.
  • Tổng phần dư (sumrem): (Rất khó) Tính ∑i≤mnmodi với n,m≤1013 theo modulo: tổng có trọng số i⌊n/i⌋, phải xử lý m>n và tràn số khi nhân.
  • Đếm số dư nhỏ (ck10flr): (Rất khó) Đếm i<n với (ai+b)modm≤c cho 105 truy vấn, quy về hiệu hai lần floor_sum.
  • Hàm Mertens (mertens): (Chuyên gia) Tính M(N)=∑i≤Nμ(i) với N≤109 qua truy hồi M(x)=1−∑d≥2M(⌊x/d⌋), chia khối theo d và ghi nhớ trên tập O(N) giá trị ⌊N/i⌋.
Trang này có hữu ích không? Đăng nhập để trả lời

Bình luận

Không có bình luận tại thời điểm này.

gnatmake 12.2.0 a68g 3.1.2 nasm 2.16.1 as_x64 2.47 awk 1.3.4 gcc 16.2.0 dotnet 10.0.402 g++ 16.2.0 g++-themis 16.2.0 g++17 16.2.0 g++20 16.2.0 g++23 16.2.0 clang++ 22.1.8 dmd 2.113.0 dart 3.13.6 gforth 0.7.3 gfortran 15.3.0 go 1.27.3 groovyc 5.1.3 javac 26.0.2.1 node 26.12.1 julia 1.13.2 kotlinc 2.4.21 lean 4.35.0 sbcl 2.2.9 lua 5.5.1 nim 2.2.12 fpc 3.2.2 fpc-themis 3.2.2 perl 5.42.3 php 8.5.12 pike 8.0 swipl 9.0.4 pypy3 7.3.23 python3 3.15.1 racket 8.7 ruby 4.0.8 rustc 1.99.1 csc 5.3.0 ctoj-scratch 0.0.1 sed 4.9 swiftc 6.4.1 tclsh 8.6 bun 1.4.4 deno 2.9.8 v 0.5.2 zig 0.17.0