Question

因此，我的朋友给我执行了此任务，其中必须使用递归来计算正数的平方和。
条件-输入的内容将是一个由数字分隔的字符串
这是我到目前为止所看到的，但这显示了runtime error。

这是完整的错误https://ideone.com/53oOjN

package main
import(
    'fmt',
    'strings',
    'strconv'
)
var n int = 4
var sum_of_squares int = 0
func sumOfSquares(strArray []string, iterate int) int{
    number, _ := strconv.Atoi(strArray[iterate])
    if number > 0 {
        sum_of_squares += number*number
    }
    if iterate == n {
        return 0 // just to end the recursion
    }
    return sumOfSquares(strArray, iterate+1)
}
func main() {
    str := "1 2 3 4"
    strArray := strings.Fields(str)
    result := sumOfSquares(strArray, 0)
    fmt.Println(sum_of_squares, result)
}

Answer 1

递归的经验法则是终止条件。它应该存在，并且应该存在于正确的位置。

func sumOfSquares(strArray []string, iterate int) int{
    if iterate >= len(strArray) { 
        return sum_of_squares
    }
    number, _ := strconv.Atoi(strArray[iterate]) //TODO: handle err here
    sum_of_squares += number*number

    return sumOfSquares(strArray, iterate+1)
}

仅供您参考：规范递归不应将其状态保存到全局字段中。我建议使用以下函数签名。

func sumOfSquares(strArray []string, iterate, currentSum int) int{
    //...    
    return sumOfSquares(strArray, iterate+1, sum_of_squares)
}

因此您无需将sum_of_squares存储在某个地方。您只需将其传递给下一个函数调用即可。

Answer 2

package main

import (
    "fmt"
    "strconv"
    "strings"
)

var n int

func sumOfSquares(strArray []string, iterate int) int {
    number, _ := strconv.Atoi(strArray[iterate])
    if iterate == n {
        return number * number
    }
    return ((number * number) + sumOfSquares(strArray, iterate+1))
}

func main() {
    str := "1 2 3 4"
    strArray := strings.Fields(str)
    n = len(strArray) - 1
    result := sumOfSquares(strArray, 0)
    fmt.Println(result)
}

索引从0开始，因此将长度减少一。

如@peterSO所指出的，如果字符串包含不寻常的字符，则它不起作用，我没有发布正确的答案来获取输入，因为您似乎是初学者，但是您可以读取输入，例如这样

var inp []byte
var loc int

inp, _ = ioutil.ReadFile(fileName)
//add \n so that we don't end up running out of bounds,
//if last byte is integer.
inp = append(inp, '\n')


func scanInt() (res int) {
    if loc < len(inp) {
        for ; inp[loc] < 48 || inp[loc] > 57; loc++ {
        }
        for ; inp[loc] > 47 && inp[loc] < 58; loc++ {
            res = res<<3 + res<<1 + (int(inp[loc]) - 48)
        }
    }
    return
}

这更快，仅扫描整数，并跳过所有其他不寻常的字符。

Answer 3

我想保持简单。我也有一些条件，但希望您喜欢。

func sumOfSquares(numArr []string) int {
    i, err := strconv.Atoi(numArr[0])

    rest := numArr[1:]

    //Error checking
    if err != nil {
        fmt.Println(err)
        os.Exit(1)
        return 0
    }

    square := i * i

    // negative & last number
    if i < 0 && len(rest) == 0 {
        return square
    }

    // negative & not last number
    if i < 0 && len(rest) > 0 {
        return sumOfSquares(rest)
    }

    // last man standing
    if i >= 0 && len(rest) == 0 {
        return square
    }

    return square + sumOfSquares(rest)

}

演示：https://play.golang.org/p/WWYxKbvzanJ

使用Golang中的递归的数组中的平方和

3 个答案: