Question

我有一个整数[1,2,3,7,13,14]和一个整数值12的数组。我需要返回一个新数组中最接近的整数值组合的数组

例如：[1,2,3,7,13,14]，其值为12.需要返回的数组为[1,2,3,4]，因为元素的总和为1 + 2 + 3 + 4＆lt; = 12.这是最长的阵列，优先于[1,7,4] 1 + 7 + 4 = 12。

Answer 1

我对算法没有必要，但我会这样做：

由于您的规则是＆lt; = 5，您可以对数组进行排序：[1,2,3,7,13,11,4] =＆gt; [1,2,3,4,7,11,13] 然后，因为你不需要整数＆gt; 5你可以将你的阵列分成两部分而只取第一部分：[1,2,3,4] 从那里你必须添加4 + 3并与你的价值相匹配。如果它不起作用4 + 2，那么4 + 1.如果它仍然> 5，循环用3,2; 3,1;我用Swift方式做了类似的事情：

// Init
let array = [1, 2, 3, 7, 13, 11, 4]
let value = 5
let sortedArray = array.sorted()
let usefulArray = sortedArray.filter() {$0 < value}
var hasCombination = false
var currentIndex = usefulArray.count - 1
var indexForSum = currentIndex - 1

// Process
if currentIndex > 0 {
  hasCombination = true
  while usefulArray[currentIndex] + usefulArray[indexForSum] > value {
  indexForSum -= 1
  if indexForSum < 0 {
    currentIndex -= 1
    indexForSum = currentIndex - 1
  } 
  if currentIndex == 0 {
    hasCombination = false
    break
  }
 }
}

// Result
if hasCombination {
 let combination = [usefulArray[indexForSum], usefulArray[currentIndex]]
} else {
  print("No combination")
}

我想它确实有效，告诉我它是否有效！

Answer 2

如果你没有在数组中重复数字，这个解决方案是有效的。

var array = [1, 2, 3, 7, 13, 11, 4, -12, 22, 100]
print(array.sorted())
let value = 19

func close(array: [Int], value: Int) -> (Int , Int) {
    let sortedArray = array.sorted()
    var lastNumberBeforValue = sortedArray.first!
    for (index,number) in sortedArray.enumerated() {
        let sub = value - number
        if sub > 0 {
            lastNumberBeforValue = number
        }
        if sortedArray.contains(sub) && sub != number {
            return (sub, number)
        } else if index == sortedArray.count - 1 {
            if sub < 0 {
                let near = close(array: array, value: value - lastNumberBeforValue)
                return (near.0, lastNumberBeforValue)
            }
            let near = close(array: array, value: sub)
            return (near.0, number)
        }
    }
    return (-1,-1)
}

let numbers = close(array: array, value: value)
print(numbers) //prints (4, 13)

Answer 3

此解决方案还在数组中找到两个整数，其中和最接近给定值：

let array = [1, 2, 3, 7, 13, 11, 4]
let value = 5

var difference = Int.max
var result = [Int(), Int()]

for firstInt in array {
    for secondInt in array {
        let tempDifference = abs((firstInt + secondInt) - value)
        if tempDifference < difference {
            difference = tempDifference
            result[0] = firstInt
            result[1] = secondInt
        }
    }
}

或者不允许多次使用相同值的解决方案：

for (firstIndex, firstInt) in array.enumerated() {
    for (secondIndex, secondInt) in array.enumerated() {
        guard firstInt != secondInt else { break }
        let tempDifference = abs((firstInt + secondInt) - value)
        if tempDifference < difference {
            difference = tempDifference
            result[0] = firstInt
            result[1] = secondInt
        }
    }
}

如果需要更长的结果数组，可以继续嵌套for循环并保护多次使用相同的索引。最后，您可以获取具有最大result.count的有效数组。这不是一个很好的解决方案，因为它计算量很大，并且要求数组具有静态长度。

找到最近的最长组合

3 个答案: