在go语言中使用多种方式获得slice/array的总和sum示例代码

2023-06-01 00:00:00 示例 多种 总和

在go语言中获得给定数组或片断的总和的多种方法介绍，希望有合适你的代码示例

1.使用for range循环的切片/数组之和

for index, value := range arr {
  // do whatever
}

在这块，我们将看到两个代码的例子。

因为如果你看一下Golang中for range循环的语法，它的左边有两个值，第一个值是索引，第二个是该索引的值，所以我们可以同时使用这两个值，或者我们可以避免使用这两个值，也可以使用单个值，这取决于开发者。


但是在这个区块中，我们将同时使用这两种技术，首先我们将索引留为空白，

在另一个例子中，我们将把值留为空白，那么我们如何使用，如何避免接收值，让我告诉你，

在Golang中，如果你不想接收那个值，你可以使用_（下划线）操作符来留空那个变量，

我们在这些例子中也将这样做


变化1：空白索引接收值

package main
import (
    "fmt"
)
func sum(arr []int) int {
    sum := 0
    for _, valueInt := range arr {
        sum += valueInt
    }
    return sum
}
func main() {
    fmt.Println("How to get sum of slice/array using Golang...")
    // slice
    arr := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
    result := sum(arr)
    fmt.Printf("slice: %v\n", arr)
    fmt.Printf("sum of slice is: %d\n", result)
}

变化2：空白值接收器

package main
import (
    "fmt"
)
func sum(arr []int) int {
    sum := 0
    for idx, _ := range arr {
        sum += arr[idx]
    }
    return sum
}
func main() {
    fmt.Println("How to get sum of slice/array using Golang...")
    // slice
    arr := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
    result := sum(arr)
    fmt.Printf("slice: %v\n", arr)
    fmt.Printf("sum of slice is: %d\n", result)
}

变化3：使用外部增量值的空白指数和值

package main
import (
    "fmt"
)
func sum(arr []int) int {
    sum := 0
    idx := 0
    for _, _ = range arr {
        sum += arr[idx]
        idx++
    }
    return sum
}
func main() {
    fmt.Println("How to get sum of slice/array using Golang...")
    // slice
    arr := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
    result := sum(arr)
    fmt.Printf("slice: %v\n", arr)
    fmt.Printf("sum of slice is: %d\n", result)
}

变化4：只有索引接收器

package main
import (
    "fmt"
)
func sum(arr []int) int {
    sum := 0
    for idx := range arr {
        sum += arr[idx]
    }
    return sum
}
func main() {
    fmt.Println("How to get sum of slice/array using Golang...")
    // slice
    arr := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
    result := sum(arr)
    fmt.Printf("slice: %v\n", arr)
    fmt.Printf("sum of slice is: %d\n", result)
}

正如你所看到的，在for range循环中，你可以使用多种变化来获得给定片断/数组的总和。

如果你一个接一个地运行这些代码，你会得到下面提到的相同的输出：

$ go run main.go
How to get sum of slice/array using Golang…
slice: [1 2 3 4 5 6 7 8 9 10]
sum of slice is: 55

这些是在Golang中提到的使用for range循环获得总和的变化。

如果你知道更多使用for range循环获得片断/数组之和的变化，请在下面评论。

我也会包括你的变体例子。还有一个可以使用的变体。


变化5：同时使用指数和价值

package main
import (
    "fmt"
)
func sum(arr []int) int {
    sum := 0
    for idx, value := range arr {
        sum += value
        fmt.Printf("idx: %d, sum: %d\n", idx, sum)
    }
    return sum
}
func main() {
    fmt.Println("How to get sum of slice/array using Golang...")
    // slice
    arr := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
    result := sum(arr)
    fmt.Printf("slice: %v\n", arr)
    fmt.Printf("sum of slice is: %d\n", result)
}

正如你所看到的，在这个如何获得切片/数组的总和的变体中，我们同时使用了索引和值，

每次我们都把值加到总和中，同时打印出索引号是什么，在这个索引上的值总和是什么。

你也可以这样使用它，但现在我们在循环中使用了另一个打印语句，所以它将改变我们的输出与之前的输出。


如果你尝试在你的机器上运行这段代码，你会在终端看到下面提到的输出：

$ go run main.go
How to get sum of slice/array using Golang…
idx: 0, sum: 1
idx: 1, sum: 3
idx: 2, sum: 6
idx: 3, sum: 10
idx: 4, sum: 15
idx: 5, sum: 21
idx: 6, sum: 28
idx: 7, sum: 36
idx: 8, sum: 45
idx: 9, sum: 55
slice: [1 2 3 4 5 6 7 8 9 10]
sum of slice is: 55


2.使用 for i:=0;i<len(arr);i++

在这种方式下，你也可以使用多重变化，但是，我把这个问题留给你，让你为这种多重变化的方法编写代码，以获得给定的切片/阵列的总和。

package main
import (
    "fmt"
)
func sum(arr []int) int {
    sum := 0
    for idx := 0; idx < len(arr); idx++ {
        sum += arr[idx]
        fmt.Printf("idx: %d, sum: %d\n", idx, sum)
    }
    return sum
}
func main() {
    fmt.Println("How to get sum of slice/array using Golang...")
    // slice
    arr := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
    result := sum(arr)
    fmt.Printf("slice: %v\n", arr)
    fmt.Printf("sum of slice is: %d\n", result)
}

输出：

$ go run main.go
How to get sum of slice/array using Golang…
idx: 0, sum: 1
idx: 1, sum: 3
idx: 2, sum: 6
idx: 3, sum: 10
idx: 4, sum: 15
idx: 5, sum: 21
idx: 6, sum: 28
idx: 7, sum: 36
idx: 8, sum: 45
idx: 9, sum: 55
slice: [1 2 3 4 5 6 7 8 9 10]
sum of slice is: 55


3.使用for(while)循环| forever循环

在Golang中，你可以用多种方式来使用for循环，其中之一是这样的，对于使用for循环作为while，你不需要像我们在前面的例子中那样添加任何表达式来使它停止，你需要在for循环中添加条件，并且需要使用break关键字来在条件满足时退出循环。

为了加深理解，让我们看一下代码

package main
import (
    "fmt"
)
func sum(arr []int) int {
    sum := 0
    idx := 0
    for {
        if idx > len(arr)-1 {
            break
        }
        sum += arr[idx]
        fmt.Printf("idx: %d, sum: %d\n", idx, sum)
        idx++
    }
    return sum
}
func main() {
    fmt.Println("How to get sum of slice/array using Golang...")
    // slice
    arr := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
    result := sum(arr)
    fmt.Printf("slice: %v\n", arr)
    fmt.Printf("sum of slice is: %d\n", result)
}

正如你所看到的，在sum函数中，我们没有在for关键字旁边添加任何表达式，这就是为什么它的工作或行为像while循环（Golang直接没有任何while关键字），在for循环中，你可以看到首先我们添加了break条件，为什么我们希望我们的程序在条件满足时立即脱离循环（以避免任何冲突或代码中断）。


在我们的条件之后，我们直接做我们的工作，这个函数是用来做和的，同时在每次我们也增加idx值，所以我们可以访问给定片/数组的另一个索引值。

运行这段代码将产生以下输出：

$ go run main.go
How to get sum of slice/array using Golang…
idx: 0, sum: 1
idx: 1, sum: 3
idx: 2, sum: 6
idx: 3, sum: 10
idx: 4, sum: 15
idx: 5, sum: 21
idx: 6, sum: 28
idx: 7, sum: 36
idx: 8, sum: 45
idx: 9, sum: 55
slice: [1 2 3 4 5 6 7 8 9 10]
sum of slice is: 55


4.使用递归函数

在这个模块中，我们将使用递归函数来获取给定的片断/数组的总和，那么使用递归来获取总和的方法是什么呢，很简单，我们需要修改我们的总和函数（在以前的例子中使用过）。


添加两个函数参数，第一个是slice/array，第二个是length。在sum函数中，我们需要添加条件来检查第二个参数，即长度是否<=0，如果是，则返回0在sum函数内部调用sum函数的返回时间，所以它将直接返回它在内部进行的每次迭代的总和（递归）。

package main
import (
    "fmt"
)
func sum(arr []int,n int) int {
  if n <= 0 {
    return 0
  }
    return (sum(arr, n - 1) + arr[n - 1])
}
func main() {
    fmt.Println("How to get sum of slice/array using Golang...")
    // slice
    arr := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
    result := sum(arr,len(arr))
    fmt.Printf("slice: %v\n", arr)
    fmt.Printf("sum of slice is: %d\n", result)
}

输出：

$ go run main.go
How to get sum of slice/array using Golang…
slice: [1 2 3 4 5 6 7 8 9 10]
sum of slice is: 55


5.使用Variadic函数

你可以使用所有提到的方法来使用variadic函数，但在这篇文章中我将使用for(while)循环。

在上述所有函数中，你也可以使用递归，但你可能需要一个额外的变量来先存储所有元素，

然后再传递arr和length，所以在所有期望递归的方法中最好使用variadic。

package main
import (
    "fmt"
)
func sum(arr ...int) int {
    sum := 0
    idx := 0
    for {
        if idx > len(arr)-1 {
            break
        }
        sum += arr[idx]
        fmt.Printf("idx: %d, sum: %d\n", idx, sum)
        idx++
    }
    return sum
}
func main() {
    fmt.Println("How to get sum of slice/array using Golang...")
    // slice
    arr := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
    result := sum(arr...)
    fmt.Printf("slice: %v\n", arr)
    fmt.Printf("sum of slice is: %d\n", result)
}

输出：

$ go run main.go
How to get sum of slice/array using Golang…
idx: 0, sum: 1
idx: 1, sum: 3
idx: 2, sum: 6
idx: 3, sum: 10
idx: 4, sum: 15
idx: 5, sum: 21
idx: 6, sum: 28
idx: 7, sum: 36
idx: 8, sum: 45
idx: 9, sum: 55
slice: [1 2 3 4 5 6 7 8 9 10]
sum of slice is: 55

相关文章