记录一次lua（luajit）比cpp（STL）快

lua

local int = math.floor
local solu89 = {[89]=true}
local solu1 = {[1]=true}

local function sqrsum(i)
    local s = 0
    while i>0 do
        s = s + (i%10)^2
        i = int(i/10)
    end
    return s
end

local function sol(i)
    local temp = {i}
    while true do
        if solu89[i] then
            for j=1,#temp do solu89[temp[j]]=true end
            break
        elseif solu1[i] then
            for j=1,#temp do solu1[temp[j]]=true end
            break
        else
            table.insert(temp, i)
        end
        i = sqrsum(i)
    end
end

for i=1,1e7 do
    sol(i)
end
local count = 0 for _ in pairs(solu89) do count = count + 1 end
print(count)

cpp

#pragma GCC optimize(3, "Ofast", "inline")
#include <bits/stdc++.h>
using namespace std;
#define all(x) x.begin(), x.end()
using ll = long long;
unordered_set<int> solu89 = {89}, solu1 = {1};
int sqrsum(int i)
{
    int s = 0;
    while (i > 0)
    {
        int tmp = i % 10;
        s += tmp * tmp;
        i /= 10;
    }
    return s;
}
void sol(int i)
{
    vector<int> temp = {i};
    while (true)
    {
        if (solu89.count(i))
        {
            solu89.insert(all(temp));
            break;
        }
        else if (solu1.count(i))
        {
            solu1.insert(all(temp));
            break;
        }
        else
        {
            temp.push_back(i);
            i = sqrsum(i);
        }
    }
}
int main()
{
    for (size_t i = 1; i < 10000000; i++)
    {
        sol(i);
    }
    cout << solu89.size();
}

rust

use std::collections::HashSet;

fn sqrsum(x: i64) -> i64 {
    let mut s = 0;
    let mut i = x;
    while i > 0 {
        let tmp = i % 10;
        s += tmp * tmp;
        i /= 10;
    }
    s
}

fn sol(solu89: &mut HashSet<i64>, solu1: &mut HashSet<i64>, mut i: i64) {
    let mut temp: HashSet<i64> = [i].into();
    loop {
        if solu89.contains(&i) {
            solu89.extend(temp.iter());
            break;
        } else if solu1.contains(&i) {
            solu1.extend(temp.iter());
            break;
        } else {
            temp.insert(i);
        }
        i = sqrsum(i);
    }
}

fn main() {
    let mut solu89: HashSet<i64> = [89].into();
    let mut solu1: HashSet<i64> = [1].into();
    for i in 1..10000000 {
        sol(&mut solu89, &mut solu1, i);
    }
    println!("{}", solu89.len());
}

$ time node.exe test.ts 
8581146

real    0m5.158s
user    0m0.000s
sys     0m0.062s

$ time deno.exe run test.ts
8581146

real    0m5.935s
user    0m0.015s
sys     0m0.015s

$ time luajit.exe test.lua
8581146

real    0m3.136s
user    0m0.031s
sys     0m0.062s
 
 $ time test-rust.exe
8581146

real    0m4.078s
user    0m0.000s
sys     0m0.031s

$ time test-g++O3.exe
8581146
real    0m5.491s
user    0m0.015s
sys     0m0.015s