Question

我已将数组排序为

1, 4, 5 , 6, 8

找出这个数组是否包含算术级数（序列）的方法是什么？

就像在这个例子中一样

4,6,8

或

 4,5,6

备注：序列中的最小数字为3

Answer 1

你可以通过将其分解为更小的问题来递归地解决这个问题：

确定对{1,4}，{1,5} ...... {6,8}
对于每对，查找具有相同间隔的序列

首先创建脚手架来运行问题：

Dim number(7) As Integer
Dim result() As Integer
Dim numbers As Integer
Sub FindThem()
number(1) = 1
number(2) = 4
number(3) = 5
number(4) = 6
number(5) = 8
number(6) = 10
number(7) = 15
numbers = UBound(number)
ReDim result(numbers)
Dim i As Integer
For i = 1 To numbers - 2
    FindPairs i
Next
End Sub

现在迭代对

Sub FindPairs(start As Integer)
    Dim delta As Integer
    Dim j As Integer
    result(1) = number(start)
    For j = start + 1 To numbers
        result(2) = number(j)
        delta = result(2) - result(1)
        FindMore j, 2, delta
    Next
End Sub

随时查找序列

Sub FindMore(start As Integer, count As Integer, delta As Integer)
    Dim k As Integer
    For k = start + 1 To numbers
        step = number(k) - result(count)
        result(count + 1) = number(k) ' should be after the if statement
                                      ' but here makes debugging easier
        If step = delta Then
            PrintSeq "Found ", count + 1
            FindMore k, count + 1, delta
        ElseIf step > delta Then ' Pointless to search further
            Exit Sub
        End If
    Next
End Sub

这只是为了显示结果

Sub PrintSeq(text As String, count As Integer)
    ans = ""
    For t = 1 To count
        ans = ans & "," & result(t)
    Next
    ans = text & " " & Mid(ans, 2)
    Debug.Print ans
End Sub

结果

findthem
Found  1,8,15
Found  4,5,6
Found  4,6,8
Found  4,6,8,10
Found  5,10,15
Found  6,8,10

编辑：哦，当然，数组必须排序！

HTH

Answer 2

当然不是解决问题的最佳方式，但您可以执行以下操作：

遍历数组中的所有数字对 - 如果我们假设它们是第1和第2个渐进成员，则每2个数字完全定义算术序列。因此，知道这2个数字，您可以构建更多的进展元素，并检查它们是否在您的数组中。

如果你想找到形成算术级数的3个数字，那么你可以迭代所有非相邻数字对a [i]和a [j]，j＆gt; i + 1并检查他们的算术平均值是否属于数组 - 你可以使用间隔二进制搜索来做到这一点] i，j [。

Answer 3

首先，我假设您只需要三个或更多个术语的算术序列。

我建议将每个数字a[i]作为算术序列的开头，并将a[i+n]作为下一个。{/ p>

现在你的系列中有前两个术语，你可以找到下一个术语。一般来说，如果x是你的第一个词而y是你的第二个词，那么你的术语将是x + i*(y-x)，第一个词是i = 0.下一个词将是x + 2 *（y-x）。在数组中搜索该值。如果该值在您的数组中，则您具有三个或更多项的算术序列！

您可以继续使用i = 3，i = 4等，直到找到阵列中找不到的那个。

如果l是您的数组的大小，请为从0到i的所有l-2以及从n到{{0的所有l-i-1执行此操作1}}

唯一的主要警告是，在示例中，这将找到序列4,6,8以及6,8。从技术上讲，它们都是你系列中的算术序列。你必须更具体地定义你想要的东西。在您的情况下，仅仅检查并消除完全包含在其他内容中的所有进度可能是微不足道的。

Answer 4

一般的想法是选择一个元素作为你的a_1，然后选择一个元素作为你的a_2，计算差异，然后看看之后是否有任何其他元素匹配那个差异。只要至少有3个元素具有相同的差异，我们认为它是一个进展。

progression (A, n)
   for i = 1 ... n - 2
      a_1 = A[i]
      for j = i + 1 ... n - 1
         a_2 = A[j]
         d = a_2 - a_1
         S = [ i, j ]
         for k = j + 1 ... n
            if ( d == ( a[k] - a[S.last] ) )
               /* Append the element index to the sequence so far. */
               S += k
         if ( |s| > 2 )
            /* We define a progression to have at least 3 numbers. */
            return true
   return false

您可以修改算法以在丢失之前存储每个集合S，以计算给定阵列A的所有进度。算法在O（n ^ 3）中运行，假设追加并获取集合的最后一个元素S处于不变的时间。

虽然我觉得可能有更有效的解决方案......

Answer 5

我尝试做的是找到这个数组中3个数字的所有组合。

并找到它们之间的距离，如果它相等，我们找到了

喜欢：

for ($i = 1; $i <= $countArray - 2; $i++) {
     for ($j = $i+1; $j <= $countArray - 1; $j++) {         
    for ($k = $j+1; $k <= $countArray; $k++) {
            if($array[$j]-$array[$i] == $array[$k]-$array[$j]){
             # found 
            }
        }
   }
 }

Answer 6

这是Swift 4中的代码：

extension Array where Element == Int {

    var isArithmeticSequence: Bool {
        let difference = self[1] - self[0]
        for (index, _) in self.enumerated() {
            if index < self.count-1 {
                if self[index + 1] - self[index] != difference {
                    return false
                }
            }
        }
        return true
    }

    var arithmeticSlices: [[Int]] {

        var arithmeticSlices = [[Int]]()
        var sliceSize = 3
        while sliceSize < self.count+1 {

            for (index, _) in self.enumerated() {

                if (index + sliceSize-1) <= self.count - 1 {

                    let currentSlice = Array(self[index...index + sliceSize-1])
                    if currentSlice.isArithmeticSequence {
                        arithmeticSlices.append(currentSlice)
                    }
                }
            }
            sliceSize+=1
        }
        return arithmeticSlices
    }
}


let A = [23, 24, 98, 1, 2, 5]
print(A.arithmeticSlices) // []

let B = [4, 7, 10, 4,5]
print(B.arithmeticSlices) //[[1, 2, 3], [2, 3, 4], [3, 4, 5], [1, 2, 3, 4], [2, 3, 4, 5], [1, 2, 3, 4, 5]]

let C = [4, 7, 10, 23, 11, 12, 13]
print(C.arithmeticSlices) // [[4, 7, 10], [11, 12, 13]]

如果数组包含算术级数（序列），查找的方法是什么

6 个答案: