如何解决UTXO选择策略
在选择UTXO时,我需要应用特定的策略。 该策略应尽可能减少utxo的使用。 应该设置此策略的边界,理想情况下,应减少utxo的数量,直到比率达到10倍为止。
为了简化问题,让我们假设,有一片整数列表:= [] int {},我需要在其中找到元素'target': list [index] = target,如果这样的元素不存在,那么我需要从切片中找到第一个元素,该元素大于target但需要为
如果我找不到这样的元素,那么我需要找到两个元素x,y,其中: x + y =目标,如果不存在此类元素,我需要从切片中找到前两个大于目标的元素,但它们必须为
如果找不到此类元素,则需要找到三个元素x,y,z,其中: x + y + z =目标,如果不存在这样的元素,我需要从切片中找到前三个比目标大的元素,但需要
如果找不到这三个元素,我需要找到四个,五个...直到len(list)。
示例1:
target = 6
list := []int {1,2,6,10}
result = list[2] = 6
示例2:
target = 6
list := []int {1,3,10}
result = list[3] = 10
示例3:
target = 6
list := []int {1,10}
result = list[3] = 10
示例4:
target = 6
list := []int {1,61}
result = list[1] + list[2]= 6
请参阅下面的测试用例,我需要通过递归或某种方式对其进行改进,以得到通用的解决方案:
func Test_SelectUtxo(t *testing.T){
x := 6
list := []int{1,64,65,62,61,59}
fmt.Println("ONE = x")
for i := 0; i < len(list) - 1; i ++ {
if list[i] == x {
fmt.Println(i)
break
}
}
fmt.Println("ONE <= x*10")
for i := 0; i < len(list); i ++ {
if list[i] > x {
if list[i] <= x*10 && list[i] > x {
fmt.Println(list[i])
break
}
}
}
fmt.Println("TWO = x")
out:
for i := 0; i < len(list) - 1; i ++ {
for j:=i + 1; j < len(list); j ++ {
if list[i] + list[j] == x {
fmt.Println(i)
fmt.Println(j)
break out
}
}
}
fmt.Println()
fmt.Println("TWO <= x*10")
out1:
for i := 0; i < len(list) - 1; i ++ {
for j:=i + 1; j < len(list); j ++ {
if list[i] + list[j] <= x*10 && list[i] + list[j] > x {
fmt.Println(i)
fmt.Println(j)
break out1
}
}
}
fmt.Println()
fmt.Println("THREE = x")
out2:
for i := 0; i < len(list) - 2; i ++ {
for j:=i + 1; j < len(list) - 1; j ++ {
for k:= j + 1; k < len(list); k ++ {
if list[i] + list[j] + list[k] == x {
fmt.Println(i)
fmt.Println(j)
fmt.Println(k)
break out2
}
}
}
}
}
解决方法
一种解决方案:
-
设置
size = 1
-
使用递归(以下代码段中的函数名称= getCombination )来获取输入数组中
size
个元素的所有组合。 -
检查每个组合是否符合 0-> i 的要求,如果是,请返回(完成)
-
如果没有一个组合匹配,则依次
size++
,然后转到步骤2 。
代码段:
import (
"fmt"
)
var combination = []int{}
func GetCombination(src []int,size int,offset int) [][]int { // get all combinations for **size** elements in the elements of src array
result := [][]int{}
if size == 0 {
temp := make([]int,len(combination))
copy(temp,combination)
return append(result,temp)
}
for i:=offset; i<=len(src) - size; i++ {
combination = append(combination,src[i])
temp := GetCombination(src,size-1,i+1)
result = append(result,temp...)
combination = combination[:len(combination)-1]
}
return result[:]
}
func sum(items []int) int {
total := 0
for _,v := range items {
total += v
}
return total
}
func GetBestPair(items []int,target int) []int {
for i := 1; i < len(items)+1; i++ {
result := GetCombination(items,i,0) // get all possible combinations for 1 -> len(items) elements of Array=items
// fmt.Println("Combinations for "," elements:",result)
for j := 0; j < len(result); j++ {
total := sum(result[j])
if total < target {
continue
}
if total == target {
return result[j]
}
if total < target*10 {
return result[j]
}
}
}
return []int{}
}
func main () {
fmt.Println("Result",GetBestPair([]int{1,3,61},6))
}
上述测试用例的输出
Combinations for 1 elements: [[1] [3] [3] [61]]
Combinations for 2 elements: [[1 3] [1 3] [1 61] [3 3] [3 61] [3 61]]
Result: [3 3]
版权声明:本文内容由互联网用户自发贡献,该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 dio@foxmail.com 举报,一经查实,本站将立刻删除。