私の同僚が使用する興味深いインタビューの質問：
符号なし64ビット整数の非常に長いソートされていないリストが与えられたとします。リストにない最小の非負の整数をどのように見つけますか？
フォローアップ：ソートによる明らかな解決策が提案されたので、O（n log n）よりも速く実行できますか？
フォローアップ：アルゴリズムは、たとえば1GBのメモリを搭載したコンピュータで実行する必要があります
明確化：リストはRAMにありますが、大量に消費する可能性があります。リストのサイズ、たとえばNが事前に与えられます。
回答:
データ構造をその場で変更でき、ランダムアクセスをサポートしている場合は、O（N）時間とO（1）追加スペースでそれを行うことができます。配列を順番に調べ、すべてのインデックスについて、値で指定されたインデックスにインデックスの値を書き込み、その場所の任意の値をその場所に再帰的に配置し、値> Nを破棄します。次に、配列をもう一度調べてスポットを探します。ここで、値はインデックスと一致しません。これは、配列にない最小の値です。これにより、最大で3Nの比較が行われ、一時スペースに相当する数個の値のみが使用されます。
# Pass 1, move every value to the position of its value
for cursor in range(N):
target = array[cursor]
while target < N and target != array[target]:
new_target = array[target]
array[target] = target
target = new_target
# Pass 2, find first location where the index doesn't match the value
for cursor in range(N):
if array[cursor] != cursor:
return cursor
return N
O(N)これは、O(N)スペースを使用する簡単なソリューションです。入力リストを非負の数に制限していて、リストにない最初の非負の数を見つけたいと想定しています。
N。Nallに初期化されたブール値の配列を割り当てますfalse。 Xリスト内の各数値について、Xが未満の場合は、配列の要素をNに設定X'thしtrueます。0し、最初の要素であるを探しfalseます。falseインデックスIで最初のものを見つけたら、それIが答えです。それ以外の場合（つまり、すべての要素がである場合true）、答えはNです。実際には、「Nブール値の配列」はおそらく、byteまたはint配列として表される「ビットマップ」または「ビットセット」としてエンコードされます。これにより、通常、使用するスペースが少なくなり（プログラミング言語によって異なります）、最初のスキャンをfalseより迅速に実行できます。
これが、アルゴリズムが機能する方法/理由です。
Nリスト内の番号が明確でないか、1つ以上の番号がN。より大きいと仮定します。これは、リストにない範囲に少なくとも1つの数値が存在する必要があることを意味し0 .. N - 1ます。したがって、最小の欠落数を見つける問題は、N。未満の最小の欠落数を見つける問題に還元する必要があります。これはN、答えにはならないため、...以上の数値を追跡する必要がないことを意味します。
前の段落の代わりに、リストはからの番号の順列です0 .. N - 1。この場合、ステップ3は配列のすべての要素をに設定しtrue、ステップ4は最初の「欠落している」数がであると通知しNます。
アルゴリズムの計算の複雑さは、O(N)比例定数が比較的小さいことです。リストを2回線形パスするか、リストの長さが最初からわかっている場合は1回だけパスします。リスト全体をメモリに保持することを表す必要はないため、アルゴリズムの漸近的なメモリ使用量は、ブール値の配列を表すために必要なものです。すなわちO(N)ビット。
（対照的に、メモリ内の並べ替えまたはパーティショニングに依存するアルゴリズムは、リスト全体をメモリ内で表現できることを前提としています。質問された形式では、O(N)64ビットワードが必要になります。）
@Jornは、ステップ1から3は、ソートのカウントのバリエーションであるとコメントしています。ある意味で彼は正しいですが、違いは重要です。
Xmax - Xminカウンターの配列が必要です。ここXmaxで、はリスト内の最大数であり、はリスト内Xminの最小数です。各カウンターは、N個の状態を表すことができなければなりません。つまり、バイナリ表現を想定すると、（少なくとも）整数型のceiling(log2(N))ビットが必要です。Xmaxとを決定する必要がありXminます。ceiling(log2(N)) * (Xmax - Xmin)ビットです。対照的に、上記のアルゴリズムNでは、最悪の場合と最良の場合にビットが必要です。
ただし、この分析により、アルゴリズムがゼロを探してリストを最初に通過した場合（および必要に応じてリスト要素をカウントした場合）、ゼロが見つかった場合はスペースをまったく使用せずに迅速な回答が得られるという直感につながります。リスト内に少なくとも1つのゼロが見つかる可能性が高い場合は、これを行う価値があります。そして、この余分なパスは全体的な複雑さを変えません。
編集：ビットとビットマップを使用した元の説明が混乱していると思われるため、アルゴリズムの説明を「ブール値の配列」を使用するように変更しました。
bool[]ビットマップまたはビットマップで実装することは、一般的な解決策とは無関係です。
OPは、元のリストがRAMに保持され、コンピューターにはたとえば1GBのメモリしかないことを指定しているので、手足に出て、答えがゼロであると予測します。
1GBのRAMは、リストに最大で134,217,728個の番号を含めることができることを意味します。しかし、2 64 = 18,446,744,073,709,551,616の可能な数があります。したがって、ゼロがリストに含まれる確率は、137,438,953,472分の1です。
対照的に、今年の落雷の確率は70万分の1です。そして、隕石に見舞われる確率は約10兆分の1です。ですから、答えがゼロでないよりも、天体による早すぎる死のために、私は科学雑誌に書かれる可能性が約10倍あります。
他の回答で指摘されているように、並べ替えを行ってから、ギャップが見つかるまでスキャンするだけです。
ギャップを含む可能性のある候補ではないパーティションを削除する修正されたクイックソートを使用することにより、アルゴリズムの複雑さをO（N）に改善し、O（N）スペースを維持できます。
これにより、多数の計算が節約されます。
O(N)思考の落とし穴の1つを説明するために、ここにスペースO(N)を使用するアルゴリズムがありますO(1)。
for i in [0..2^64):
if i not in list: return i
print "no 64-bit integers are missing"
数値はすべて64ビット長であるため、基数ソートを使用できます。これはO（n）です。'emを並べ替えてから、探しているものが見つかるまで' emをスキャンします。
最小数がゼロの場合は、ギャップが見つかるまで前方にスキャンします。最小数がゼロでない場合、答えはゼロです。
スペース効率の高い方法で、すべての値が異なる場合は、スペースO( k )と時間でそれを行うことができますO( k*log(N)*N )。スペース効率が高く、データの移動がなく、すべての操作が基本的です（加算と減算）。
U = N; L=0kリージョンに分割します。このような：
0->(1/k)*(U-L) + L、0->(2/k)*(U-L) + L、0->(3/k)*(U-L) + L...0->(U-L) + Lcount{i}各地域にいくつの数字（）があるかを調べます。（N*kステップ）hいっぱいではない最初の領域（）を見つけます。つまり、count{h} < upper_limit{h}。（kステップ）h - count{h-1} = 1あなたがあなたの答えを持っているならU = count{h}; L = count{h-1}これはハッシュを使用して改善できます（Nicのこのアイデアに感謝します）。
kリージョンに分割します。このような：
L + (i/k)->L + (i+1/k)*(U-L)inc count{j} を使用して j = (number - L)/k (if L < number < U)hk個の要素を含まない最初の領域（）を見つけるcount{h} = 1hがあなたの答えならU = maximum value in region h L = minimum value in region hこれはで実行されO(log(N)*N)ます。
U-L < k
それらを並べ替えてから、ギャップ（ゼロと最初の数値の間の最初のギャップを含む）が見つかるまでシーケンスを実行します。
アルゴリズムに関しては、次のようなものがそれを行います。
def smallest_not_in_list(list):
sort(list)
if list[0] != 0:
return 0
for i = 1 to list.last:
if list[i] != list[i-1] + 1:
return list[i-1] + 1
if list[list.last] == 2^64 - 1:
assert ("No gaps")
return list[list.last] + 1
もちろん、CPUのうなり声よりもはるかに多くのメモリがある場合は、可能なすべての64ビット値のビットマスクを作成し、リスト内のすべての数値のビットを設定することができます。次に、そのビットマスクで最初の0ビットを探します。それは時間の点ではO（n）演算になりますが、メモリ要件の点ではかなり高価です:-)
O（n）を改善できるとは思えません。なぜなら、各数値を少なくとも1回は確認しない方法がわからないからです。
そのためのアルゴリズムは、次の線に沿っています。
def smallest_not_in_list(list):
bitmask = mask_make(2^64) // might take a while :-)
mask_clear_all (bitmask)
for i = 1 to list.last:
mask_set (bitmask, list[i])
for i = 0 to 2^64 - 1:
if mask_is_clear (bitmask, i):
return i
assert ("No gaps")
隠れた要素はかなり大きいですが、O（n）時間とO（1）追加スペースでそれを行うことができます。これは問題を解決するための実用的な方法ではありませんが、それでも興味深いかもしれません。
符号なし64ビット整数（昇順）ごとに、ターゲット整数が見つかるか、リストの最後に到達するまで、リストを繰り返し処理します。リストの最後に到達した場合、ターゲット整数はリストにない最小の整数です。64ビット整数の終わりに達すると、すべての64ビット整数がリストに含まれます。
これはPython関数としてのものです：
def smallest_missing_uint64(source_list):
the_answer = None
target = 0L
while target < 2L**64:
target_found = False
for item in source_list:
if item == target:
target_found = True
if not target_found and the_answer is None:
the_answer = target
target += 1L
return the_answer
この関数は、O（n）を維持するために意図的に非効率的です。特に、答えが見つかった後でも、関数はターゲット整数をチェックし続けることに注意してください。回答が見つかるとすぐに関数が返される場合、外側のループが実行された回数は、回答のサイズ（nによって制限される）によって制限されます。この変更により、実行時間はO（n ^ 2）になりますが、はるかに高速になります。
私のインスピレーションを与えてくれたegon、swilden、StephenCに感謝します。まず、リストのサイズを超えることはできないため、目標値の範囲がわかります。また、1GBのリストには、最大で134217728（128 * 2 ^ 20）の64ビット整数を含めることができます。
ハッシュ部分
ハッシュを使用して検索スペースを大幅に削減することを提案します。まず、リストのサイズの平方根。1GBのリストの場合、N = 11,586です。サイズNの整数配列を設定します。リストを反復処理し、見つかった各数値の平方根*をハッシュとして使用します。ハッシュテーブルで、そのハッシュのカウンターをインクリメントします。次に、ハッシュテーブルを繰り返し処理します。最大サイズと等しくない最初のバケットは、新しい検索スペースを定義します。
ビットマップ部分次
に、新しい検索スペースのサイズに等しい通常のビットマップを設定し、ソースリストを繰り返し処理して、検索スペースで各番号を見つけたらビットマップに入力します。完了したら、ビットマップの最初の未設定ビットが答えを示します。
これは、O（n）時間とO（sqrt（n））空間で完了します。
（*ビットシフトなどを使用してこれをより効率的に行うことができ、それに応じてバケットの数とサイズを変更するだけです。）
番号のリストに欠落している番号が1つしかない場合、不足している番号を見つける最も簡単な方法は、シリーズを合計し、リスト内の各値を減算することです。最終的な値は欠落している数です。
int i = 0;
while ( i < Array.Length)
{
if (Array[i] == i + 1)
{
i++;
}
if (i < Array.Length)
{
if (Array[i] <= Array.Length)
{//SWap
int temp = Array[i];
int AnoTemp = Array[temp - 1];
Array[temp - 1] = temp;
Array[i] = AnoTemp;
}
else
i++;
}
}
for (int j = 0; j < Array.Length; j++)
{
if (Array[j] > Array.Length)
{
Console.WriteLine(j + 1);
j = Array.Length;
}
else
if (j == Array.Length - 1)
Console.WriteLine("Not Found !!");
}
}
ハッシュテーブルを使用して数値を保持できます。すべての数値が完了したら、最小値が見つかるまで0からカウンターを実行します。適度に優れたハッシュは、一定時間でハッシュおよび保存され、一定時間で取得されます。
for every i in X // One scan Θ(1)
hashtable.put(i, i); // O(1)
low = 0;
while (hashtable.get(i) <> null) // at most n+1 times
low++;
print low;
n配列に要素があり、がである場合の最悪のケース。{0, 1, ... n-1}その場合、答えはで取得されn、それを維持しO(n)ます。
これがJavaで書かれた私の答えです：
基本的な考え方：1-配列をループして、重複する正、ゼロ、および負の数を破棄し、残りを合計して、最大の正の数も取得し、一意の正の数をマップに保持します。
2-合計をmax *（max + 1）/ 2として計算します。
3-ステップ1と2で計算された合計の差を見つけます
4- 1から[合計差、最大]まで再度ループし、手順1で入力したマップにない最初の数値を返します。
public static int solution(int[] A) {
if (A == null || A.length == 0) {
throw new IllegalArgumentException();
}
int sum = 0;
Map<Integer, Boolean> uniqueNumbers = new HashMap<Integer, Boolean>();
int max = A[0];
for (int i = 0; i < A.length; i++) {
if(A[i] < 0) {
continue;
}
if(uniqueNumbers.get(A[i]) != null) {
continue;
}
if (A[i] > max) {
max = A[i];
}
uniqueNumbers.put(A[i], true);
sum += A[i];
}
int completeSum = (max * (max + 1)) / 2;
for(int j = 1; j <= Math.min((completeSum - sum), max); j++) {
if(uniqueNumbers.get(j) == null) { //O(1)
return j;
}
}
//All negative case
if(uniqueNumbers.isEmpty()) {
return 1;
}
return 0;
}
Stephen Cが賢く指摘したように、答えは配列の長さよりも小さい数でなければなりません。次に、二分探索で答えを見つけます。これにより、最悪のケースが最適化されます（したがって、インタビュアーは「もしも」の病理学的シナリオであなたを捕まえることができません）。面接では、最悪の場合に最適化するためにこれを行っていることを指摘してください。
二分探索を使用する方法は、配列の各要素から探している数を減算し、否定的な結果をチェックすることです。
質問があったかどうかわかりません。しかし、リスト1、2、3、5、6で、欠落している番号が4の場合、欠落している番号はO（n）で次のように見つけることができます：（n + 2）（n + 1）/ 2-（n + 1）n / 2
編集：申し訳ありませんが、私は昨夜あまりにも速く考えていたと思います。とにかく、2番目の部分は実際にはsum（list）に置き換える必要があります。これは、O（n）が来る場所です。この式は、その背後にある考え方を明らかにしています。n個の連続する整数の場合、合計は（n + 1）* n / 2でなければなりません。欠落している数がある場合、合計は（n + 1）個の連続する整数の合計から欠落している数を引いたものに等しくなります。
私が頭の中にいくつかの中間部分を置いていたという事実を指摘してくれてありがとう。
よくやったアリAasma！私は約15分間答えを考え、あなたと同じような考え方で独自に答えを思いつきました。
#define SWAP(x,y) { numerictype_t tmp = x; x = y; y = tmp; }
int minNonNegativeNotInArr (numerictype_t * a, size_t n) {
int m = n;
for (int i = 0; i < m;) {
if (a[i] >= m || a[i] < i || a[i] == a[a[i]]) {
m--;
SWAP (a[i], a[m]);
continue;
}
if (a[i] > i) {
SWAP (a[i], a[a[i]]);
continue;
}
i++;
}
return m;
}
mは、「最初のi入力について知っていることを前提として、m-1のエントリまで値について他に何も想定しない、現在の最大可能出力」を表します。
このmの値は、（a [i]、...、a [m-1]）が値（i、...、m-1）の順列である場合にのみ返されます。したがって、a [i]> = mの場合、a [i] <iの場合、またはa [i] == a [a [i]]の場合、mは間違った出力であり、少なくとも1要素下でなければならないことがわかります。したがって、mをデクリメントし、a [i]をa [m]と交換すると、再帰できます。
これが当てはまらないがa [i]> iの場合、a [i]！= a [a [i]]であることがわかっているので、a [i]をa [a [i]]と交換すると要素の数が増えることがわかります。自分の場所で。
それ以外の場合、a [i]はiと等しくなければなりません。その場合、このインデックスまでのすべての値がそれらのインデックスに等しいことを知って、iをインクリメントできます。
これが無限ループに入ることができないという証拠は、読者の練習問題として残されています。:)
Antsの回答からのDafnyフラグメントは、インプレースアルゴリズムが失敗する理由を示しています。requires前提条件は、各項目の値が配列の境界を越えてはならないことを説明しています。
method AntsAasma(A: array<int>) returns (M: int)
requires A != null && forall N :: 0 <= N < A.Length ==> 0 <= A[N] < A.Length;
modifies A;
{
// Pass 1, move every value to the position of its value
var N := A.Length;
var cursor := 0;
while (cursor < N)
{
var target := A[cursor];
while (0 <= target < N && target != A[target])
{
var new_target := A[target];
A[target] := target;
target := new_target;
}
cursor := cursor + 1;
}
// Pass 2, find first location where the index doesn't match the value
cursor := 0;
while (cursor < N)
{
if (A[cursor] != cursor)
{
return cursor;
}
cursor := cursor + 1;
}
return N;
}
forall ...句の有無にかかわらず、コードをバリデーターに貼り付けて、検証エラーを確認します。2番目のエラーは、ベリファイアがパス1ループの終了条件を確立できない結果です。これを証明するのは、ツールをよりよく理解している人に任されています。
def solution(A):
index = 0
target = []
A = [x for x in A if x >=0]
if len(A) ==0:
return 1
maxi = max(A)
if maxi <= len(A):
maxi = len(A)
target = ['X' for x in range(maxi+1)]
for number in A:
target[number]= number
count = 1
while count < maxi+1:
if target[count] == 'X':
return count
count +=1
return target[count-1] + 1
上記のソリューションで100％を取得しました。
1）負のフィルターとゼロ
2）ソート/個別
3）アレイにアクセス
複雑さ：O（N）またはO（N * log（N））
Java8を使用する
public int solution(int[] A) {
int result = 1;
boolean found = false;
A = Arrays.stream(A).filter(x -> x > 0).sorted().distinct().toArray();
//System.out.println(Arrays.toString(A));
for (int i = 0; i < A.length; i++) {
result = i + 1;
if (result != A[i]) {
found = true;
break;
}
}
if (!found && result == A.length) {
//result is larger than max element in array
result++;
}
return result;
}
unordered_setを使用してすべての正の数を格納できます。次に、1からunordered_setの長さまで反復して、発生しない最初の数を確認できます。
int firstMissingPositive(vector<int>& nums) {
unordered_set<int> fre;
// storing each positive number in a hash.
for(int i = 0; i < nums.size(); i +=1)
{
if(nums[i] > 0)
fre.insert(nums[i]);
}
int i = 1;
// Iterating from 1 to size of the set and checking
// for the occurrence of 'i'
for(auto it = fre.begin(); it != fre.end(); ++it)
{
if(fre.find(i) == fre.end())
return i;
i +=1;
}
return i;
}
Pythonの場合、これは最も効率的ではありませんが、正しいです
#!/usr/bin/env python3
# -*- coding: UTF-8 -*-
import datetime
# write your code in Python 3.6
def solution(A):
MIN = 0
MAX = 1000000
possible_results = range(MIN, MAX)
for i in possible_results:
next_value = (i + 1)
if next_value not in A:
return next_value
return 1
test_case_0 = [2, 2, 2]
test_case_1 = [1, 3, 44, 55, 6, 0, 3, 8]
test_case_2 = [-1, -22]
test_case_3 = [x for x in range(-10000, 10000)]
test_case_4 = [x for x in range(0, 100)] + [x for x in range(102, 200)]
test_case_5 = [4, 5, 6]
print("---")
a = datetime.datetime.now()
print(solution(test_case_0))
print(solution(test_case_1))
print(solution(test_case_2))
print(solution(test_case_3))
print(solution(test_case_4))
print(solution(test_case_5))
これは役に立ちます：
0- A is [5, 3, 2, 7];
1- Define B With Length = A.Length; (O(1))
2- initialize B Cells With 1; (O(n))
3- For Each Item In A:
if (B.Length <= item) then B[Item] = -1 (O(n))
4- The answer is smallest index in B such that B[index] != -1 (O(n))