在算术级数中找到缺失的数字

给定一个按顺序表示算术级数元素的数组。进程中缺少一个元素，找到缺少的数字。
例子：

Input: arr[]  = {2, 4, 8, 10, 12, 14}
Output: 6

Input: arr[]  = {1, 6, 11, 16, 21, 31};
Output: 26

一个简单的解决方案是线性遍历数组并找到丢失的数字。该解决方案的时间复杂度为 O(n)。
我们可以使用二分搜索在 O(Logn) 时间内解决这个问题。这个想法是去中间元素。检查 middle 和 next to middle 之间的差异是否等于 diff ，如果不是，则缺少的元素位于 mid 和 mid+1 之间。如果中间元素等于算术级数中的^第n/2 项(令 n 为输入数组中的元素数)，则缺失元素位于右半部分。 Else 元素位于左半部分。
以下是上述想法的实现。

C++

// C++ program to find the missing number
// in a given arithmetic progression
#include
using namespace std;
#define INT_MAX 2147483647;
class GFG
{
     
// A binary search based recursive function that returns
// the missing element in arithmetic progression
public:int findMissingUtil(int arr[], int low,
                           int high, int diff)
{
    // There must be two elements to find the missing
    if (high <= low)
        return INT_MAX;
 
    // Find index of middle element
    int mid = low + (high - low) / 2;
 
    // The element just after the middle element is missing.
    // The arr[mid+1] must exist, because we return when
    // (low == high) and take floor of (high-low)/2
    if (arr[mid + 1] - arr[mid] != diff)
        return (arr[mid] + diff);
 
    // The element just before mid is missing
    if (mid > 0 && arr[mid] - arr[mid - 1] != diff)
        return (arr[mid - 1] + diff);
 
    // If the elements till mid follow AP, then recur
    // for right half
    if (arr[mid] == arr[0] + mid * diff)
        return findMissingUtil(arr, mid + 1,
                               high, diff);
 
    // Else recur for left half
    return findMissingUtil(arr, low, mid - 1, diff);
}
 
// The function uses findMissingUtil() to
// find the missing element in AP.
// It assumes that there is exactly one
// missing element and may give incorrect result
// when there is no missing element or
// more than one missing elements. This function
// also assumes that the difference in AP is an
// integer.
int findMissing(int arr[], int n)
{
    // If exactly one element is missing, then we can find
    // difference of arithmetic progression using following
    // formula. Example, 2, 4, 6, 10, diff = (10-2)/4 = 2.
    // The assumption in formula is that the difference is
    // an integer.
    int diff = (arr[n - 1] - arr[0]) / n;
 
    // Binary search for the missing
    // number using above calculated diff
    return findMissingUtil(arr, 0, n - 1, diff);
}
};
 
// Driver Code
int main()
{
    GFG g;
    int arr[] = {2, 4, 8, 10, 12, 14};
    int n = sizeof(arr) / sizeof(arr[0]);
    cout << "The missing element is "
         << g.findMissing(arr, n);
    return 0;
}
 
// This code is contributed by Soumik

C

// A C program to find the missing number in a given
// arithmetic progression
#include 
#include 
 
// A binary search based recursive function that returns
// the missing element in arithmetic progression
int findMissingUtil(int arr[], int low, int high, int diff)
{
    // There must be two elements to find the missing
    if (high <= low)
        return INT_MAX;
 
    // Find index of middle element
    int mid = low + (high - low)/2;
 
    // The element just after the middle element is missing.
    // The arr[mid+1] must exist, because we return when
    // (low == high) and take floor of (high-low)/2
    if (arr[mid+1] - arr[mid] != diff)
        return (arr[mid] + diff);
 
    // The element just before mid is missing
    if (mid > 0 && arr[mid] - arr[mid-1] != diff)
        return (arr[mid-1] + diff);
 
    // If the elements till mid follow AP, then recur
    // for right half
    if (arr[mid] == arr[0] + mid*diff)
        return findMissingUtil(arr, mid+1, high, diff);
 
    // Else recur for left half
    return findMissingUtil(arr, low, mid-1, diff);
}
 
// The function uses findMissingUtil() to find the missing
// element in AP.  It assumes that there is exactly one missing
// element and may give incorrect result when there is no missing
// element or more than one missing elements.
// This function also assumes that the difference in AP is an
// integer.
int findMissing(int arr[], int n)
{
    // If exactly one element is missing, then we can find
    // difference of arithmetic progression using following
    // formula.  Example, 2, 4, 6, 10, diff = (10-2)/4 = 2.
    // The assumption in formula is that the difference is
    // an integer.
    int diff = (arr[n-1] - arr[0])/n;
 
    // Binary search for the missing number using above
    // calculated diff
    return findMissingUtil(arr, 0, n-1, diff);
}
 
/* Driver program to check above functions */
int main()
{
    int arr[] = {2, 4, 8, 10, 12, 14};
    int n = sizeof(arr)/sizeof(arr[0]);
    printf("The missing element is %d", findMissing(arr, n));
    return 0;
}

Java

// A Java program to find
// the missing number in
// a given arithmetic
// progression
import java.io.*;
 
class GFG
{
     
// A binary search based
// recursive function that
// returns the missing
// element in arithmetic
// progression
static int findMissingUtil(int arr[], int low,
                           int high, int diff)
{
    // There must be two elements
    // to find the missing
    if (high <= low)
        return Integer.MAX_VALUE;
 
    // Find index of
    // middle element
    int mid = low + (high - low) / 2;
 
    // The element just after the
    // middle element is missing.
    // The arr[mid+1] must exist,
    // because we return when
    // (low == high) and take
    // floor of (high-low)/2
    if (arr[mid + 1] - arr[mid] != diff)
        return (arr[mid] + diff);
 
    // The element just
    // before mid is missing
    if (mid > 0 && arr[mid] -
                   arr[mid - 1] != diff)
        return (arr[mid - 1] + diff);
 
    // If the elements till mid follow
    // AP, then recur for right half
    if (arr[mid] == arr[0] + mid * diff)
        return findMissingUtil(arr, mid + 1,
                               high, diff);
 
    // Else recur for left half
    return findMissingUtil(arr, low, mid - 1, diff);
}
 
// The function uses findMissingUtil()
// to find the missing element in AP.
// It assumes that there is exactly
// one missing element and may give
// incorrect result when there is no
// missing element or more than one
// missing elements. This function also
// assumes that the difference in AP is
// an integer.
static int findMissing(int arr[], int n)
{
    // If exactly one element is missing,
    // then we can find difference of
    // arithmetic progression using
    // following formula. Example, 2, 4,
    // 6, 10, diff = (10-2)/4 = 2.
    // The assumption in formula is that
    // the difference is an integer.
    int diff = (arr[n - 1] - arr[0]) / n;
 
    // Binary search for the missing
    // number using above calculated diff
    return findMissingUtil(arr, 0, n - 1, diff);
}
 
// Driver Code
public static void main (String[] args)
{
    int arr[] = {2, 4, 8, 10, 12, 14};
    int n = arr.length;
    System.out.println("The missing element is "+  
                            findMissing(arr, n));
}
}
 
// This code is contributed by anuj_67.

Python3

# A Python3 program to find the missing
# number in a given arithmetic progression
import sys
 
# A binary search based recursive function
# that returns the missing element in
# arithmetic progression
def findMissingUtil(arr, low, high, diff):
 
    # There must be two elements to
    # find the missing
    if (high <= low):
        return sys.maxsize;
 
    # Find index of middle element
    mid = int(low + (high - low) / 2);
 
    # The element just after the middle
    # element is missing. The arr[mid+1]
    # must exist, because we return when
    # (low == high) and take floor of
    # (high-low)/2
    if (arr[mid + 1] - arr[mid] != diff):
        return (arr[mid] + diff);
 
    # The element just before mid is missing
    if (mid > 0 and arr[mid] -
                    arr[mid - 1] != diff):
        return (arr[mid - 1] + diff);
 
    # If the elements till mid follow AP,
    # then recur for right half
    if (arr[mid] == arr[0] + mid * diff):
        return findMissingUtil(arr, mid + 1,
                                high, diff);
 
    # Else recur for left half
    return findMissingUtil(arr, low,
                           mid - 1, diff);
 
# The function uses findMissingUtil() to find
# the missing element in AP. It assumes that
# there is exactly one missing element and may
# give incorrect result when there is no missing
# element or more than one missing elements.
# This function also assumes that the difference
# in AP is an integer.
def findMissing(arr, n):
 
    # If exactly one element is missing, then
    # we can find difference of arithmetic
    # progression using following formula.
    # Example, 2, 4, 6, 10, diff = (10-2)/4 = 2.
    # The assumption in formula is that the
    # difference is an integer.
    diff = int((arr[n - 1] - arr[0]) / n);
 
    # Binary search for the missing number
    # using above calculated diff
    return findMissingUtil(arr, 0, n - 1, diff);
 
# Driver Code
arr = [2, 4, 8, 10, 12, 14];
n = len(arr);
print("The missing element is",
          findMissing(arr, n));
 
# This code is contributed by chandan_jnu

C#

// A C# program to find
// the missing number in
// a given arithmetic
// progression
using System;
 
class GFG
{
     
// A binary search based
// recursive function that
// returns the missing
// element in arithmetic
// progression
static int findMissingUtil(int []arr, int low,
                           int high, int diff)
{
    // There must be two elements
    // to find the missing
    if (high <= low)
        return int.MaxValue;
 
    // Find index of
    // middle element
    int mid = low + (high -
                     low) / 2;
 
    // The element just after the
    // middle element is missing.
    // The arr[mid+1] must exist,
    // because we return when
    // (low == high) and take
    // floor of (high-low)/2
    if (arr[mid + 1] -
        arr[mid] != diff)
        return (arr[mid] + diff);
 
    // The element just
    // before mid is missing
    if (mid > 0 && arr[mid] -
                   arr[mid - 1] != diff)
        return (arr[mid - 1] + diff);
 
    // If the elements till mid follow
    // AP, then recur for right half
    if (arr[mid] == arr[0] +
               mid * diff)
        return findMissingUtil(arr, mid + 1,
                               high, diff);
 
    // Else recur for left half
    return findMissingUtil(arr, low,
                           mid - 1, diff);
}
 
// The function uses findMissingUtil()
// to find the missing element
// in AP. It assumes that there
// is exactly one missing element
// and may give incorrect result
// when there is no missing element
// or more than one missing elements.
// This function also assumes that
// the difference in AP is an integer.
static int findMissing(int []arr, int n)
{
    // If exactly one element
    // is missing, then we can
    // find difference of arithmetic
    // progression using following
    // formula. Example, 2, 4, 6, 10,
    // diff = (10-2)/4 = 2.The assumption
    // in formula is that the difference
    // is an integer.
    int diff = (arr[n - 1] -
                arr[0]) / n;
 
    // Binary search for the
    // missing number using
    // above calculated diff
    return findMissingUtil(arr, 0,
                           n - 1, diff);
}
 
// Driver Code
public static void Main ()
{
    int []arr = {2, 4, 8,
                 10, 12, 14};
    int n = arr.Length;
    Console.WriteLine("The missing element is "+
                           findMissing(arr, n));
}
}
 
// This code is contributed by anuj_67.

PHP

 0 && $arr[$mid] - $arr[$mid - 1] != $diff)
        return ($arr[$mid - 1] + $diff);
 
    // If the elements till mid follow AP,
    // then recur for right half
    if ($arr[$mid] == $arr[0] + $mid * $diff)
        return findMissingUtil($arr, $mid + 1,
                               $high, $diff);
 
    // Else recur for left half
    return findMissingUtil($arr, $low, $mid - 1, $diff);
}
 
// The function uses findMissingUtil() to find
// the missing element in AP. It assumes that
// there is exactly one missing element and may
// give incorrect result when there is no missing
// element or more than one missing elements.
// This function also assumes that the difference
// in AP is an integer.
function findMissing($arr, $n)
{
    // If exactly one element is missing, then
    // we can find difference of arithmetic
    // progression using following formula.
    // Example, 2, 4, 6, 10, diff = (10-2)/4 = 2.
    // The assumption in formula is that the
    // difference is an integer.
    $diff = ($arr[$n - 1] - $arr[0]) / $n;
 
    // Binary search for the missing number
    //  using above calculated diff
    return findMissingUtil($arr, 0, $n - 1, $diff);
}
 
// Driver Code
$arr = array(2, 4, 8, 10, 12, 14);
$n = sizeof($arr);
echo "The missing element is ",
         findMissing($arr, $n);
 
// This code is contributed by Sach_Code
?>

Javascript

 
    // A JavaScript program to find
    // the missing number in
    // a given arithmetic
    // progression
     
    // A binary search based
    // recursive function that
    // returns the missing
    // element in arithmetic
    // progression
    function findMissingUtil(arr, low, high, diff)
    {
        // There must be two elements
        // to find the missing
        if (high <= low)
            return Number.MAX_VALUE;
 
        // Find index of
        // middle element
        let mid = low + parseInt((high - low) / 2, 10);
 
        // The element just after the
        // middle element is missing.
        // The arr[mid+1] must exist,
        // because we return when
        // (low == high) and take
        // floor of (high-low)/2
        if (arr[mid + 1] - arr[mid] != diff)
            return (arr[mid] + diff);
 
        // The element just
        // before mid is missing
        if (mid > 0 && arr[mid] -
                       arr[mid - 1] != diff)
            return (arr[mid - 1] + diff);
 
        // If the elements till mid follow
        // AP, then recur for right half
        if (arr[mid] == arr[0] + mid * diff)
            return findMissingUtil(arr, mid + 1, high, diff);
 
        // Else recur for left half
        return findMissingUtil(arr, low, mid - 1, diff);
    }
 
    // The function uses findMissingUtil()
    // to find the missing element in AP.
    // It assumes that there is exactly
    // one missing element and may give
    // incorrect result when there is no
    // missing element or more than one
    // missing elements. This function also
    // assumes that the difference in AP is
    // an integer.
    function findMissing(arr, n)
    {
        // If exactly one element is missing,
        // then we can find difference of
        // arithmetic progression using
        // following formula. Example, 2, 4,
        // 6, 10, diff = (10-2)/4 = 2.
        // The assumption in formula is that
        // the difference is an integer.
        let diff = parseInt((arr[n - 1] - arr[0]) / n, 10);
 
        // Binary search for the missing
        // number using above calculated diff
        return findMissingUtil(arr, 0, n - 1, diff);
    }
     
    let arr = [2, 4, 8, 10, 12, 14];
    let n = arr.length;
    document.write("The missing element is "+  
                            findMissing(arr, n));
   

输出：

The missing element is 6

如果您希望与专家一起参加现场课程，请参阅DSA 现场工作专业课程和学生竞争性编程现场课程。