이 면접 질문을 받았습니다 :

40 억 개의 정수를 가진 입력 파일이 주어지면 파일에 포함되지 않은 정수를 생성하는 알고리즘을 제공하십시오. 1GB 메모리가 있다고 가정하십시오. 10MB의 메모리 만있는 경우 수행 할 작업을 추적하십시오.

내 분석 :

파일 크기는 4 × 10 ⁹ × 4 bytes = 16GB입니다.

외부 정렬을 수행 할 수 있으므로 정수 범위를 알려줍니다.

내 질문은 정렬 된 큰 정수 세트에서 누락 된 정수를 감지하는 가장 좋은 방법은 무엇입니까?

내 이해 (모든 답변을 읽은 후) :

32 비트 정수에 대해 이야기하고 있다고 가정하면 2 ³² = 4 * 10 ⁹ 개의 고유 정수가 있습니다.

사례 1 : 1GB = 1 * 10 ⁹ * 8 비트 = 80 억 비트 메모리가 있습니다.

해결책:

하나의 고유 한 정수를 나타내는 하나의 비트를 사용하면 충분합니다. 우리는 정렬 할 필요가 없습니다.

이행:

int radix = 8;
byte[] bitfield = new byte[0xffffffff/radix];
void F() throws FileNotFoundException{
    Scanner in = new Scanner(new FileReader("a.txt"));
    while(in.hasNextInt()){
        int n = in.nextInt();
        bitfield[n/radix] |= (1 << (n%radix));
    }

    for(int i = 0; i< bitfield.lenght; i++){
        for(int j =0; j<radix; j++){
            if( (bitfield[i] & (1<<j)) == 0) System.out.print(i*radix+j);
        }
    }
}

사례 2 : 10MB 메모리 = 10 * 10 ⁶ * 8 비트 = 8 천만 비트

해결책:

가능한 모든 16 비트 접두사에 대해 2 ^{16 개의} 정수 = 65536이 있으며 2 ¹⁶ * 4 * 8 = 2 백만 비트가 필요합니다. 65536 버킷을 빌드해야합니다. 각 버킷마다 모든 가능성을 보유하는 4 바이트가 필요합니다. 최악의 경우 40 억 정수가 모두 동일한 버킷에 속하기 때문입니다.

1. 파일을 통한 첫 번째 통과를 통해 각 버킷의 카운터를 만듭니다.
2. 버킷을 스캔하고 적중률이 65536 미만인 첫 번째 버킷을 찾으십시오.
3. 2 단계에서 파일의 두 번째 패스를 통해 높은 16 비트 접두사가있는 새 버킷을 빌드하십시오.
4. 3 단계에서 빌드 한 버킷을 스캔하고 적중하지 않은 첫 번째 버킷을 찾으십시오.

코드는 위의 코드와 매우 유사합니다.

결론 : 파일 전달을 늘려 메모리를 줄입니다.

^{늦게 도착하는 사람들을위한 설명 : 질문에 따르면, 질문에 따르면 파일에 포함되지 않은 정수가 정확히 하나 있다고 말하지는 않습니다. 적어도 대부분의 사람들이 그것을 해석하는 방식이 아닙니다. 주석 스레드의 많은 의견이 있다 하지만, 작업의 변화에 대해. 불행하게도 주석 도입 이후 저자에 의해 삭제 된 코멘트 스레드에, 그래서 지금은 오해 다 그것에 고아 응답 것 같습니다. 매우 혼란 스럽습니다. 죄송합니다.}

"정수"가 32 비트를 의미한다고 가정하면, 10MB의 공간이 주어진 16 비트 접두사를 가진 입력 파일에 몇 개의 숫자가 있는지 계산하기에 충분합니다. 입력 파일. 버킷 중 하나 이상이 2 ¹⁶ 회 미만으로 적중 되었습니다. 해당 버킷에서 사용 가능한 숫자 중 어떤 것이 이미 사용 중인지 확인하려면 두 번째 패스를 수행하십시오.

32 비트를 초과하지만 여전히 경계 크기 인 경우 : 부호있는 또는 부호없는, 선택한 32 비트 범위를 벗어나는 모든 입력 숫자를 무시하고 위와 같이하십시오.

"정수"가 수학 정수를 의미하는 경우 : 입력을 한 번 읽고 읽은 가장 긴 숫자 의 최대 길이를 추적하십시오 . 완료되면 최대 자릿수에 숫자 하나가 더 많은 난수를 더한 값을 출력 하십시오 . (파일의 숫자 중 하나는 정확하게 나타내는 데 10MB 이상이 걸리는 큰 숫자 일 수 있지만 입력이 파일 인 경우 최소한 파일에 맞는 길이 를 나타낼 수 있습니다 ).

통계 정보 알고리즘은 결정적 접근 방식보다 적은 패스를 사용하여이 문제를 해결합니다.

매우 큰 정수가 허용되면 O (1) 시간에 고유 한 숫자를 생성 할 수 있습니다. GUID 와 같은 의사 난수 128 비트 정수는 640 억 억 건 중 1 개 미만의 집합에서 기존의 40 억 정수 중 하나와 만 충돌합니다.

정수가 32 비트로 제한되면 10MB보다 훨씬 적은 단일 패스에서 고유 한 숫자를 생성 할 수 있습니다. 의사 랜덤 32 비트 정수가 40 억 개의 기존 정수 중 하나와 충돌 할 확률은 약 93 % (4e9 / 2 ^ 32)입니다. 1000 개의 의사 난수 정수가 모두 충돌 할 확률은 1 천 2 백억 억 (1 개의 충돌 률 ^ 1000) 중 1 개 미만입니다. 따라서 프로그램이 1000 개의 의사 랜덤 후보를 포함하는 데이터 구조를 유지하고 알려진 정수를 반복하여 후보에서 일치하는 항목을 제거하는 경우 파일에없는 하나 이상의 정수를 찾는 것이 확실합니다.

이 문제에 대한 자세한 설명은 Jon Bentley "Column 1. Cracking the Oyster" Programming Pearls Addison-Wesley pp.3-10에서 논의되었습니다.

벤틀리 정렬 등 여러 외부 파일을 사용하여 외부 정렬, 병합 등 여러 가지 방법을 설명하지만 벤틀리가 제안하는 가장 좋은 방법은 사용하는 단일 패스 알고리즘 비트 필드 그는 익살 "정렬 원더"호출 :) 문제에 40 억 오는 숫자는 다음과 같이 나타낼 수 있습니다.

4 billion bits = (4000000000 / 8) bytes = about 0.466 GB

비트 셋을 구현하는 코드는 간단하다 : ( solutions page 에서 가져온 )

#define BITSPERWORD 32
#define SHIFT 5
#define MASK 0x1F
#define N 10000000
int a[1 + N/BITSPERWORD];

void set(int i) {        a[i>>SHIFT] |=  (1<<(i & MASK)); }
void clr(int i) {        a[i>>SHIFT] &= ~(1<<(i & MASK)); }
int  test(int i){ return a[i>>SHIFT] &   (1<<(i & MASK)); }

Bentley의 알고리즘은 파일에서 단일 패스를 생성하여 set배열의 해당 비트를 팅한 다음 test위의 매크로를 사용하여이 배열을 검사 하여 누락 된 숫자를 찾습니다.

사용 가능한 메모리가 0.466GB 미만인 경우 Bentley는 k-pass 알고리즘을 제안합니다.이 알고리즘은 입력을 사용 가능한 메모리에 따라 범위로 나눕니다. 아주 간단한 예를 들어, 1 바이트 (즉, 8 개의 숫자를 처리하는 메모리) 만 사용할 수 있고 범위가 0 ~ 31 인 경우이를 0 ~ 7, 8-15, 16-22 등의 범위로 나눕니다. 각 32/8 = 4패스 에서이 범위를 처리하십시오 .

HTH.

문제는 파일에없는 가장 작은 가능한 숫자를 찾아야한다고 지정하지 않기 때문에 입력 파일 자체보다 긴 숫자 만 생성 할 수 있습니다. :)

1GB RAM 변형의 경우 비트 벡터를 사용할 수 있습니다. 40 억 비트 == 500MB 바이트 배열을 할당해야합니다. 입력에서 읽은 각 숫자에 대해 해당 비트를 '1'로 설정하십시오. 완료되면 비트를 반복하여 여전히 '0'인 첫 번째 비트를 찾으십시오. 그 색인이 답입니다.

32 비트 정수인 경우 (2 ^32에 가까운 ~ 40 억 숫자 선택에서와 같이) 40 억 숫자 의 목록은 가능한 정수의 최대 93 %를 차지합니다 (4 * 10 ⁹ / (2 ³² ) ). 따라서 각 비트가 0으로 초기화 된 2 ³² 비트의 비트 배열을 만들면 (2 ²⁹ 바이트 ~ 500 MB의 RAM이 필요합니다. 바이트 = 2 ^3을 기억하십시오. 비트 = 8 비트를 하십시오) 정수 목록을 읽고 각각의 int에 대해 대응하는 비트 어레이 요소를 0 내지 1로 설정하고; 그런 다음 비트 배열을 읽고 여전히 0 인 첫 번째 비트를 반환하십시오.

RAM이 적 으면 (~ 10MB)이 솔루션을 약간 수정해야합니다. 10 MB ~ 83886080 비트는 여전히 0에서 83886079 사이의 모든 숫자에 대해 비트 배열을 수행하기에 충분합니다. 따라서 int 목록을 읽을 수 있습니다. 비트 배열에서 0에서 83886079 사이의 레코드 번호 만 기록하십시오. 숫자가 무작위로 분포 된 경우; (이 약 100 %의 차이 확률이 압도적으로 (10) ^-2592069 )를) 누락 INT를 찾을 수 있습니다. 실제로 1에서 2048까지의 숫자 (256 바이트의 RAM 만 있음) 만 선택하면 시간의 압도적 비율 (99.99999999999999999999999999999999999999999999999999999999999995 %)이 여전히 누락 된 숫자임을 알 수 있습니다.

그러나 약 40 억 개의 숫자 대신에 2 ^32-1 숫자와 10MB 미만의 RAM이 있습니다. 따라서 작은 범위의 정수는 숫자를 포함하지 않을 가능성이 적습니다.

당신이 목록의 각 INT 고유 것을 보장한다면, 당신은 숫자를 합계 한 # 전체 합계 (½)에 누락 된 합을 빼기 수 (2 ³² ) (2 ³² - 1)의 누락 INT를 찾을 수 = 9223372034707292160 . 그러나 int가 두 번 발생하면이 방법은 실패합니다.

그러나 항상 나누고 정복 할 수 있습니다. 순진한 방법은 배열을 읽고 전반 (0 ~ 2 ^31-1 )과 후반 (2 ³¹ , 2 ³² )에 있는 숫자의 수를 세는 것 입니다. 그런 다음 더 적은 수의 범위를 선택하고 해당 범위를 반으로 나누십시오. (말 (2 적은 수의 두이 있다면 ⁽³¹⁾ , 2 ⁽³²⁾ ) 다음, 다음 검색은 범위의 숫자 (2 카운트 것 ⁽³¹⁾ , 3 * 2 ³⁰ -1), (3 * 2 ⁽³⁰⁾ , 2 ⁽³²⁾ ). 계속 숫자가 0 인 범위를 찾을 때까지 반복하고 답을 얻으십시오. 배열을 통해 O (lg N) ~ 32 읽기를 가져와야합니다.

그 방법은 비효율적이었습니다. 각 단계에서 2 개의 정수만 사용하거나 4 바이트 (32 비트) 정수를 갖는 약 8 바이트의 RAM을 사용합니다. 더 나은 방법은 sqrt (2 ³² ) = 2 ¹⁶ = 65536 bin 으로 나누는 것입니다 . 각 bin에는 65536 개의 숫자가 있습니다. 각 저장소에는 카운트를 저장하는 데 4 바이트가 필요하므로 2 ¹⁸ 바이트 = 256kB 가 필요합니다 . 빈 0이되어, (0 (2) = 65535 ⁽¹⁶⁾ -1), 빈 1 (2, ¹⁶ = 65536 (2) * 2 ⁽¹⁶⁾ , 빈 (2) -1 = 131,071) (2 * 2 ¹⁶ = 131072 3 2 * ¹⁶ - 1 = 196607). 파이썬에서는 다음과 같은 것이 있습니다.

import numpy as np
nums_in_bin = np.zeros(65536, dtype=np.uint32)
for N in four_billion_int_array:
    nums_in_bin[N // 65536] += 1
for bin_num, bin_count in enumerate(nums_in_bin):
    if bin_count < 65536:
        break # we have found an incomplete bin with missing ints (bin_num)

~ 40 억 개의 정수 목록을 읽습니다. 2 ^{개의 16 개} 빈 각각에 몇 개의 정수가 있는지 계산 하고 65536 개의 숫자가 모두없는 incomplete_bin을 찾으십시오. 그런 다음 40 억 개의 정수 목록을 다시 읽습니다. 그러나 이번에는 정수가 그 범위에있을 때만 주목할 것입니다. 당신이 그들을 찾을 때 조금 뒤집어.

del nums_in_bin # allow gc to free old 256kB array
from bitarray import bitarray
my_bit_array = bitarray(65536) # 32 kB
my_bit_array.setall(0)
for N in four_billion_int_array:
    if N // 65536 == bin_num:
        my_bit_array[N % 65536] = 1
for i, bit in enumerate(my_bit_array):
    if not bit:
        print bin_num*65536 + i
        break

왜 그렇게 복잡하게 만드나요? 파일에없는 정수를 요청 하시겠습니까?

지정된 규칙에 따라 저장해야 할 유일한 것은 파일에서 지금까지 본 가장 큰 정수입니다. 전체 파일을 읽은 후에는 1보다 큰 숫자를 리턴하십시오.

규칙에 따라 정수의 크기 또는 알고리즘이 반환하는 숫자에 대한 제한이 없으므로 maxint 또는 기타를 칠 위험이 없습니다.

이진 검색의 변형을 사용하여 매우 적은 공간에서 해결할 수 있습니다.

1. 숫자의 허용 범위를 시작 0으로 4294967295.

2. 중간 점을 계산하십시오.

3. 중간 점 값보다 작거나 같은 숫자의 수를 세면서 파일을 반복합니다.

4. 같은 숫자가 없으면 완료된 것입니다. 중간 점 번호가 답입니다.

5. 그렇지 않으면 숫자가 가장 적은 범위를 선택하고이 새로운 범위로 2 단계부터 반복하십시오.

파일을 통해 최대 32 개의 선형 스캔이 필요하지만 범위와 카운트를 저장하는 데 몇 바이트의 메모리 만 사용합니다.

이것은 16k 대신 2 개의 빈을 사용한다는 점을 제외하면 본질적으로 Henning의 솔루션 과 동일합니다.

편집 좋아, 이것은 파일의 정수가 정적 분포를 따르는 것으로 가정하기 때문에 생각하지 않았습니다. 분명히 그들은 필요하지 않지만 심지어는 이것을 시도해야합니다.

32 억 개의 32 비트 정수가 있습니다. 파일에 어떻게 분포되어 있는지는 모르지만 최악의 경우는 Shannon 엔트로피가 가장 높은 경우입니다. 이 경우 파일에서 하나의 정수가 발생하지 않을 확률은 다음과 같습니다.

((2³²-1) / 2³²) ⁴ ⁰⁰⁰ ⁰⁰⁰ ⁰⁰⁰ ≈ .4

Shannon 엔트로피가 낮을수록이 확률은 평균적으로 높아지지만, 최악의 경우에도 임의의 정수로 5 번 추측 한 후 90 %의 확률이 발생합니다. 의사 난수 생성기를 사용하여 이러한 숫자를 만들고 목록에 저장하십시오. 그런 다음 int 다음에 int를 읽고 모든 추측과 비교하십시오. 일치하는 항목이 있으면이 목록 항목을 제거하십시오. 모든 파일을 다 읽은 후에는 둘 이상의 추측이 남을 가능성이 있습니다. 그들 중 하나를 사용하십시오. 추측 할 수없는 드문 (최악의 경우에도 10 %) 이벤트에서 새로운 임의의 정수 세트를 얻습니다.

메모리 소비 : 수십 바이트, 복잡성 : O (n), 오버 헤드 : 대부분의 시간은 어쨌든 정수를 비교하지 않고 피할 수없는 하드 디스크 액세스에 소비되므로 무시할 수 있습니다.

[0, 2 ^ x -1] 범위에서 누락 된 하나의 정수가 있으면 모두 함께 xor하십시오. 예를 들면 다음과 같습니다.

>>> 0 ^ 1 ^ 3
2
>>> 0 ^ 1 ^ 2 ^ 3 ^ 4 ^ 6 ^ 7
5

(이것이 질문에 정확하게 대답하지는 않지만 매우 유사한 질문에 대한 좋은 대답입니다.)

그들은 값이 큰 세트의 일부가 아닌지를 절대적으로 효율적으로 결정할 수 있는 확률 블룸 필터에 대해 들어 보았을 지 모릅니다 (그러나 확률이 높은 세트의 멤버인지 결정할 수 있습니다).

원래 질문의 현재 문구를 기반으로 가장 간단한 해결책은 다음과 같습니다.

파일에서 최대 값을 찾은 다음 1을 추가하십시오.

를 사용하십시오 BitSet. 바이트 당 8로 BitSet에 압축 된 40 억 개의 정수 (최대 2 ^ 32 정수로 가정)는 2 ^ 32 / 2 ^ 3 = 2 ^ 29 = 약 0.5Gb입니다.

조금 더 자세하게 추가하려면 숫자를 읽을 때마다 BitSet에서 해당 비트를 설정하십시오. 그런 다음 BitSet을 전달하여 존재하지 않는 첫 번째 숫자를 찾으십시오. 실제로, 임의의 숫자를 반복적으로 선택하고 존재하는 경우 테스트하여이를 효과적으로 수행 할 수 있습니다.

실제로 BitSet.nextClearBit (0)은 설정되지 않은 첫 번째 비트를 알려줍니다.

BitSet API를 살펴보면 0..MAX_INT 만 지원하는 것으로 보이므로 + 've 숫자와 -'ve 숫자 각각에 대해 하나씩 2 개의 BitSet이 필요할 수 있지만 메모리 요구 사항은 변경되지 않습니다.

크기 제한이없는 경우 가장 빠른 방법은 파일 길이를 가져 와서 파일 길이 + 1의 임의의 자릿수 (또는 "11111 ..."s)를 생성하는 것입니다. 장점 : 파일을 읽을 필요가 없으며 메모리 사용을 거의 0으로 최소화 할 수 있습니다. 단점 : 수십억 자리를 인쇄합니다.

그러나 유일한 요소가 메모리 사용을 최소화하고 다른 중요한 것은 없다면 이것이 최적의 솔루션입니다. 심지어 "가장 최악의 규칙 남용"상을받을 수도 있습니다.

우리가 숫자의 범위가 항상 2 ^ n (2의 거듭 제곱)이라고 가정하면 배타적 또는 작동합니다 (다른 포스터에서 볼 수 있듯이). 이유까지는 증명해 보자.

이론

다음과 같은 0 기반 정수 범위가 주어집니다. 2^n하나의 요소가 누락 된 요소가 , 알려진 값을 xor-ing하여 누락 된 숫자를 산출하여 해당 요소를 찾을 수 있습니다.

증거

n = 2를 봅시다. n = 2의 경우, 4, 0, 1, 2, 3의 고유 한 정수를 나타낼 수 있습니다. 비트 패턴은 다음과 같습니다.

• 0-00
• 1-01
• 2-10
• 3 ~ 11

이제 살펴보면 각각의 비트가 정확히 두 번 설정됩니다. 따라서 짝수 번 설정되고 배타적 또는 숫자의 숫자는 0이됩니다. 하나의 숫자가 누락되면 배타적 숫자는 배타적 숫자가없는 배타적 숫자의 결과입니다. 따라서 누락 된 숫자와 결과 배타적 정렬 숫자는 정확히 같습니다. 2를 제거하면 결과 xor는10 (또는 2)가됩니다.

이제 n + 1을 봅시다. 하자의 각 비트에 설정 한 횟수 전화 n, x각 비트가 설정 횟수를 n+1 y. 의 값은 y동일 할 것이다 y = x * 2있기 때문에 x와 요소 n+10 비트 세트 및 x와 소자 n+1(1)에 비트를 설정하고 이후 2x항상 짝수가 될 것이며, n+1항상 각 비트 횟수로 설정 한 것이다.

따라서 n=2작동하고 n+1작동하므로 xor 메소드는의 모든 값에 대해 작동합니다 n>=2.

0 기반 범위의 알고리즘

이것은 매우 간단합니다. 2 * n 비트의 메모리를 사용하므로 <= 32 범위의 경우 2 32 비트 정수가 작동합니다 (파일 설명자가 소비하는 모든 메모리는 무시). 그리고 파일의 단일 패스를 만듭니다.

long supplied = 0;
long result = 0;
while (supplied = read_int_from_file()) {
    result = result ^ supplied;
}
return result;

임의의 범위에 대한 알고리즘

이 알고리즘은 총 범위가 2 ^ n 인 한 시작 숫자부터 끝 숫자까지의 범위에서 작동합니다. 기본적으로 범위를 0에서 최소값으로 재 지정합니다. 그러나 2 패스가 필요합니다. 파일을 통해 (첫 번째는 최소값을 잡고 두 번째는 누락 된 int를 계산합니다).

long supplied = 0;
long result = 0;
long offset = INT_MAX;
while (supplied = read_int_from_file()) {
    if (supplied < offset) {
        offset = supplied;
    }
}
reset_file_pointer();
while (supplied = read_int_from_file()) {
    result = result ^ (supplied - offset);
}
return result + offset;

임의의 범위

모든 범위가 2 ^ n의 거듭 제곱을 적어도 한 번 초과하므로이 수정 된 방법을 임의의 범위 세트에 적용 할 수 있습니다. 누락 된 단일 비트가있는 경우에만 작동합니다. 정렬되지 않은 파일은 2 패스가 필요하지만 매번 누락 된 단일 번호를 찾습니다.

long supplied = 0;
long result = 0;
long offset = INT_MAX;
long n = 0;
double temp;
while (supplied = read_int_from_file()) {
    if (supplied < offset) {
        offset = supplied;
    }
}
reset_file_pointer();
while (supplied = read_int_from_file()) {
    n++;
    result = result ^ (supplied - offset);
}
// We need to increment n one value so that we take care of the missing 
// int value
n++
while (n == 1 || 0 != (n & (n - 1))) {
    result = result ^ (n++);
}
return result + offset;

기본적으로 0을 기준으로 범위를 다시 조정합니다. 그런 다음 배타적 값을 계산할 때 추가 할 정렬되지 않은 값의 수를 셉니다. 그런 다음 정렬되지 않은 값의 수에 1을 더하여 결 측값을 처리합니다 (결 측값 계산). 그런 다음 n이 2의 거듭 제곱이 될 때까지 매번 1 씩 증가하여 n 값을 계속 xoring합니다. 결과는 원래 기준으로 다시 기반이됩니다. 끝난.

다음은 PHP에서 테스트 한 알고리즘입니다 (파일 대신 배열을 사용하지만 개념은 동일 함).

function find($array) {
    $offset = min($array);
    $n = 0;
    $result = 0;
    foreach ($array as $value) {
        $result = $result ^ ($value - $offset);
        $n++;
    }
    $n++; // This takes care of the missing value
    while ($n == 1 || 0 != ($n & ($n - 1))) {
        $result = $result ^ ($n++);
    }
    return $result + $offset;
}

누락 된 해당 범위 안에 하나가있는 모든 범위의 값 (음수 포함 테스트)이있는 배열에서 공급하면 매번 올바른 값을 찾았습니다.

또 다른 접근법

외부 정렬을 사용할 수 있으므로 차이를 확인하지 않는 이유는 무엇입니까? 이 알고리즘을 실행하기 전에 파일이 정렬되어 있다고 가정하면 :

long supplied = 0;
long last = read_int_from_file();
while (supplied = read_int_from_file()) {
    if (supplied != last + 1) {
        return last + 1;
    }
    last = supplied;
}
// The range is contiguous, so what do we do here?  Let's return last + 1:
return last + 1;

부적절하게 인용되지 않는 한 속임수 질문. 최대 정수를 얻기 위해 파일을 한 번 읽고을 n반환하십시오 n+1.

물론 n+1정수 오버플로 가 발생할 경우 백업 계획이 필요합니다 .

입력 파일의 크기를 확인한 다음 해당 파일로 표현하기에는 너무 큰 숫자 를 출력 하십시오 . 이것은 저렴한 트릭처럼 보이지만 인터뷰 문제에 대한 창의적인 해결책이며 메모리 문제를 깔끔하게 회피하며 기술적으로 O (n)입니다.

void maxNum(ulong filesize)
{
    ulong bitcount = filesize * 8; //number of bits in file

    for (ulong i = 0; i < bitcount; i++)
    {
        Console.Write(9);
    }
}

인쇄해야 10 ^bitcount 1 - 항상보다 큰 것, 2 ^bitcount을 . 기술적으로, 당신이 비트에있는 번호는 2 ^bitcount는 - (4 * 10 ⁽⁹⁾ - 1) , 당신은 (40 억 - 1)이 알고 있기 때문에 파일의 다른 정수, 심지어 완벽한 압축 그들이 적어도 걸릴거야 1 비트 씩

• 가장 간단한 방법은 파일에서 최소 숫자를 찾아 그보다 1을 적게 반환하는 것입니다. 이것은 O (1) 스토리지를 사용하고 n 숫자의 파일에 O (n) 시간을 사용합니다. 그러나 숫자 범위가 제한되어 있으면 최소 -1이 아닌 숫자가 될 수 있습니다.

• 비트 맵을 사용하는 간단하고 간단한 방법은 이미 언급되었습니다. 이 방법은 O (n) 시간과 저장 공간을 사용합니다.

• 2 ^ 16 카운팅 버킷을 가진 2- 패스 방법도 언급되었습니다. 2 * n 정수를 읽으므로 O (n) 시간과 O (1) 스토리지를 사용하지만 2 ^ 16 이상의 숫자를 가진 데이터 세트를 처리 할 수 ​​없습니다. 그러나 2 대신 4 패스를 실행하여 (예를 들어) 2 ^ 60 64 비트 정수로 쉽게 확장하고 메모리에 맞는 수의 빈 만 사용하고 이에 따라 패스 수를 늘려 작은 메모리를 사용하도록 쉽게 조정할 수 있습니다. 이 경우 런타임은 더 이상 O (n)가 아니라 대신 O (n * log n)입니다.

• rfrankel이 지금까지 언급하고 ircmaxell이 길게 언급 한 모든 숫자를 함께 XOR하는 방법은 ltn100이 지적한 것처럼 stackoverflow # 35185 에서 묻는 질문에 대답합니다 . O (1) 스토리지와 O (n) 런타임을 사용합니다. 현재 32 비트 정수를 가정하면 XOR은 7 %의 확률로 고유 한 숫자를 생성 할 수 있습니다. 이론적 근거 : ~ 4G의 고유 한 숫자가 함께 XOR되고, ca. 파일에없는 300M의 경우, 각 비트 위치의 설정 비트 수가 홀수 또는 짝수 일 가능성이 동일합니다. 따라서 2 ^ 32 숫자는 XOR 결과로 발생할 가능성이 동일하며 그 중 93 %가 이미 파일에 있습니다. 파일의 숫자가 모두 고유하지 않으면 XOR 방법의 성공 확률이 높아집니다.

어떤 이유로,이 문제를 읽 자마자 나는 대각선 화를 생각했습니다. 임의로 큰 정수를 가정합니다.

첫 번째 숫자를 읽으십시오. 40 억 비트가 될 때까지 0 비트로 왼쪽 채 웁니다. 첫 번째 (고차) 비트가 0이면 출력 1; else output 0. (실제로 왼쪽 패드를 쓸 필요는 없습니다. 숫자에 충분한 비트가 없으면 1 만 출력하십시오.) 두 번째 비트를 사용하는 것을 제외하고 두 번째 숫자와 동일하게하십시오. 이 방법으로 파일을 계속 진행하십시오. 한 번에 한 비트 씩 40 억 비트 숫자를 출력 할 것이고 그 숫자는 파일의 숫자와 같지 않을 것입니다. 증명 : 그것은 n 번째 숫자와 같았으며, 그들은 n 번째 비트에 동의하지만 건축 적으로는 아닙니다.

비트 플래그를 사용하여 정수 유무를 표시 할 수 있습니다.

전체 파일을 순회 한 후 각 비트를 스캔하여 숫자가 존재하는지 여부를 판별하십시오.

각 정수가 32 비트라고 가정하면 비트 플래그 지정이 완료되면 1GB의 RAM에 편리하게 맞습니다.

파일에서 공백과 숫자가 아닌 문자를 제거하고 1을 추가하십시오. 이제 파일에는 원본 파일에 나열되지 않은 단일 숫자가 포함됩니다.

카본 등으로 Reddit에서.

완벽을 기하기 위해 여기에 실행하는 데 오랜 시간이 걸리지 만 메모리는 거의 사용하지 않는 매우 간단한 또 ​​다른 솔루션이 있습니다.

가능한 모든 정수의 범위하자 int_min로 int_max하고, bool isNotInFile(integer)파일 (파일의 각 정수와 그 특정 정수를 비교하여) 특정 정수 거짓 다른 사람을 포함하지 않는 경우는 true를 반환하는 함수

for (integer i = int_min; i <= int_max; ++i)
{
    if (isNotInFile(i)) {
        return i;
    }
}

10MB 메모리 제한의 경우 :

1. 숫자를 이진 표현으로 변환하십시오.
2. left = 0 및 right = 1 인 이진 트리를 만듭니다.
3. 이진 표현을 사용하여 트리에 각 숫자를 삽입하십시오.
4. 숫자가 이미 삽입 된 경우 리프가 이미 생성 된 것입니다.

완료되면 요청 된 번호를 작성하기 전에 작성되지 않은 경로를 사용하십시오.

40 억 숫자 = 2 ^ 32, 즉 10MB로는 충분하지 않을 수 있습니다.

편집하다

두 개의 끝 잎이 만들어지고 공통 부모가있는 경우 최적화가 가능하며, 제거하고 부모가 솔루션이 아닌 것으로 플래그 될 수 있습니다. 이것은 가지를 줄이고 메모리의 필요성을 줄입니다.

편집 II

트리를 완전히 만들 필요는 없습니다. 숫자가 비슷한 경우에만 깊은 가지를 만들면됩니다. 우리도 가지를 자르면이 솔루션이 실제로 작동 할 수 있습니다.

1GB 버전에 답하겠습니다.

질문에 충분한 정보가 없으므로 먼저 몇 가지 가정을 설명하겠습니다.

정수는 -2,147,483,648에서 2,147,483,647 범위의 32 비트입니다.

의사 코드 :

var bitArray = new bit[4294967296];  // 0.5 GB, initialized to all 0s.

foreach (var number in file) {
    bitArray[number + 2147483648] = 1;   // Shift all numbers so they start at 0.
}

for (var i = 0; i < 4294967296; i++) {
    if (bitArray[i] == 0) {
        return i - 2147483648;
    }
}

창의적인 답변을하는 한 여기 또 다른 답변이 있습니다.

외부 정렬 프로그램을 사용하여 입력 파일을 숫자로 정렬하십시오. 이것은 필요한 메모리 양에 관계없이 작동합니다 (필요한 경우 파일 스토리지를 사용함). 정렬 된 파일을 읽고 누락 된 첫 번째 숫자를 출력하십시오.

비트 제거

한 가지 방법은 비트를 제거하는 것이지만 실제로 결과를 얻지 못할 수도 있습니다 (그렇지 않을 수도 있습니다). 슈도 코드 :

long val = 0xFFFFFFFFFFFFFFFF; // (all bits set)
foreach long fileVal in file
{
    val = val & ~fileVal;
    if (val == 0) error;
}

비트 수

비트 수를 추적하십시오. 가장 적은 양의 비트를 사용하여 값을 생성합니다. 다시 말하지만 이것은 올바른 값을 생성한다고 보장하지 않습니다.

레인지 로직

목록 순서 범위를 추적하십시오 (시작 순서로 정렬). 범위는 다음 구조로 정의됩니다.

struct Range
{
  long Start, End; // Inclusive.
}
Range startRange = new Range { Start = 0x0, End = 0xFFFFFFFFFFFFFFFF };

파일의 각 값을 살펴보고 현재 범위에서 제거하십시오. 이 방법은 메모리를 보장하지는 않지만 꽤 잘 작동합니다.

2 ^{128 * 10 18} + 1 (인 (2 ⁸ ) ^{16 * 10 18} + 1) - 오늘날위한 범용 대답 할 수 없는가? 16 EB 파일에 보유 할 수없는 숫자를 나타내며 현재 파일 시스템의 최대 파일 크기입니다.

나는 이것이 해결 된 문제라고 생각하지만 (위 참조) 질문이있을 수 있으므로 염두에 두어야 할 흥미로운 사례가 있습니다.

반복없이 정확히 4,294,967,295 (2 ^ 32-1) 32 비트 정수가 있으므로 하나만 누락되면 간단한 해결책이 있습니다.

누계를 0에서 시작하고 파일의 각 정수에 대해 32 비트 오버플로가있는 정수를 추가합니다 (실제 runningTotal = (runningTotal + nextInteger) % 4294967296). 완료되면 3229 오버플로로 누적 합계에 4294967296/2를 추가하십시오. 이것을 4294967296에서 빼면 결과는 누락 된 정수입니다.

"단 하나의 누락 된 정수"문제는 한 번의 실행과 64 비트의 RAM 만 데이터 전용으로 해결할 수 있습니다 (실행중인 총 32, 다음 정수에서 32).

Corollary : 정수 결과에 몇 비트가 필요한지 염려하지 않으면보다 일반적인 사양은 매우 간단합니다. 우리는 주어진 파일에 포함 할 수없는 충분히 큰 정수를 생성합니다. 다시 말하지만 이것은 최소한의 RAM을 차지합니다. 의사 코드를 참조하십시오.

# Grab the file size
fseek(fp, 0L, SEEK_END);
sz = ftell(fp);
# Print a '2' for every bit of the file.
for (c=0; c<sz; c++) {
  for (b=0; b<4; b++) {
    print "2";
  }
}

Ryan이 기본적으로 말했듯이 파일을 정렬 한 다음 정수를 건너 뛰고 값을 건너 뛰면 거기에 있습니다 :)

downvoters에서 편집 : OP는 파일을 정렬 할 수 있다고 말했으며 이것이 유효한 방법입니다.

32 비트 제약 조건을 가정하지 않으면 임의로 생성 된 64 비트 숫자 (또는 비관적 인 경우 128 비트)를 반환하십시오. 충돌 가능성은 1 in 2^64/(4*10^9) = 4611686018.4약 40 억분의 1입니다. 당신은 대부분의 시간에 맞을 것입니다!

(농담 ... 종류)