C,D,Go,Rust,Nim,Zig,V,Julia,Py,C#,Kotlin 11语回文数大战!仅供娱乐参考!

原创
2015/09/25 01:29
阅读数 3.7K
娱乐!娱乐!请不要诋毁任何语言!!!!
我有个心愿!用汇编写一个!当年大学时没好好学汇编!惭愧!正在看汇编!
20200820 加入Kotlin语言,就不加java了。
20200817 加入 c# 版本!
20200816加入Julia和py版本!
20200815加入Vlang语言版本!
20200814加入zig语言的版本!
20171123 rust改用release编译且换官方时间库release编译后执行速度惊人;
20160829Nim改releas编译;
20160712]Rust 1.10MSVC编译;
20160527Rust1.9MSVC编译;
20160416rust1.8ms编译;
20160307改用rust1.7(ms)重编译了;
加了个D语言(C的代码就改了时间部分就移植了);
20160131在树莓派兼容的香蕉派m1上编译的go1.5测试;
20160127 Nim 0.13;
20160127测试Rust 1.6 MSVC;
20151214测试了Rust 1.5 GCC版;
20151102测试了nim0.12;
20151030测试了Rust 1.4;
联想笔记本 inter i7,2.4GHz,16G,win10
C语言(应该是全C,vs2015编译)
#include<stdio.h>
#include<stdlib.h>
#include<time.h>
bool ishuiwen(int n) {
    int sn = 0;
    sn = n;
    int tn = 0;
    while (sn != 0) {
        tn = tn * 10 + sn % 10;
        sn = sn / 10;
    }
    if (tn == n)
        return true;
    return false;
}
int hw1() {
    int tx = 0;
    int x = 0;
    for (x = 0; x <= 10000000; x++) {
        if (ishuiwen(x) == true)
            tx ++;
    }
    return tx;
}

void runhw() {
    clock_t start, finish;
    double  duration;
    start = clock();
    int total = hw1();
    finish = clock();
    duration = (double)(finish - start) / CLOCKS_PER_SEC;
    printf("total = %d,  %f seconds\n", total, duration);
}
1100毫秒+(相信c的潜力没发挥出来)
20200815 用vs2019 release 模式编译后 输出:total = 10999, 0.126000 seconds,c的威力出来了!
---------------------------
DLang(在vs中用D插件编译的)
import std.stdio;
import std.datetime;

bool ishuiwen(int n) {
    int sn = 0;
    sn = n;
    int tn = 0;
    while (sn != 0) {
        tn = tn * 10 + sn % 10;
        sn = sn / 10;
    }
    if (tn == n)
        return true;
    return false;
}
int hw1() {
    int tx = 0;
    int x = 0;
    for (x = 0; x <= 10000000; ++x) {
        if (ishuiwen(x) == true)
            tx ++;
    }
    return tx;
}

int main(string[] argv)
{
    auto currentTime1 = Clock.currTime();
    auto all = hw1();
    auto currentTime2 = Clock.currTime();
    writeln("it is ", all, "have ", currentTime2 - currentTime1, " sec.");
    return 0;
}
764毫秒左右。D 2.07编译的
---------------------------
Go
func HW(num int) bool {
    var source int = num
    var tnum int = 0
    for num != 0 {
        tnum = tnum*10 + num%10
        num = num / 10
    }
    if tnum == source {
        //fmt.Println(source)
        return true
    }
    return false
}
func hw() {
    all := 10000000
    t1 := time.Now()
    total := 0
    for n := 0; n <= all; n++ {
        if HW(n) {
            total++
        }
    }
    t2 := time.Now()
    fmt.Println(total)
    fmt.Println(t2.Sub(t1))
}
Go 1.5.1    200毫秒+;
Go 1.5.2    209毫秒+;
香蕉派m1上,Go1.5,2.5秒左右;
----------------
Rust
use std::time::SystemTime;

fn main() {
    hw21();
}

fn hw21(){
    let local1 = SystemTime::now();
    hw2();
    let local2 = SystemTime::now();
    let rtime = local2.duration_since(local1);
    println!("{:?}", rtime);
}

fn hw2(){
    let mut tx:i32 = 0;
    for x in 0..10000000 {
        if hw(x) == true {
            tx=tx+1;
        }
    }
    println!("--{:?}--", tx);
}

fn hw(n: i32) -> bool {
    let mut sn:i32 = n;
    let mut tn:i32 = 0;
    while sn != 0 {
        tn = tn*10 + sn%10;
        sn = sn/10;
    }
    if tn == n {
        return true;
    }
    return false;
}
Rust 1.3  900毫秒+
Rust 1.4 同一套代码,用时飙到了1100毫以上。最高的1500多毫秒!
Rust 1.5 GCC 同一套代码,用时927毫秒! MSVC版的 Rust 1.5 没有编译成功!
Rust 1.6 MSVC版 959 毫秒+,数次平均970毫秒左右
Rust 1.7 MSVC版本 967毫秒,不是特别稳定,96X毫秒-1秒100毫秒不等。【20160307】
Rust 1.8 MSVC版本 95X 毫秒,比较稳定,95X毫秒-96X毫秒不等。【20160416】每次不要覆盖安装rust新版,卸载以前的安装,不然编译很容易出错!
Rust1.9 MSVC 1秒多,比1.8退步了。但是这不代表Rust退步了。请诸位各自明辨!
Rust1.10 MSVC 1秒多。根据某个评论用户的测试其运行大约都是220毫秒左右,所以最后执行效率可能因为各种因素而不通。
20171123 这次使用了 cargo build --release 编译,还升级了时间计算,用的rust自带的原生std::time。120毫秒上下。果然不负rust的称号!
PS E:\rustprojects\rusttest> ./rust_test --10999-- Duration { secs: 1, nanos: 78146300 } // 上面是以前的 // 下面是带有release编译的,基本120-130毫秒之间,但是用的硬件稍有改动:
i5 4460 3.2g 4核+8G+win10
F:\work\rustp\rustp02>target\release\rustp02.exe --10999-- Ok(Duration { secs: 0, nanos: 120095200 })
-----------------

Nim 0.11.2

import strutils, times

proc ishuiwen(n : int): bool =
  var sn : int
  sn = n
  var tn : int
  tn = 0
  while sn != 0 :
    tn = tn * 10 + sn mod 10
    sn = sn div 10
  if tn == n :
    return true
  return false

proc hw1() : int =
  var tx:int = 0
  for x in 0..10000000 :
    if ishuiwen(x) == true :
      tx=tx+1
  return tx

var t0 = times.cpuTime()
var total : int = hw1()
var t1 = times.cpuTime()
echo("Nim HW all ok ", total, " . use : ", t1 - t0)
4000毫秒+
20151102更新了Nim 0.12版,测试回文数计算速度有提高,2.8-2.9秒;
20160127  Nim 0.13  2.7秒多点;
20160829,在某个网友提示下加入-d:release编译,性能提升。200多毫秒。感谢那位提示的网友。
-----------------------------------------------------------
zig 版本 20200814
const print = std.debug.print;
const std = @import("std");
const os = std.os;
const time = std.time;

fn ishuiwen(n: i32) bool {
    var sn: i32 = 0;
    sn = n;
    var tn: i32 = 0;
    while (sn != 0) {
        tn = tn * 10 + @mod(sn, 10);
        sn = @divTrunc(sn, 10);
    }
    if (tn == n) {
        //print("数::{} == 回文数::{}\n", .{ tn, n });
        return true;
    }
    return false;
}

fn hw1() i32 {
    var tx: i32 = 0;
    var x: i32 = 0;
    var i: i32 = 0;
    var max: i32 = 10000000;
    while (i < max) : (i += 1) {
        if (ishuiwen(i) == true) {
            tx += 1;
            //print("{}\n", .{i});
        }
    }
    return tx;
}

fn runhw() void {
    var s: i64 = time.milliTimestamp();
    var r: i32 = hw1();
    var e: i64 = time.milliTimestamp();
    var ss: i64 = e - s;
    print("Hello, {} == result::{} -- start::{} -- end::{} -- time::{}!\n", .{ "world", r, s, e, ss });
}

pub fn main() !void {
    runhw();
    const stdout = std.io.getStdOut().writer();
    try stdout.print("Hello, {}!\n", .{"world"});
    try stdout.print("Hello[{}]!\n", .{@mod(12, 10)});
    try stdout.print("Hello[{}]!\n", .{@divTrunc(12, 10)});
}
clear; zig fmt .\huiwen.zig;zig build-exe --release-fast .\huiwen.zig; .\huiwen.exe
Hello, world == result::10999 -- start::1597487195088 -- end::1597487195237 -- time::149!
也非常不错 和rust非常接近!
-----------------------------------------
Vlang V语言
module main

import time

fn main() {
    sw := time.new_stopwatch({})
    r := huiwen()
    println('hello world VLang is here Res=$r == tme::${sw.elapsed().milliseconds()}ms')
}

fn huiwen() int {
    mut tx := 0
    for i in 0..10000000 {
        if ishuiwen(i) == true {
            tx ++
        }
    }
    return tx
}

fn ishuiwen(n int) bool {
    mut sn := 0
    sn = n
    mut tn := 0
    for sn != 0 {
        tn = tn * 10 + sn % 10
        sn = sn / 10
    }
    if tn == n {
        return true
    }
    return false
}

// 编译运行命令 v run .\vexe001.v; v version

hello world VLang is here Res=10999 == tme::339ms
V 0.1.28 bbaf6e3
----------------------------------------
julia 20200816 成都今天下雨
//貌似julia要先安装包
import Pkg; Pkg.add("Dates") # 这是标准库的居然要安装!
 

using Dates
using Printf

"""
是否回文
"""
function ishuiwen(n::Int64)
    sn::Int32 = 0 # 可以不用类型
    sn = n
    tn::Int32 = 0
    while sn != 0
        tn = tn * 10 + sn % 10
        sn = sn ÷ 10
    end
    if tn == n
        return true
    end
    return false
end

"""
回文10000000
"""
function huiwen(max::Int64=10000000)
    tx::Int32 = 0
    x::Int32 = 0
    for i = 0:max
        if ishuiwen(i) == true
            tx+=1
        end
    end
    return tx
end

function run()
    t1 = now()
    r = huiwen(10000000)
    t2 = now()
    tx = t2 - t1
    @printf("回文 结果:: %d == 时间:: %F \n", r, Dates.value(tx))
end

run()
# julia .\huiwen.jl; julia --version

回文 结果:: 10999 == 时间:: 240.000000
julia version 1.5.0
---------------------------------------
python 20200816

# coding=utf-8
""" 回文数 """

import datetime
from numba import jit

"""
是否回文
"""
@jit
def ishuiwen(n:int):
    sn = 0 # 可以不用类型
    sn = n
    tn = 0
    while sn != 0:
        tn = tn * 10 + sn % 10
        sn = sn // 10
    if tn == n:
        return True
    return False

"""
回文10000000
"""
@jit
def huiwen(max:int=10000000):
    tx = 0
    for i in range(0, max):
        # print(f"数:{i}")
        if ishuiwen(i):
            tx+=1
            # print(f"回文数:{i}")
    return tx

def run():
    t1 = datetime.datetime.now()
    r = huiwen()
    t2 = datetime.datetime.now()
    tx = (t2 - t1)
    print(f"回文 结果:: {r} == 时间::[{tx.seconds}]秒{tx.microseconds/1000}毫秒")


if __name__ == '__main__':
    run()
# python .\huiwen.py;python --version

回文 结果:: 10999 == 时间::[13]秒959.858毫秒   加jit前 13-14秒
加 jit 后:回文 结果:: 10999 == 时间::[0]秒579.826毫秒
Python 3.8.4
---------------------------------------
C# 20200817,core 3.1,win,release编译
 

// C# 20200817 release 模式
        static bool ishuiwen(int n)
        {
            int sn = 0;
            int tn = 0;
            sn = n;
            while (sn != 0)
            {
                tn = tn * 10 + sn % 10;
                sn = sn / 10;
            }
            if (tn == n)
                return true;
            return false;
        }
        static int hw1(int max = 10000000)
        {
            int tx = 0;
            int x = 0;
            for (x = 0; x <= max; x++)
            {
                if (ishuiwen(x) == true)
                    tx++;
            }
            return tx;
        }
        static void runhw()
        {
            Stopwatch watch = new Stopwatch();
            watch.Start();
            int total = hw1();
            watch.Stop();
            Console.WriteLine($"--{total}-- In milliseconds: {watch.ElapsedMilliseconds}");
        }

--10999-- In milliseconds: 133,c#成绩不赖!
---------------------------------------
Kotlin 20202820

// huiwen.kt
import kotlin.system.*

fun main(args: Array<String>) {
    run()
    println("Hello, World!")
}

fun ishuiwen(n: Int) : Boolean{
    var sn: Int = n;
    var tn: Int = 0;
    while (sn != 0) {
        tn = tn * 10 + sn % 10;
        sn /= 10;
    }
    if (tn == n) {
        return true;
    }
    return false;
}

fun huiwen(max: Int = 10000000) : Int{
    var tx: Int = 0;
    for (x: Int in 0..max) {
        if (ishuiwen(x))
            tx ++;
    }
    return tx;
}

fun run(){
    var total: Int = 0
    val t1 = getTimeMillis()
    val total: Int = huiwen(10000000);
    val t2 = getTimeMillis()
    val tms = t2 - t1
    println("Result:: $total -- Time:: $tms ")
}

// kotlinc huiwen.kt -o huiwen;kotlinc -version;.\huiwen.exe

info: kotlinc-native 1.4.0-rc-308 (JRE 1.8.0_241-b07)
Kotlin/Native: 1.4
Result:: 10999 -- Time:: 221  //java应该也是一个水平就不写java的了

=======================
我可不是想说谁好谁坏!!
我不是某语言拥护者。反正需要不断进步!

展开阅读全文
打赏
1
3 收藏
分享
加载中
捍卫机密博主

引用来自“路中鸟”的评论

我知道你为什么是2秒多了, 因为编译的debug版本, 我上面debug版本也是2秒多。
Nim HW all ok 10999 . use : 2.329
用语言debug版本来秀比拼也是醉了, 其它语言可能也是用的debug编译的吧, 也是服了你。
可能你说的是,我的确没注意这个问题。多谢指教,我空了再试试。谢谢。
2016/08/28 22:21
回复
举报
我知道你为什么是2秒多了, 因为编译的debug版本, 我上面debug版本也是2秒多。
Nim HW all ok 10999 . use : 2.329
用语言debug版本来秀比拼也是醉了, 其它语言可能也是用的debug编译的吧, 也是服了你。
2016/08/15 12:07
回复
举报
虽然不知道你是怎么搞出来的, 同样i7 win10.
```bash
#nim 0.14.2
Nim HW all ok 10999 . use : 0.098
```
2016/08/15 12:03
回复
举报
捍卫机密博主

引用来自“dongweigogo”的评论

无法理解你的结果怎么来的
Rust 1.9 均为 220+ 毫秒
C:\Users\1\Desktop\myrust>main.exe
--10999--
Duration { secs: 0, nanos: 230013200 }

C:\Users\DW\Desktop\myrust>main.exe
--10999--
Duration { secs: 0, nanos: 224012800 }

C:\Users\1\Desktop\myrust>main.exe
--10999--
Duration { secs: 0, nanos: 223012800 }
也许是编译器不同吧,或者电脑硬件问题。可能出入很大。可自己明辨。我说过只是娱乐,不代表什么。
2016/06/30 13:27
回复
举报
无法理解你的结果怎么来的
Rust 1.9 均为 220+ 毫秒
C:\Users\1\Desktop\myrust>main.exe
--10999--
Duration { secs: 0, nanos: 230013200 }

C:\Users\DW\Desktop\myrust>main.exe
--10999--
Duration { secs: 0, nanos: 224012800 }

C:\Users\1\Desktop\myrust>main.exe
--10999--
Duration { secs: 0, nanos: 223012800 }
2016/06/30 13:00
回复
举报
除了C语言,其他都看不顺眼。
2016/01/17 14:08
回复
举报
Go 1.5.1 这么牛逼了?这不科学啊。。。
2016/01/12 19:07
回复
举报
捍卫机密博主

引用来自“狂徒归来”的评论

首先 作为一个c/c++ 脑残粉,对这份报告,我表示不满!实际上控制台返回的时间并没有1100ms+,开启-o3后,

total = 10999, 0.143000 seconds

Process returned 0 (0x0) execution time : 0.149 s
Press any key to continue.

我觉得楼主的测试很不准!

这是不开启任何优化c++的表现
total = 10999, 0.403000 seconds

Process returned 0 (0x0) execution time : 0.408 s
Press any key to continue.

我待会测试下RUST
还请赐教,我毕竟不是专业C++。我只不过是尽量让几个程序一样而已。其实这些个程序我都是现学现用的。不专业是肯定的。纯娱乐吗!
2015/11/29 23:38
回复
举报
首先 作为一个c/c++ 脑残粉,对这份报告,我表示不满!实际上控制台返回的时间并没有1100ms+,开启-o3后,

total = 10999, 0.143000 seconds

Process returned 0 (0x0) execution time : 0.149 s
Press any key to continue.

我觉得楼主的测试很不准!

这是不开启任何优化c++的表现
total = 10999, 0.403000 seconds

Process returned 0 (0x0) execution time : 0.408 s
Press any key to continue.

我待会测试下RUST
2015/11/29 11:06
回复
举报
测试
2015/11/29 11:02
回复
举报
更多评论
打赏
14 评论
3 收藏
1
分享
返回顶部
顶部