Question

我在Go中玩一些基本的时间，并且有一个问题。我想给Golang计时以获取数组每个元素的平方根，但是无论是否保留输出，我都会得到两个略有不同的答案。这是我的第一个版本：

div

平均大约36毫秒：

package main

import ("fmt"
        "time" 
        "math"
        "math/rand"
)

// A random array of integers 
func randomArray(max int ,len int) []int {
    a := make([]int, len)
    for i := 0; i <= len-1; i++ {
        a[i] = rand.Intn(max)
    }
    return a
}

// Taking square root of each element in array
func sqrt_array(arr [] int) [] float64 {
    var len_arr = len(arr)
    a := make([]float64, len_arr)
    for i, v := range arr {
    a[i] = math.Sqrt(float64(v))
    }
    return a
}


func main() {

    arr := randomArray(100, 10e6)
    sqrt := make([]float64, len(arr))
    start := time.Now()
    sqrt = sqrt_array(arr)
    end := time.Now()

    fmt.Println("time taken: ", end.Sub(start), sqrt[0])
}

现在，当我用空白标识符替换输出“ sqrt”时，我得到的速度要慢得多。具体来说，我将main（）替换为

time taken:  36.542019ms 9

平均得到大约92ms

func main() {

    arr := randomArray(100, 10e6)
    // sqrt := make([]float64, len(arr))
    start := time.Now()
    _ = sqrt_array(arr)
    end := time.Now()

    fmt.Println("time taken: ", end.Sub(start))
}

有人可以解释发生了什么吗？我觉得，如果我了解了我可能会学到有关Go的知识。

顺便说一句，我发现在Python中，如果进行广播，相同的计算大约是20毫秒，如果在循环中，则大约是数百毫秒。

Answer 1

如果您想要相同的结果，请执行相同的操作！显然，分配不是免费的！不要注释掉分配！

例如，

输出：

time taken:  77.726729ms 9
time taken:  78.213242ms 0

main.go：

package main

import (
    "fmt"
    "math"
    "math/rand"
    "testing"
    "time"
)

// A random array of integers
func randomArray(max int, len int) []int {
    a := make([]int, len)
    for i := 0; i <= len-1; i++ {
        a[i] = rand.Intn(max)
    }
    return a
}

// Taking square root of each element in array
func sqrt_array(arr []int) []float64 {
    var len_arr = len(arr)
    a := make([]float64, len_arr)
    for i, v := range arr {
        a[i] = math.Sqrt(float64(v))
    }
    return a
}

func main1() {

    arr := randomArray(100, 10e6)
    sqrt := make([]float64, len(arr))
    start := time.Now()
    sqrt = sqrt_array(arr)
    end := time.Now()

    fmt.Println("time taken: ", end.Sub(start), sqrt[0])
}

func main2() {

    arr := randomArray(100, 10e6)
    // sqrt := make([]float64, len(arr))
    sqrt := make([]float64, len(arr))
    start := time.Now()
    _ = sqrt_array(arr)
    end := time.Now()

    fmt.Println("time taken: ", end.Sub(start), sqrt[0])
}

func main() {
    main1()
    main2()
}

Answer 2

@Not_a_Golfer这是一个有趣的想法，谢谢！我用

替换了sqrt_array

func sqrt_array(arr [] int) [] float64 {
    var len_arr = len(arr)
    a := make([]float64, len_arr)
    s := time.Now()
    for i, v := range arr {
    a[i] = math.Sqrt(float64(v))
    }
    e := time.Now()
    fmt.Println("time taken: ", e.Sub(s))
    return a
}

，发现我使用的第一个main（）给出：

耗时：30.455811ms
花费时间：36.419998ms 9

第二个给出

耗时：30.916246ms
花费时间：90.815387ms

我认为这表明两种方法的计算时间大致相同（30毫秒）。在第二个选项中删除阵列确实确实会花费一些时间（大约60毫秒）。尽管这很奇怪，因为它应该只是删除一个指针

带有和不带有空白标识符的Golang中的计时

2 个答案: