Go 元组替代方案

偷偷努力，悄无声息地变强，然后惊艳所有人！哈哈，小伙伴们又来学习啦~今天我将给大家介绍《Go 元组替代方案》，这篇文章主要会讲到等等知识点，不知道大家对其都有多少了解，下面我们就一起来看一吧！当然，非常希望大家能多多评论，给出合理的建议，我们一起学习，一起进步！

我正在学习麻省理工学院计算思维和数据科学简介课程讲座 2 讲座 pdf，我正在尝试将以下树搜索算法 python 代码翻译为 golang。主要问题是 python 代码正在使用元组。

def maxval(toconsider, avail):
    """assumes toconsider a list of items, avail a weight
       returns a tuple of the total value of a solution to the
         0/1 knapsack problem and the items of that solution"""
    if toconsider == [] or avail == 0:
        result = (0, ())
    elif toconsider[0].getcost() > avail:
        #explore right branch only
        result = maxval(toconsider[1:], avail)
    else:
        nextitem = toconsider[0]
        #explore left branch
        withval, withtotake = maxval(toconsider[1:],
                                     avail - nextitem.getcost())
        withval += nextitem.getvalue()
        #explore right branch
        withoutval, withouttotake = maxval(toconsider[1:], avail)
        #choose better branch
        if withval > withoutval:
            result = (withval, withtotake + (nextitem,))
        else:
            result = (withoutval, withouttotake)
    
    return result

def testmaxval(foods, maxunits, printitems = true):
    print('use search tree to allocate', maxunits,
          'calories')
    val, taken = maxval(foods, maxunits)
    print('total value of items taken =', val)
    if printitems:
        for item in taken:
            print('   ', item)

我知道 go 没有元组，我四处寻找解决方法。我尝试了这个解决方案，但没有成功：

type Food struct {
    name     string
    value    int
    calories int
}

type Pair struct{ //found this work around on another stack overflow question but I think I incorrectly implemented it 
    a,b interface{}
}



func maxVal(toConsider []Food, avail int) Pair{ 
    /*
    Assumes toConsider a list of items, avail a weight
    Returns a tuple of the total value of a solution to the
    0/1 knapsack problem and the items of that solution
    */

    var result Pair //the culprit

    if (toConsider == nil || avail == 0){ //Slices can only be compared to nil so I am not sure this is achieving what I want it to achieve (i.e. checking for an empty list)

        result = Pair{0, nil}
    } else if toConsider[0].calories > avail{
        //explore right branch only
        result = maxVal(toConsider[1:], avail)
    } else{
        nextItem := toConsider[0]
        //explore left branch
        withVal, withToTake := maxVal(toConsider[1:], avail - nextItem.calories)
        withVal = withVal + nextItem.value
        //explore right branch
        withoutVal, withoutToTake := maxVal(toConsider[1:], avail)
        //choose better branch
        if withVal > withoutVal{
            result = Pair{withVal, withToTake + (nextItem)}
        }
    }
    return result
}

func testMaxVal(foods []Food, maxUnits int, printItems bool) {
    printItems = true
    fmt.Printf("Use search tree to allocate %d calories", maxUnits)
    val, taken := maxVal(foods, maxUnits)
    fmt.Printf("\nTotal value of items taken = %d", val)
    if printItems{
        for i := range taken{
            fmt.Print("\n ", i)
        }
    }
}

解决方案

go 没有元组，但它可以返回多个值：

func maxval(toConsider []Food, avail int) (int,[]Food) {
   if len(toConsider)==0 || avail == 0) { // len(toConsider)==0 will work even if toConsider is nil
      return 0,nil
   }
 ...
}

今天带大家了解了的相关知识，希望对你有所帮助；关于Golang的技术知识我们会一点点深入介绍，欢迎大家关注golang学习网公众号，一起学习编程~