在Go中对切片/数组求和的多种方法

简介: 在Go中对切片/数组求和的多种方法

在这篇文章中,你将看到在 Golang 中获得一个给定 array/slice 的总和的多种方法,你可以使用多种方法来获得 Golang 中 array/slice 的总和,例如在数组的每个索引上进行迭代循环,或者你可以使用递归方法来获得 array/slice 的总和,这取决于开发者想要获得他们给定 array/slice 的总和。


这篇文章涵盖了如何在 Golang 中使用以下方法获得 array/slice 的总和。


  • 使用 for range
  • 使用 for(i:=0;i
  • 使用 for(while)
  • 使用递归函数
  • 使用变化函数


**1. **使用 for range


for index, value := range arr {
  // do whatever
}
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


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)


在 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 值,这样我们就可以访问给定 array/slice 的另一个索引值。


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


$ 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. **使用递归函数


在这个模块中,我们将使用递归函数来获取给定的 array/slice 的总和,那么使用递归来获取总和的方法是什么呢,很简单,我们需要修改我们的总和函数。

  • 添加两个函数参数,第一个是 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. 使用变化函数

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


在上述所有函数中,你也可以使用递归,但你可能需要一个额外的变量来先存储所有元素,然后再传递 arr 和 length,所以在所有期望递归的方法中最好使用变量。


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
相关文章
|
12月前
|
存储 JSON 安全
Go语言切片,使用技巧与避坑指南
Go语言中的切片(Slice)是动态引用数组的高效数据结构,支持扩容与截取。本文从切片基础、常用操作到高级技巧全面解析,涵盖创建方式、`append`扩容机制、共享陷阱及安全复制等内容。通过代码示例详解切片特性,如预分配优化性能、区分`nil`与空切片、处理多维切片等。掌握这些核心知识点,可编写更高效的Go代码。
453 2
|
8月前
|
存储 安全 Java
【Golang】(4)Go里面的指针如何?函数与方法怎么不一样?带你了解Go不同于其他高级语言的语法
结构体可以存储一组不同类型的数据,是一种符合类型。Go抛弃了类与继承,同时也抛弃了构造方法,刻意弱化了面向对象的功能,Go并非是一个传统OOP的语言,但是Go依旧有着OOP的影子,通过结构体和方法也可以模拟出一个类。
397 2
|
存储 Go 索引
go语言中数组和切片
go语言中数组和切片
363 7
Go语言方法与接收者 -《Go语言实战指南》
本文介绍了 Go 语言中方法的相关概念和用法。方法是绑定到特定类型上的函数,包含值接收者和指针接收者两种形式。值接收者不会改变原始数据,而指针接收者可修改原始数据,且在处理大型结构体时性能更优。文章详细对比了方法与普通函数的区别,并说明了选择指针接收者的原因,如修改原始值、提升性能及保持一致性。此外,Go 支持为任意自定义类型定义方法,不仅限于结构体。最后通过表格总结了方法的核心概念和使用场景。
332 34
|
11月前
|
数据采集 机器学习/深度学习 存储
Go语言实战案例 - 找出切片中的最大值与最小值
本案例通过实现查找整数切片中的最大值与最小值,帮助初学者掌握遍历、比较和错误处理技巧,内容涵盖算法基础、应用场景及完整代码示例,适合初学者提升编程能力。
|
测试技术 Go API
Go 切片导致 rand.Shuffle 产生重复数据的原因与解决方案
在 Go 语言开发中,使用切片时由于其底层数据共享特性,可能会引发意想不到的 Bug。本文分析了 `rand.Shuffle` 后切片数据重复的问题,指出原因在于切片是引用类型,直接赋值会导致底层数组共享,进而影响原始数据。解决方案是使用 `append` 进行数据拷贝,确保独立副本,避免 `rand.Shuffle` 影响原始数据。总结强调了切片作为引用类型的特性及正确处理方法,确保代码稳定性和正确性。
374 82
|
12月前
|
Go 索引
Go语言中使用切片需要注意什么?
本文详细讲解了Go语言中切片(Slice)的使用方法与注意事项。切片是对数组连续片段的引用,具有灵活的操作方式。文章从定义与初始化、长度与容量、自动扩容、共享底层数组、复制、边界检查、零值到拼接等方面展开,并配以示例代码演示。通过学习,读者可深入了解切片的工作原理及优化技巧,避免常见陷阱,提升编程效率与代码质量。
284 2
|
安全 Go 开发者
Go语言之切片的原理与用法 - 《Go语言实战指南》
切片(slice)是Go语言中用于处理变长数据集合的核心结构,基于数组的轻量级抽象,具有灵活高效的特点。切片本质是一个三元组:指向底层数组的指针、长度(len)和容量(cap)。本文详细介绍了切片的声明与初始化方式、基本操作(如访问、修改、遍历)、长度与容量的区别、自动扩容机制、共享与副本处理、引用类型特性以及常见陷阱。通过理解切片的底层原理,开发者可以更高效地使用这一数据结构,优化代码性能。
441 13
|
Go 索引
Go语言数组的定义与操作 - 《Go语言实战指南》
本文介绍了 Go 语言中的数组(Array)相关知识,包括定义、初始化方式(默认、显式、指定索引及自动推导长度)、访问与修改、遍历方法(for 循环和 for range)、值类型特性(复制行为)、多维数组支持以及其与切片的区别。数组是定长且同类型的集合,适合性能敏感场景,但实际开发中更常用动态的切片(slice)。
366 11
|
Go
【LeetCode 热题100】DP 实战进阶:最长递增子序列、乘积最大子数组、分割等和子集(力扣300 / 152/ 416 )(Go语言版)
本文深入解析三道经典的动态规划问题:**最长递增子序列(LIS)**、**乘积最大子数组** 和 **分割等和子集**。 - **300. LIS** 通过 `dp[i]` 表示以第 `i` 个元素结尾的最长递增子序列长度,支持 O(n²) 动态规划与 O(n log n) 的二分优化。 - **152. 乘积最大子数组** 利用正负数特性,同时维护最大值与最小值的状态转移方程。 - **416. 分割等和子集** 转化为 0-1 背包问题,通过布尔型 DP 实现子集和判断。 总结对比了三题的状态定义与解法技巧,并延伸至相关变种问题,助你掌握动态规划的核心思想与灵活应用!
473 1

热门文章

最新文章