在数字数组中查找缺失数字的最快方法

Question

这个问题的答案是社区的努力。 编辑现有答案以改进这篇文章。 它目前不接受新的答案或交互。

我有一个从 1 到 100（包括两者）的数字数组。 数组的大小为 100。数字是随机添加到数组中的，但数组中有一个随机的空槽。 找到该插槽以及应该放入插槽的数字的最快方法是什么？ Java 解决方案更可取。

Answer 1

您可以在 O(n) 中执行此操作。 遍历数组并计算所有数字的总和。 现在，从 1 到 N 的自然数之和可以表示为Nx(N+1)/2 。 在您的情况下，N = 100。

从Nx(N+1)/2中减去数组的总和，其中 N=100。

那是缺少的号码。 可以在计算总和的迭代期间检测到空槽。

// will be the sum of the numbers in the array.
int sum = 0;
int idx = -1;
for (int i = 0; i < arr.length; i++)
{
    if (arr[i] == 0)
    {
         idx = i; 
    }
    else 
    {
         sum += arr[i];
    }
}

// the total sum of numbers between 1 and arr.length.
int total = (arr.length + 1) * arr.length / 2;

System.out.println("missing number is: " + (total - sum) + " at index " + idx);

Answer 2

我们可以使用比求和更安全的异或运算，因为在编程语言中，如果给定的输入很大，它可能会溢出并可能给出错误的答案。

在找到解决方案之前，请知道A xor A = 0 。 因此，如果我们对两个相同的数字进行异或运算，则值为 0。

现在，与数组中存在的元素进行 XORing [1..n] 会取消相同的数字。 所以最后我们会得到丢失的数字。

// Assuming that the array contains 99 distinct integers between 1..99
// and empty slot value is zero
int XOR = 0;
for(int i=0; i<100; i++) {
    if (ARRAY[i] != 0) // remove this condition keeping the body if no zero slot
        XOR ^= ARRAY[i];
    XOR ^= (i + 1);
}
return XOR;
//return XOR ^ ARRAY.length + 1; if your array doesn't have empty zero slot. 

Answer 3

让给定的数组是长度为 N 的 A。让我们假设在给定的数组中，单个空槽被 0 填充。

我们可以使用许多方法找到这个问题的解决方案，包括Counting sort中使用的算法。 但是，就有效的时间和空间使用而言，我们有两种算法。 一种主要使用加法、减法和乘法。 另一个使用 XOR。 从数学上讲，这两种方法都可以正常工作。 但是以编程方式，我们需要使用主要措施评估所有算法，例如

• 限制（如输入值很大（ A[1...N] ）和/或输入值的数量很大（ N ））
• 涉及的条件检查数量
• 涉及的数学运算的数量和类型

等等。这是因为时间和/或硬件（硬件资源限制）和/或软件（操作系统限制，编程语言限制等）等方面的限制。让我们列出并评估它们各自的优缺点.

算法1：

在算法 1 中，我们有 3 个实现。

1. 使用数学公式（ 1+2+3+...+N=(N(N+1))/2 ）计算所有数字的总和（包括未知的缺失数字）。 这里， N=100 。 计算所有给定数字的总和。 从第一个结果中减去第二个结果将给出缺失的数字。

   Missing Number = (N(N+1))/2) - (A[1]+A[2]+...+A[100])

2. 使用数学公式（ 1+2+3+...+N=(N(N+1))/2 ）计算所有数字的总和（包括未知的缺失数字）。 这里， N=100 。 从该结果中，减去每个给定的数字会得到缺失的数字。

   Missing Number = (N(N+1))/2)-A[1]-A[2]-...-A[100]

   ( Note:即使第二个实现的公式是从第一个派生的，从数学的角度来看，两者都是相同的。但从编程的角度来看，两者都是不同的，因为第一个公式比第二个公式更容易发生位溢出（如果给定的数字足够大）。即使加法比减法快，第二种实现减少了由大值相加引起的位溢出的机会（它没有完全消除，因为仍然存在非常小的机会，因为 ( N+1 ) 是在公式中）。但是两者都同样容易通过乘法溢出。限制是两个实现只有在N(N+1)<=MAXIMUM_NUMBER_VALUE时才能给出正确的结果。对于第一个实现，额外的限制是它给出正确的结果仅当Sum of all given numbers<=MAXIMUM_NUMBER_VALUE 。）

3. 计算所有数字的总和（包括未知的缺失数字）并在同一循环中并行减去每个给定数字。 这消除了乘法位溢出的风险，但加减法容易发生位溢出。

   //ALGORITHM missingNumber = 0; foreach(index from 1 to N) { missingNumber = missingNumber + index; //Since, the empty slot is filled with 0, //this extra condition which is executed for N times is not required. //But for the sake of understanding of algorithm purpose lets put it. if (inputArray[index] != 0) missingNumber = missingNumber - inputArray[index]; }

在编程语言（如 C、C++、Java 等）中，如果表示整数数据类型的位数是有限的，那么上述所有的实现都容易因为求和、减法和乘法而发生位溢出，从而导致错误的结果在大输入值（ A[1...N] ）和/或大量输入值（ N ）的情况下。

算法2：

我们可以利用异或的性质来解决这个问题，而不用担心位溢出的问题。 而且 XOR 比求和更安全、更快。 我们知道 XOR 的性质，即两个相同数的 XOR 等于 0（ A XOR A = 0 ）。 如果我们计算从 1 到 N 的所有数字的 XOR（这包括未知的缺失数字），然后根据该结果，对所有给定数字进行 XOR，公共数字被抵消（因为A XOR A=0 ）并且在最后我们得到丢失的号码。 如果我们没有位溢出问题，我们可以使用求和和基于 XOR 的算法来获得解决方案。 但是，使用 XOR 的算法比使用加法、减法和乘法的算法更安全、更快。 并且可以避免加减乘法带来的额外烦恼。

在算法 1 的所有实现中，我们可以使用 XOR 代替加法和减法。

让我们假设， XOR(1...N) = XOR of all numbers from 1 to N

实现 1 => Missing Number = XOR(1...N) XOR (A[1] XOR A[2] XOR...XOR A[100])

实现 2 => Missing Number = XOR(1...N) XOR A[1] XOR A[2] XOR...XOR A[100]

实施 3 =>

//ALGORITHM
missingNumber = 0;
foreach(index from 1 to N)
{
    missingNumber = missingNumber XOR index;
    //Since, the empty slot is filled with 0,
    //this extra condition which is executed for N times is not required.
    //But for the sake of understanding of algorithm purpose lets put it.
    if (inputArray[index] != 0)
        missingNumber = missingNumber XOR inputArray[index];
}

算法 2 的所有三种实现都可以正常工作（从编程的角度来看也是如此）。 一种优化是，类似于

1+2+....+N = (N(N+1))/2

我们有，

1 XOR 2 XOR .... XOR N = {N if REMAINDER(N/4)=0, 1 if REMAINDER(N/4)=1, N+1 if REMAINDER(N/4)=2, 0 if REMAINDER(N/4)=3}

我们可以用数学归纳法证明这一点。 因此，我们可以使用这个公式来减少 XOR 操作的次数，而不是通过 XOR 计算从 1 到 N 的所有数字的值。

此外，使用上述公式计算 XOR(1...N) 有两种实现方式。 实施明智，计算

// Thanks to https://a3nm.net/blog/xor.html for this implementation
xor = (n>>1)&1 ^ (((n&1)>0)?1:n)

比计算快

xor = (n % 4 == 0) ? n : (n % 4 == 1) ? 1 : (n % 4 == 2) ? n + 1 : 0;

所以，优化的 Java 代码是，

long n = 100;
long a[] = new long[n];

//XOR of all numbers from 1 to n
// n%4 == 0 ---> n
// n%4 == 1 ---> 1
// n%4 == 2 ---> n + 1
// n%4 == 3 ---> 0

//Slower way of implementing the formula
// long xor = (n % 4 == 0) ? n : (n % 4 == 1) ? 1 : (n % 4 == 2) ? n + 1 : 0;
//Faster way of implementing the formula
// long xor = (n>>1)&1 ^ (((n&1)>0)?1:n);
long xor = (n>>1)&1 ^ (((n&1)>0)?1:n);

for (long i = 0; i < n; i++)
{
    xor = xor ^ a[i];
}
//Missing number
System.out.println(xor);

Answer 4

这是一个亚马逊面试问题，最初在这里得到了回答： 我们将 1 到 52 的数字放入 51 数字数组中，找出缺少哪个数字的最佳方法是什么？

得到了答复，如下：

1) Calculate the sum of all numbers stored in the array of size 51. 
2) Subtract the sum from (52 * 53)/2 ---- Formula : n * (n + 1) / 2.

它也在这里发表了博客： 软件工作 - 面试问题

Answer 5

这是一个在整数数组中查找缺失数字的简单程序

ArrayList<Integer> arr = new ArrayList<Integer>();
int a[] = { 1,3,4,5,6,7,10 };
int j = a[0];
for (int i=0;i<a.length;i++)
{
    if (j==a[i])
    {
        j++;
        continue;
    }
    else
    {
        arr.add(j);
        i--;
    j++;
    }
}
System.out.println("missing numbers are ");
for(int r : arr)
{
    System.out.println(" " + r);
}

Answer 6

（1 到 n 的总和）-（数组中所有值的总和）= 缺失数

int sum = 0;
int idx = -1;
for (int i = 0; i < arr.length; i++) {
  if (arr[i] == 0) idx = i; else sum += arr[i];
}
System.out.println("missing number is: " + (5050 - sum) + " at index " + idx);

Answer 7

最近我在一次求职面试中遇到了一个类似（不完全相同）的问题，而且我从一位朋友那里听说在一次面试中被问到了完全相同的问题。 因此，这是对 OP 问题的答案以及可能会提出的其他一些变体。 答案示例是用Java给出的，因为它指出：

Java 解决方案更可取。

变体1：

从 1 到 100（包括两个）的数字数组 ... 数字被随机添加到数组中，但数组中有一个随机的空槽

public static int findMissing1(int [] arr){
    int sum = 0;
    for(int n : arr){
        sum += n;
    }
    return (100*(100+1)/2) - sum;
}

说明：此解决方案（与此处发布的许多其他解决方案一样）基于Triangular number公式，它为我们提供了从 1 到n的所有自然数的总和（在这种情况下， n为 100）。 现在我们知道应该从 1 到 100 的总和 - 我们只需要减去给定数组中现有数字的实际总和。

变体2：

从 1 到 n 的数字数组（表示最大数字未知）

public static int findMissing2(int [] arr){
    int sum = 0, max = 0;
    for(int n : arr){
        sum += n;
        if(n > max) max = n;
    }
    return (max*(max+1)/2) - sum;
}

说明：在这个解决方案中，由于没有给出最大数量 - 我们需要找到它。 找到最大数量后 - 逻辑是相同的。

变体3：

从 1 到 n 的数字数组（最大数未知），数组中有两个随机空槽

public static int [] findMissing3(int [] arr){
    int sum = 0, max = 0, misSum;
    int [] misNums = {};//empty by default
    for(int n : arr){
        sum += n;
        if(n > max) max = n;
    }
    misSum = (max*(max+1)/2) - sum;//Sum of two missing numbers
    for(int n = Math.min(misSum, max-1); n > 1; n--){
        if(!contains(n, arr)){
            misNums = new int[]{n, misSum-n};
            break;   
        }
    }
    return misNums;
}
private static boolean contains(int num, int [] arr){
    for(int n : arr){
        if(n == num)return true;
    }
    return false;
}

说明：在这个解决方案中，没有给出最大数字（如前所述），但它也可能缺少两个数字而不是一个。 因此，首先我们找到缺失数字的总和 - 与之前的逻辑相同。 第二次找到缺失总和和最后一个（可能）缺失的数字之间的较小数字 - 以减少不必要的搜索。 第三，由于Java的 Array（不是 Collection）没有indexOf或contains方法，因此我为该逻辑添加了一个小的可重用方法。 第四，当找到第一个丢失的数字时，第二个是从丢失的总和中减去。 如果仅缺少一个数字，则数组中的第二个数字将为零。

变体4：

从 1 到 n 的数字数组（最大数字未知），缺少 X（丢失数字的数量未知）

public static ArrayList<Integer> findMissing4(ArrayList<Integer> arr){
    int max = 0;
    ArrayList<Integer> misNums = new ArrayList();
    int [] neededNums;
    for(int n : arr){
        if(n > max) max = n;
    }
    neededNums = new int[max];//zero for any needed num
    for(int n : arr){//iterate again
        neededNums[n == max ? 0 : n]++;//add one - used as index in second array (convert max to zero)
    }
    for(int i=neededNums.length-1; i>0; i--){
        if(neededNums[i] < 1)misNums.add(i);//if value is zero, than index is a missing number
    }
    return misNums;
}

说明：在这个解决方案中，和前面一样，最大数字是未知的，可能会丢失多个数字，但在这个变体中，我们不知道有多少数字可能丢失（如果有的话）。 逻辑的开头是相同的 - 找到最大数量。 然后我用零初始化另一个数组，在这个数组中， index表示可能丢失的数字，零表示数字丢失。 因此，原始数组中的每个现有数字都用作索引，其值加一（最大值转换为零）。

笔记

如果您想要其他语言的示例或此问题的其他有趣变体，欢迎您查看我的Github存储库以获取面试问题和答案。

Answer 8

在类似的情况下，数组已经排序，它不包含重复项并且只有一个数字丢失，可以使用二进制搜索在 log(n) 时间内找到这个丢失的数字。

public static int getMissingInt(int[] intArray, int left, int right) {
    if (right == left + 1) return intArray[right] - 1;
    int pivot = left + (right - left) / 2;
    if (intArray[pivot] == intArray[left] + (intArray[right] - intArray[left]) / 2 - (right - left) % 2)
        return getMissingInt(intArray, pivot, right);
    else 
        return getMissingInt(intArray, left, pivot);
}

public static void main(String args[]) {
    int[] array = new int[]{3, 4, 5, 6, 7, 8, 10};
    int missingInt = getMissingInt(array, 0, array.length-1);
    System.out.println(missingInt); //it prints 9
}

Answer 9

好吧，使用布隆过滤器。

int findmissing(int arr[], int n)
{
    long bloom=0;
    int i;
    for(i=0; i<;n; i++)bloom+=1>>arr[i];
    for(i=1; i<=n, (bloom<<i & 1); i++);
    return i;
}

Answer 10

这是 c#，但它应该非常接近您的需要：

int sumNumbers = 0;
int emptySlotIndex = -1;

for (int i = 0; i < arr.length; i++)
{
  if (arr[i] == 0)
    emptySlotIndex = i;
  sumNumbers += arr[i];
}

int missingNumber = 5050 - sumNumbers;

Answer 11

例如，不涉及重复添加或 n(n+1)/2 公式的解决方案不会在面试时找到你。

您必须使用 4 个整数（32 位）或 2 个整数（64 位）的数组。 用 (-1 & ~(1 << 31)) >> 3 初始化最后一个 int。（高于 100 的位设置为 1）或者您可以使用 for 循环设置高于 100 的位。

1. 遍历数字数组并将与数字对应的位位置设置为 1（例如，71 将设置在从左到右第 7 位的第 3 个 int 上）
2. 遍历 4 个整数（32 位版本）或 2 个整数（64 位版本）的数组

    public int MissingNumber(int a[])
    {   
        int bits = sizeof(int) * 8;
        int i = 0;
        int no = 0;
        while(a[i] == -1)//this means a[i]'s bits are all set to 1, the numbers is not inside this 32 numbers section
        {
            no += bits;
            i++;
        }
        return no + bits - Math.Log(~a[i], 2);//apply NOT (~) operator to a[i] to invert all bits, and get a number with only one bit set (2 at the power of something)
    }

示例：（32 位版本）假设缺少的数字是 58。这意味着第二个整数的第 26 位（从左到右）设置为 0。

第一个 int 是 -1（所有位都已设置）因此，我们继续进行第二个并将数字 32 添加到“否”。第二个 int 与 -1 不同（未设置位）因此，通过应用对我们得到 64 的数字的 NOT (~) 运算符。可能的数字是 2 的 x 次方，我们可以使用以 2 为底的 log 来计算 x； 在这种情况下，我们得到 log2(64) = 6 => 32 + 32 - 6 = 58。

希望这可以帮助。

Answer 12

这不是搜索问题。 雇主想知道您是否掌握了校验和。 如果您正在寻找多个唯一整数，您可能需要一个二进制或 for 循环或其他任何东西，但问题规定“一个随机的空槽”。 在这种情况下，我们可以使用流求和。 条件：“数字随机添加到数组中”没有更多细节是没有意义的。 该问题不假定数组必须以整数 1 开头，因此可以容忍偏移起始整数。

int[] test = {2,3,4,5,6,7,8,9,10,  12,13,14 };

/*get the missing integer*/

int max = test[test.length - 1];
int min = test[0];
int sum = Arrays.stream(test).sum();
int actual = (((max*(max+1))/2)-min+1);
//Find:

//the missing value
System.out.println(actual - sum);
//the slot
System.out.println(actual - sum - min);

成功时间：0.18 内存：320576 信号：0

Answer 13

我在这里找到了这个漂亮的解决方案：

http://javaconceptoftheday.com/java-puzzle-interview-program-find-missing-number-in-an-array/

public class MissingNumberInArray
{
    //Method to calculate sum of 'n' numbers

    static int sumOfNnumbers(int n)
    {
        int sum = (n * (n+1))/ 2;

        return sum;
    }

    //Method to calculate sum of all elements of array

    static int sumOfElements(int[] array)
    {
        int sum = 0;

        for (int i = 0; i < array.length; i++)
        {
            sum = sum + array[i];
        }

        return sum;
    }

    public static void main(String[] args)
    {
        int n = 8;

        int[] a = {1, 4, 5, 3, 7, 8, 6};

        //Step 1

        int sumOfNnumbers = sumOfNnumbers(n);

        //Step 2

        int sumOfElements = sumOfElements(a);

        //Step 3

        int missingNumber = sumOfNnumbers - sumOfElements;

        System.out.println("Missing Number is = "+missingNumber);
    }
}

Answer 14

function solution($A) {
    // code in PHP5.5
    $n=count($A);
    for($i=1;$i<=$n;$i++) {
       if(!in_array($i,$A)) {
              return (int)$i;
       }
    }
}

Answer 15

从一系列数字中找到丢失的数字。 IMP 点要记住。

1. 数组应该排序..
2. 该功能不适用于多个缺失。

3. 序列必须是 AP。

    public int execute2(int[] array) { int diff = Math.min(array[1]-array[0], array[2]-array[1]); int min = 0, max = arr.length-1; boolean missingNum = true; while(min<max) { int mid = (min + max) >>> 1; int leftDiff = array[mid] - array[min]; if(leftDiff > diff * (mid - min)) { if(mid-min == 1) return (array[mid] + array[min])/2; max = mid; missingNum = false; continue; } int rightDiff = array[max] - array[mid]; if(rightDiff > diff * (max - mid)) { if(max-mid == 1) return (array[max] + array[mid])/2; min = mid; missingNum = false; continue; } if(missingNum) break; } return -1; }

Answer 16

我认为最简单且可能最有效的解决方案是遍历所有条目并使用 bitset 来记住设置了哪些数字，然后测试 0 位。 带有 0 位的条目是缺失的数字。

Answer 17

例如，您可以做的一件事是使用快速排序对数字进行排序。 然后使用for循环从1到100遍历排序后的数组。在每次迭代中，将数组中的数字与for循环增量进行比较，如果发现索引增量与数组值不同，则找到了您丢失的号码以及丢失的索引。

Answer 18

以下是从给定数组中查找所有缺失数字的解决方案：

public class FindMissingNumbers {

/**
 * The function prints all the missing numbers from "n" consecutive numbers.
 * The number of missing numbers is not given and all the numbers in the
 * given array are assumed to be unique.
 * 
 * A similar approach can be used to find all no-unique/ unique numbers from
 * the given array
 * 
 * @param n
 *            total count of numbers in the sequence
 * @param numbers
 *            is an unsorted array of all the numbers from 1 - n with some
 *            numbers missing.
 * 
 */
public static void findMissingNumbers(int n, int[] numbers) {

    if (n < 1) {
        return;
    }

    byte[] bytes = new byte[n / 8];
    int countOfMissingNumbers = n - numbers.length;

    if (countOfMissingNumbers == 0) {
        return;
    }

    for (int currentNumber : numbers) {

        int byteIndex = (currentNumber - 1) / 8;
        int bit = (currentNumber - byteIndex * 8) - 1;
        // Update the "bit" in bytes[byteIndex]
        int mask = 1 << bit;
        bytes[byteIndex] |= mask;
    }
    for (int index = 0; index < bytes.length - 2; index++) {
        if (bytes[index] != -128) {
            for (int i = 0; i < 8; i++) {
                if ((bytes[index] >> i & 1) == 0) {
                    System.out.println("Missing number: " + ((index * 8) + i + 1));
                }
            }
        }
    }
    // Last byte
    int loopTill = n % 8 == 0 ? 8 : n % 8;
    for (int index = 0; index < loopTill; index++) {
        if ((bytes[bytes.length - 1] >> index & 1) == 0) {
            System.out.println("Missing number: " + (((bytes.length - 1) * 8) + index + 1));
        }
    }

}

public static void main(String[] args) {

    List<Integer> arrayList = new ArrayList<Integer>();
    int n = 128;
    int m = 5;
    for (int i = 1; i <= n; i++) {
        arrayList.add(i);
    }
    Collections.shuffle(arrayList);
    for (int i = 1; i <= 5; i++) {
        System.out.println("Removing:" + arrayList.remove(i));
    }
    int[] array = new int[n - m];
    for (int i = 0; i < (n - m); i++) {
        array[i] = arrayList.get(i);
    }
    System.out.println("Array is: " + Arrays.toString(array));

    findMissingNumbers(n, array);
}

}

Answer 19

假设您将 n 设为 8，对于此示例，我们的数字范围为 0-8，我们可以将所有 9 个数字的二进制表示形式如下 0000 0001 0010 0011 0100 0101 0110 0111 1000

在上面的序列中，没有丢失的数字，并且在每一列中，0 和 1 的数量匹配，但是一旦您删除 1 个值，让我们说 3，我们就会在各列中的 0 和 1 的数量上保持平衡。 如果一列中 0 的数量 <= 1 的数量，我们缺失的数字将在该位的位置为 0，否则如果 0 的数量 > 在该位的位置 1 的数量，则该位的位置将为 1 . 我们从左到右测试位，并且在每次迭代中，我们丢弃数组的一半以测试下一位，奇数数组值或偶数数组值在每次迭代时被丢弃，具体取决于我们缺少哪个位上。

以下解决方案在 C++ 中

int getMissingNumber(vector<int>* input, int bitPos, const int startRange)
{
    vector<int> zeros;
    vector<int> ones;
    int missingNumber=0;

    //base case, assume empty array indicating start value of range is missing
    if(input->size() == 0)
        return startRange;

    //if the bit position being tested is 0 add to the zero's vector
    //otherwise to the ones vector
    for(unsigned int i = 0; i<input->size(); i++)
    {
        int value = input->at(i);
        if(getBit(value, bitPos) == 0)
            zeros.push_back(value);
        else
            ones.push_back(value);
    }

    //throw away either the odd or even numbers and test
    //the next bit position, build the missing number
    //from right to left
    if(zeros.size() <= ones.size())
    {
        //missing number is even
        missingNumber = getMissingNumber(&zeros, bitPos+1, startRange);
        missingNumber = (missingNumber << 1) | 0;
    }
    else
    {
        //missing number is odd
        missingNumber = getMissingNumber(&ones, bitPos+1, startRange);
        missingNumber = (missingNumber << 1) | 1;
    }

    return missingNumber;
}

在每次迭代中，我们将输入空间减少 2，即 N, N/2,N/4 ... = O(log N)，空间 O(N)

//Test cases 
[1] when missing number is range start
[2] when missing number is range end
[3] when missing number is odd
[4] when missing number is even

Answer 20

PHP $n = 100的解决方案；

$n*($n+1)/2 - array_sum($array) = $missing_number

和array_search($missing_number)将给出缺失数字的索引

Answer 21

这里程序的时间复杂度为 O(logn)，空间复杂度为 O(logn)

public class helper1 {

public static void main(String[] args) {


    int a[] = {1, 2, 3, 4, 5, 7, 8, 9, 10, 11, 12};


    int k = missing(a, 0, a.length);
    System.out.println(k);
}

public static int missing(int[] a, int f, int l) {


    int mid = (l + f) / 2;

    //if first index reached last then no element found 
    if (a.length - 1 == f) {
        System.out.println("missing not find ");
        return 0;
    }

    //if mid with first found 
    if (mid == f) {
        System.out.println(a[mid] + 1);
        return a[mid] + 1;
    }

    if ((mid + 1) == a[mid])
        return missing(a, mid, l);
    else
        return missing(a, f, mid);

  }
 }

Answer 22

public class MissingNumber {

public static void main(String[] args) {
     int array[] = {1,2,3,4,6};
     int x1 = getMissingNumber(array,6);
    System.out.println("The Missing number is: "+x1);


}
private static int getMissingNumber(int[] array, int i) {

    int acctualnumber =0;
    int expectednumber = (i*(i+1)/2);

    for (int j : array) {
        acctualnumber = acctualnumber+j;

    }
    System.out.println(acctualnumber);
    System.out.println(expectednumber);
    return expectednumber-acctualnumber;

}
}

Answer 23

使用求和公式，

class Main {
// Function to ind missing number
     static int getMissingNo (int a[], int n) {
          int i, total;
          total  = (n+1)*(n+2)/2;   
          for ( i = 0; i< n; i++)
              total -= a[i];
          return total;
     }

    /* program to test above function */
    public static void main(String args[]) {

        int a[] = {1,2,4,5,6};
        int miss = getMissingNo(a,5);
        System.out.println(miss);   
   }
}

参考http://www.geeksforgeeks.org/find-the-missing-number/

Answer 24

simple solution with test data :

class A{

  public static void main(String[] args){
    int[] array = new int[200];
    for(int i=0;i<100;i++){
      if(i != 51){
        array[i] = i;  
      }
    }

    for(int i=100;i<200;i++){
      array[i] = i;  
    }

    int temp = 0;
    for(int i=0;i<200;i++){
      temp ^= array[i];
    }

    System.out.println(temp);
  }
} 

Answer 25

现在我对大 O 表示法太敏锐了，但你不能也做一些类似的事情（在 Java 中）

for (int i = 0; i < numbers.length; i++) {
    if(numbers[i] != i+1){
        System.out.println(i+1);
    }
}

其中 numbers 是您的数字从 1 到 100 的数组。 根据我对问题的阅读，它没有说明何时写出丢失的数字。

或者，如果您可以将 i+1 的值放入另一个数组并在迭代后将其打印出来。

当然也可能不遵守时空规则。 就像我说的。 我必须强烈地复习Big O。

Answer 26

========排序数组的最简单解决方案============

public int getMissingNumber(int[] sortedArray)
        {
            int missingNumber = 0;
            int missingNumberIndex=0;
            for (int i = 0; i < sortedArray.length; i++)
            {
                if (sortedArray[i] == 0)
                {
                    missingNumber = (sortedArray[i + 1]) - 1;
                    missingNumberIndex=i;
                    System.out.println("missingNumberIndex: "+missingNumberIndex);
                    break;
                }
            }
            return missingNumber;
        }

Answer 27

    //Array is shorted and if writing in C/C++ think of XOR implementations in java as follows.
                    int num=-1;
    for (int i=1; i<=100; i++){
        num =2*i;
        if(arr[num]==0){
         System.out.println("index: "+i+" Array position: "+ num);      
         break;
        }
        else if(arr[num-1]==0){
         System.out.println("index: "+i+ " Array position: "+ (num-1)); 
         break;             
        }           
    }// use Rabbit and tortoise race, move the dangling index faster, 
     //learnt from Alogithimica, Ameerpet, hyderbad**

Answer 28

如果数组是随机填充的，那么您最多可以进行 O(n) 复杂度的线性搜索。 但是，我们可以通过类似于 giri 指出的快速排序的分而治之方法将复杂性提高到 O(log n)，因为这些数字是按升序/降序排列的。

Answer 29

该程序查找丢失的数字

<?php
$arr_num=array("1","2","3","5","6");
$n=count($arr_num);
for($i=1;$i<=$n;$i++)
{       
      if(!in_array($i,$arr_num))
      {
      array_push($arr_num,$i);print_r($arr_num);exit;
      }

}
?>

Answer 30

另一个家庭作业问题。 顺序搜索是您能做的最好的事情。 至于 Java 解决方案，请考虑为读者练习。 :P