数字の配列で不足している数字を見つける最も簡単な方法
1〜100の数値の配列（両方を含む）があります。配列のサイズは100です。数字は配列にランダムに追加されますが、配列にはランダムな空のスロットが1つあります。そのスロットとスロットに入れるべき番号を見つける最も速い方法は何ですか？ Javaソリューションが推奨されます。
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);
プログラミング言語では与えられた入力が大きいとオーバーフローし、間違った答えを返す可能性があるため、合計より安全なXOR操作を使用できます。
ソリューションに進む前に、A xor A = 0であることを確認してください。したがって、2つの同一の番号をXORすると、値は0になります。
現在、配列に存在する要素と[1..n]のXORをとると、同じ数字がキャンセルされます。そのため、最後に不足している番号を取得します。
// 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)
XOR ^= ARRAY[i];
XOR ^= (i + 1);
}
return XOR;
指定された配列を長さNのAとします。指定された配列で、単一の空のスロットが0で埋められていると仮定します。
Counting sortで使用されるアルゴリズムを含む多くの方法を使用して、この問題の解決策を見つけることができます。しかし、効率的な時間とスペースの使用という観点から、2つのアルゴリズムがあります。主に加算、減算、乗算を使用します。もう1つはXORを使用します。数学的には両方の方法がうまく機能します。しかし、プログラム的には、次のような主要な手段ですべてのアルゴリズムを評価する必要があります
- 制限（入力値が大きい（
A[1...N]）や入力値の数が大きい（N）など） - 関係する条件チェックの数
- 関係する数学演算の数と種類
これは、時間および/またはハードウェア（ハードウェアリソースの制限）および/またはソフトウェア（オペレーティングシステムの制限、プログラミング言語の制限など）の制限などによるものです。それぞれの長所と短所をリストして評価します。 。
アルゴリズム1：
アルゴリズム1では、3つの実装があります。
数式（
1+2+3+...+N=(N(N+1))/2）を使用して、すべての数値の合計を計算します（これには未知の欠落した数値が含まれます）。ここで、N=100。指定されたすべての数値の合計を計算します。最初の結果から2番目の結果を減算すると、不足している数値が得られます。Missing Number = (N(N+1))/2) - (A[1]+A[2]+...+A[100])数式（
1+2+3+...+N=(N(N+1))/2）を使用して、すべての数値の合計を計算します（これには未知の欠落した数値が含まれます）。ここで、N=100。その結果から、指定された各数値を減算すると、欠落した数値が得られます。Missing Number = (N(N+1))/2)-A[1]-A[2]-...-A[100]（
Note:2番目の実装の式は最初から派生していますが、数学的な観点からは両方とも同じです。しかし、プログラミングの観点からは、最初の式は2番目の式よりビットオーバーフローが発生しやすいため、両方とも異なります（加算が減算よりも速い場合でも、2番目の実装は、大きな値を加算することで生じるビットオーバーフローの可能性を減らします（完全に除去されないため、（N+1）は式にあります）しかし、両方とも同様に乗算によるビットオーバーフローの傾向があります。制限は、両方の実装がN(N+1)<=MAXIMUM_NUMBER_VALUEの場合のみ正しい結果を与えることです。最初の実装では、追加の制限はSum of all given numbers<=MAXIMUM_NUMBER_VALUE。）すべての数値の合計を計算し（これには不明な欠損値が含まれます）、同じループ内の指定された各数値を並列で減算します。これにより、乗算によるビットオーバーフローのリスクがなくなりますが、加算と減算によるビットオーバーフローが発生しやすくなります。
//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のプロパティは、2つの同じ数字のXORが0（A XOR A = 0）に等しいことを知っています。 1からNまでのすべての数字のXOR（不明な欠損値を含む）を計算し、その結果でXORすべての与えられた数字を計算すると、共通の数字はキャンセルされますout（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の3つの実装はすべて正常に動作します（プログラムの観点からも）。 1つの最適化は、
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（1 ... N）の値をXOR 1からNまでのすべての数で計算する代わりに、この式を使用してXOR操作の数を減らすことができます。 。
また、上記の式を使用してXOR（1 ... N）を計算するには、2つの実装があります。賢明な実装、計算
// 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);
これはAmazonのインタビューの質問であり、元々はここで回答されました： 51の数値配列に入れられる1から52の数値があります。どの数値が欠落しているかを見つける最良の方法は何ですか？
以下のように回答されました：
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.
ここにもブログが掲載されていました： Software Job-Interview Question
整数配列で不足している数字を見つける簡単なプログラムを次に示します
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);
}
5050-（配列内のすべての値の合計）=欠落数
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);
同様のシナリオ、配列が既にソートされている場合、重複は含まれず、1つの数値のみが欠落しています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
}
最近、私は就職の面接で同様の（まったく同じではない）質問をしました。また、面接でまったく同じ質問をされた友人から聞いたことがあります。そのため、OPの質問に対する回答と、潜在的に尋ねられる可能性のあるいくつかのバリエーションがあります。答えの例はJavaで与えられています。なぜなら、それは次のように述べられているからです：
Javaソリューションが推奨されます。
バリエーション1：
1から100までの数値の配列（両方を含む）...数値は配列にランダムに追加されますが、配列にはランダムな空のスロットが1つあります
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までの数字の配列（最大数は不明）、配列内に2つのランダムな空のスロットがあります
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;
}
説明：このソリューションでは、最大数は指定されていません（前と同じ）が、1つではなく2つの数が欠落している可能性もあります。そのため、最初は不足している数字の合計を見つけます-以前と同じロジックで。不足している合計と最後の（おそらく）不足している数の間の小さい数を見つける-不要な検索を減らす3番目に、Javas配列（コレクションではない）にはindexOfやcontainsのようなメソッドがないため、そのロジックに小さな再利用可能なメソッドを追加しました。 4番目に、最初の欠落数が見つかった場合、2番目は欠落した合計からの減算です。 1つの数値のみが欠落している場合、配列の2番目の数値はゼロになります。
バリエーション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は潜在的に欠落している数値を示し、ゼロは数値が欠落していることを示します。したがって、元の配列のすべての既存の数値がインデックスとして使用され、その値は1ずつ増加します（最大値はゼロに変換されます）。
注
他の言語または別のこの質問の興味深いバリエーションの例が必要な場合は、Githubリポジトリで インタビューの質問と回答 を確認してください。
さて、ブルームフィルターを使用します。
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;
}
繰り返しの追加や多分n（n + 1）/ 2式を含まないソリューションは、たとえばインタビュー時にあなたに届かないでしょう。
4つの整数（32ビット）または2つの整数（64ビット）の配列を使用する必要があります。最後のintを（-1＆〜（1 << 31））>> 3.で初期化します（100を超えるビットは1に設定されます）または、forループを使用して100を超えるビットを設定することもできます。
- 数字の配列を調べて、数字に対応するビット位置に1を設定します（たとえば、71は左から右への7番目のビットの3番目のintに設定されます）
- 4 int（32ビットバージョン）または2 int（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であると言います。これは、2番目の整数の26番目のビット（左から右）が0に設定されることを意味します。
最初のintは-1（すべてのビットが設定されている）であるため、2番目のintに進み、「no」に32を加算します。2番目のintは-1（ビットが設定されていない）と異なるNOT（〜）演算子から64を取得します。可能な数値は2の累乗xであり、2を底とする対数を使用してxを計算できます。この場合、log2（64）= 6 => 32 + 32-6 = 58になります。
お役に立てれば。
これは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;
私はこの美しい解決策をここで見つけました：
http://javaconceptoftheday.com/Java-puzzle-interview-program-find-missing-number-in-an-an//
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);
}
}
最も簡単で、おそらく最も効率的な解決策は、すべてのエントリをループし、ビットセットを使用してどの番号が設定されているかを覚えてから、0ビットをテストすることだと思います。 0ビットのエントリは、欠落している番号です。
これは検索の問題ではありません。雇用主は、あなたがチェックサムを把握しているかどうか疑問に思っています。複数の一意の整数を探している場合は、バイナリまたはforループなどが必要になる場合がありますが、質問では「1つのランダムな空のスロット」を規定しています。この場合、ストリームの合計を使用できます。条件：「数値がランダムに配列に追加される」は、詳細なしでは意味がありません。質問は、配列が整数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
function solution($A) {
// code in PHP5.5
$n=count($A);
for($i=1;$i<=$n;$i++) {
if(!in_array($i,$A)) {
return (int)$i;
}
}
}
一連の数字から欠落している数字を見つける。 IMPは覚えておくべきポイントです。
- 配列をソートする必要があります。
- 関数は、複数の欠落に対して機能しません。
シーケンスは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; }
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;
}
}
できることの1つは、たとえばクイックソートを使用して数値をソートすることです。次に、forループを使用して、ソートされた配列を1から100まで繰り返します。各反復で、配列内の数値をforループの増分と比較します。インデックスの増分が配列の値と異なる場合は、不足している番号と不足しているインデックスが見つかりました。
合計式を使用し、
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);
}
}
Nが8であり、この例では0〜8の範囲の数値を使用すると、9つの数値すべてのバイナリ表現を次のように表すことができます。0000 0001 0010 0011 0100 0101 0110 0111 1000
上記のシーケンスでは欠落している数字はなく、各列でゼロと1の数は一致しますが、1つの値を削除するとすぐに、列全体で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
========ソートされたアレイの最も簡単なソリューション===========
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;
}
以下は、指定された配列から欠落しているすべての数値を見つけるためのソリューションです。
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);
}
}
このプログラムは不足している番号を見つけます
<?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;
}
}
?>
PHPを使用したソリューション$ n = 1;
$n*($n+1)/2 - array_sum($array) = $missing_number
array_search($missing_number)は、欠落している数値のインデックスを提供します
ここで、プログラムの所要時間の複雑さは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);
}
}
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);
}
}