Mi è stata data questa domanda di intervista:

Dato un file di input con quattro miliardi di numeri interi, fornire un algoritmo per generare un numero intero non contenuto nel file. Supponiamo di avere 1 GB di memoria. Segui cosa faresti se avessi solo 10 MB di memoria.

La mia analisi:

La dimensione del file è 4 × 10 ⁹ × 4 byte = 16 GB.

Possiamo fare l'ordinamento esterno, facendoci così conoscere l'intervallo degli interi.

La mia domanda è: qual è il modo migliore per rilevare il numero intero mancante nei set di numeri interi grandi ordinati?

La mia comprensione (dopo aver letto tutte le risposte):

Supponendo che stiamo parlando di interi a 32 bit, ci sono 2 ³² = 4 * 10 ⁹ interi distinti.

Caso 1: abbiamo 1 GB = 1 * 10 ⁹ * 8 bit = 8 miliardi di memoria.

Soluzione:

Se usiamo un bit che rappresenta un intero distinto, è sufficiente. non abbiamo bisogno dell'ordinamento.

Implementazione:

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);
        }
    }
}

Caso 2: 10 MB di memoria = 10 * 10 ⁶ * 8 bit = 80 milioni di bit

Soluzione:

Per tutti i possibili prefissi a 16 bit, ci sono 2 ¹⁶ numero di numeri interi = 65536, abbiamo bisogno di 2 ¹⁶ * 4 * 8 = 2 milioni di bit. Abbiamo bisogno di costruire 65536 secchi. Per ogni bucket, abbiamo bisogno di 4 byte con tutte le possibilità perché nel caso peggiore tutti i 4 miliardi di numeri interi appartengono allo stesso bucket.

1. Costruisci il contatore di ogni bucket attraverso il primo passaggio del file.
2. Scansiona i secchi, trova il primo con meno di 65536 colpi.
3. Costruisci nuovi bucket i cui alti prefissi a 16 bit sono stati trovati nel passaggio 2 attraverso il secondo passaggio del file
4. Analizza i bucket incorporati nel passaggio 3, trova il primo bucket che non ha un successo.

Il codice è molto simile a quello sopra.

Conclusione: riduciamo la memoria aumentando il passaggio dei file.

^{Un chiarimento per chi arriva in ritardo: la domanda, come posta, non dice che esiste esattamente un numero intero che non è contenuto nel file, almeno non è così che la maggior parte delle persone lo interpreta. Molti commenti nel commento filo sono circa che la variazione del compito, però. Sfortunatamente il commento che lo ha introdotto nel thread dei commenti è stato successivamente eliminato dal suo autore, quindi ora sembra che le risposte orfane ad esso abbiano frainteso tutto. È molto confuso, scusa.}

Supponendo che "numero intero" significhi 32 bit : 10 MB di spazio sono più che sufficienti per contare quanti numeri ci sono nel file di input con un dato prefisso a 16 bit, per tutti i possibili prefissi a 16 bit in un passaggio attraverso il file di input. Almeno uno dei secchi sarà colpito meno di 2 ¹⁶ volte. Fai un secondo passaggio per scoprire quali dei possibili numeri in quel bucket sono già utilizzati.

Se significa più di 32 bit, ma comunque di dimensioni limitate : fare come sopra, ignorando tutti i numeri di input che non rientrano nell'intervallo (con o senza segno; a scelta) a 32 bit.

Se "numero intero" significa numero intero matematico : leggi una volta l'input e tieni traccia della lunghezza del numero più grande del numero più lungo che tu abbia mai visto. Al termine, emetti il massimo più uno un numero casuale che ha un'altra cifra. (Uno dei numeri nel file può essere un bignum che richiede più di 10 MB per rappresentare esattamente, ma se l'input è un file, puoi almeno rappresentare la lunghezza di tutto ciò che si adatta in esso).

Gli algoritmi statisticamente informati risolvono questo problema utilizzando meno passaggi rispetto agli approcci deterministici.

Se sono ammessi numeri interi molto grandi, è possibile generare un numero che sarà probabilmente unico nel tempo O (1). Un intero pseudo-casuale a 128 bit come un GUID si scontrerà con uno dei quattro miliardi di interi esistenti nel set in meno di uno su 64 miliardi di miliardi di casi.

Se i numeri interi sono limitati a 32 bit, è possibile generare un numero che sarà probabilmente univoco in un singolo passaggio utilizzando molto meno di 10 MB. La probabilità che un intero pseudo-casuale a 32 bit entrerà in collisione con uno dei 4 miliardi di numeri interi esistenti è di circa il 93% (4e9 / 2 ^ 32). Le probabilità che 1000 interi pseudo-casuali si scontrino tutti sono inferiori a una su 12.000 miliardi di miliardi di miliardi (probabilità di una collisione ^ 1000). Quindi, se un programma mantiene una struttura di dati contenente 1000 candidati pseudo-casuali e scorre attraverso gli interi noti, eliminando le corrispondenze dai candidati, è quasi certo di trovare almeno un numero intero che non si trova nel file.

Una discussione dettagliata su questo problema è stata discussa in Jon Bentley "Colonna 1. Cracking the Oyster" Programmazione Pearls Addison-Wesley pp.3-10

Bentley discute di diversi approcci, incluso l'ordinamento esterno, Unisci ordinamento usando diversi file esterni ecc., Ma il metodo migliore che Bentley suggerisce è un algoritmo a passaggio singolo che utilizza campi di bit , che chiama umoristicamente "Wonder Sort" :) Venendo al problema, 4 miliardi i numeri possono essere rappresentati in:

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

Il codice per implementare il bitset è semplice: (preso dalla pagina delle soluzioni )

#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)); }

L'algoritmo di Bentley esegue un singolo passaggio sul file, setinserendo il bit appropriato nell'array e quindi esamina questo array utilizzando la testmacro sopra per trovare il numero mancante.

Se la memoria disponibile è inferiore a 0,466 GB, Bentley suggerisce un algoritmo k-pass, che divide l'input in intervalli a seconda della memoria disponibile. Per fare un esempio molto semplice, se fosse disponibile solo 1 byte (ovvero memoria per gestire 8 numeri) e l'intervallo fosse compreso tra 0 e 31, lo dividiamo in intervalli da 0 a 7, 8-15, 16-22 e così via e gestire questo intervallo in ciascuno dei 32/8 = 4passaggi.

HTH.

Poiché il problema non specifica che dobbiamo trovare il numero più piccolo possibile che non si trova nel file, potremmo semplicemente generare un numero più lungo del file di input stesso. :)

Per la variante da 1 GB RAM è possibile utilizzare un bit vettore. È necessario allocare 4 miliardi di bit == 500 MB di array di byte. Per ogni numero letto dall'ingresso, impostare il bit corrispondente su "1". Una volta fatto, scorrere i bit, trovare il primo che è ancora '0'. Il suo indice è la risposta.

Se sono numeri interi a 32 bit (probabilmente dalla scelta di ~ 4 miliardi di numeri vicini a 2 ³² ), l'elenco di 4 miliardi di numeri occuperà al massimo il 93% dei possibili numeri interi (4 * 10 ⁹ / (2 ³² ) ). Quindi, se crei un array di bit di 2 ³² bit con ogni bit inizializzato su zero (che occuperà 2 ²⁹ byte ~ 500 MB di RAM; ricorda un byte = 2 ³ bit = 8 bit), leggi l'elenco di numeri interi e per ogni int impostare l'elemento bit-array corrispondente da 0 a 1; e poi leggi il tuo bit-array e restituisci il primo bit che è ancora 0.

Nel caso in cui si disponga di meno RAM (~ 10 MB), questa soluzione deve essere leggermente modificata. 10 MB ~ 83886080 bit sono ancora sufficienti per eseguire un array di bit per tutti i numeri compresi tra 0 e 83886079. In questo modo è possibile leggere l'elenco di ints; e registra solo # tra 0 e 83886079 nel tuo array di bit. Se i numeri sono distribuiti casualmente; con una probabilità schiacciante (differisce del 100% da circa 10 ^-2592069 ) troverai un int mancante). Infatti, se scegli solo i numeri da 1 a 2048 (con solo 256 byte di RAM) troverai comunque un numero mancante in una percentuale schiacciante (99.99999999999999999999999999999999999999999999999999999999999999999595%) del tempo.

Ma diciamo invece di avere circa 4 miliardi di numeri; avevi qualcosa come 2 ³² - 1 numeri e meno di 10 MB di RAM; quindi ogni piccolo intervallo di ints ha solo una piccola possibilità di non contenere il numero.

Se ti fosse garantito che ogni int nell'elenco è univoco, puoi sommare i numeri e sottrarre la somma con un # mancante alla somma completa (½) (2 ³² ) (2 ³² - 1) = 9223372034707292160 per trovare l'int mancante . Tuttavia, se un int si è verificato due volte, questo metodo fallirà.

Tuttavia, puoi sempre dividere e conquistare. Un metodo ingenuo sarebbe leggere l'array e contare il numero di numeri presenti nella prima metà (da 0 a 2 ³¹ -1) e nella seconda metà (2 ³¹ , 2 ³² ). Quindi seleziona l'intervallo con meno numeri e ripeti dividendo l'intervallo a metà. (Di 'se ci fossero due numeri in meno in (2 ³¹ , 2 ³² ), la tua prossima ricerca avrebbe conteggiato i numeri nell'intervallo (2 ³¹ , 3 * 2 ³⁰ -1), (3 * 2 ³⁰ , 2 ³² ). ripetendo fino a quando non trovi un intervallo con zero numeri e hai la risposta. Dovresti prendere O (lg N) ~ 32 letture attraverso l'array.

Quel metodo era inefficiente. Stiamo usando solo due numeri interi in ogni passaggio (o circa 8 byte di RAM con un numero intero di 4 byte (32 bit)). Un metodo migliore sarebbe quello di dividere in sqrt (2 ³² ) = 2 ¹⁶ = 65536 bin, ciascuno con 65536 numeri in un cestino. Ogni bin richiede 4 byte per memorizzare il suo conteggio, quindi sono necessari 2 ¹⁸ byte = 256 kB. Quindi il contenitore 0 è (da 0 a 65535 = 2 ¹⁶ -1), il contenitore 1 è (2 ¹⁶ = da 65536 a 2 * 2 ¹⁶ -1 = 131071), il contenitore 2 è (2 * 2 ¹⁶ = da 131072 a 3 * 2 ¹⁶ - 1 = 196607). In Python avresti qualcosa del tipo:

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)

Leggi l'elenco di ~ 4 miliardi di numeri interi; e conta quanti ints cadono in ciascuno dei 2 ¹⁶ bin e trova un incomplete_bin che non ha tutti i 65536 numeri. Quindi leggi di nuovo l'elenco di 4 miliardi di numeri interi; ma questa volta notate solo quando gli interi sono in quell'intervallo; capovolgendoli quando li trovi.

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

Perché renderlo così complicato? Richiedi un numero intero non presente nel file?

Secondo le regole specificate, l'unica cosa che devi archiviare è il numero intero più grande che hai incontrato finora nel file. Dopo aver letto l'intero file, restituire un numero 1 maggiore di quello.

Non vi è alcun rischio di colpire maxint o altro, perché secondo le regole, non vi è alcuna restrizione alla dimensione dell'intero o al numero restituito dall'algoritmo.

Questo può essere risolto in pochissimo spazio usando una variante della ricerca binaria.

1. Inizia con l'intervallo di numeri consentito 0a 4294967295.

2. Calcola il punto medio.

3. Scorrere il file, contando quanti numeri erano uguali, inferiori o superiori al valore del punto medio.

4. Se nessun numero era uguale, il gioco è fatto. Il numero del punto medio è la risposta.

5. Altrimenti, scegli l'intervallo con il minor numero di numeri e ripeti dal passaggio 2 con questo nuovo intervallo.

Ciò richiederà fino a 32 scansioni lineari attraverso il file, ma utilizzerà solo pochi byte di memoria per memorizzare l'intervallo e i conteggi.

Questo è essenzialmente lo stesso della soluzione di Henning , tranne per il fatto che utilizza due contenitori anziché 16k.

EDIT Ok, questo non è stato del tutto considerato in quanto presuppone che gli interi nel file seguano una distribuzione statica. Apparentemente non è necessario, ma anche allora si dovrebbe provare questo:

Esistono billion4,3 miliardi di numeri interi a 32 bit. Non sappiamo come siano distribuiti nel file, ma il caso peggiore è quello con la più alta entropia di Shannon: una distribuzione equa. In questo caso, è probabile che non si verifichi un numero intero nel file

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

Più bassa è l'entropia di Shannon, maggiore è questa probabilità mediamente, ma anche nel caso peggiore abbiamo una probabilità del 90% di trovare un numero non ricorrente dopo 5 ipotesi con numeri interi casuali. Basta creare tali numeri con un generatore pseudocasuale, memorizzarli in un elenco. Quindi leggi int dopo int e confrontalo con tutte le tue ipotesi. In caso di corrispondenza, rimuovere questa voce dell'elenco. Dopo aver esaminato tutto il file, è probabile che rimarrà più di un'ipotesi. Usa uno di loro. Nel raro (10% anche nel peggiore dei casi) caso in cui non si indovina, ottenere un nuovo set di numeri interi casuali, forse più questa volta (10-> 99%).

Consumo di memoria: poche decine di byte, complessità: O (n), sovraccarico: nimibile poiché la maggior parte del tempo sarà speso negli inevitabili accessi al disco rigido piuttosto che confrontare ints comunque.

Se manca un numero intero compreso nell'intervallo [0, 2 ^ x - 1], quindi semplicemente Xor tutti insieme. Per esempio:

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

(So ​​che questo non risponde esattamente alla domanda , ma è una buona risposta a una domanda molto simile.)

Potrebbero cercare di vedere se hai sentito parlare di un filtro Bloom probabilistico che può determinare in modo molto efficiente assolutamente se un valore non fa parte di un set di grandi dimensioni (ma può determinare solo con alta probabilità che è un membro dell'insieme.)

Sulla base dell'attuale formulazione della domanda originale, la soluzione più semplice è:

Trova il valore massimo nel file, quindi aggiungi 1 ad esso.

Usa a BitSet. 4 miliardi di numeri interi (assumendo fino a 2 ^ 32 numeri interi) impacchettati in un BitSet a 8 per byte è 2 ^ 32/2 ^ 3 = 2 ^ 29 = circa 0,5 Gb.

Per aggiungere un po 'più di dettaglio - ogni volta che leggi un numero, imposta il bit corrispondente nel BitSet. Quindi, fai un passaggio sul BitSet per trovare il primo numero che non è presente. In effetti, potresti farlo altrettanto efficacemente scegliendo ripetutamente un numero casuale e testando se è presente.

In realtà BitSet.nextClearBit (0) ti dirà il primo bit non impostato.

Guardando l'API BitSet, sembra supportare solo 0..MAX_INT, quindi potresti aver bisogno di 2 BitSet - uno per + 've numeri e uno per-have numeri - ma i requisiti di memoria non cambiano.

Se non esiste un limite di dimensioni, il modo più rapido è quello di prendere la lunghezza del file e generare la lunghezza del file + 1 numero di cifre casuali (o solo "11111 ..."). Vantaggio: non è nemmeno necessario leggere il file e è possibile ridurre al minimo l'utilizzo della memoria quasi a zero. Svantaggio: verranno stampati miliardi di cifre.

Tuttavia, se l'unico fattore fosse ridurre al minimo l'utilizzo della memoria, e nient'altro è importante, questa sarebbe la soluzione ottimale. Potrebbe anche farti ottenere il premio "peggior abuso delle regole".

Se assumiamo che l'intervallo di numeri sarà sempre 2 ^ n (una potenza pari a 2), allora esclusivo o funzionerà (come mostrato da un altro poster). Per quanto riguarda il perché, dimostriamolo:

La teoria

Dato qualsiasi intervallo di numeri interi basato su 0 che ha 2^nelementi con un elemento mancante, puoi trovare quell'elemento mancante semplicemente xorando i valori noti insieme per produrre il numero mancante.

La prova

Diamo un'occhiata a n = 2. Per n = 2, possiamo rappresentare 4 numeri interi univoci: 0, 1, 2, 3. Hanno un modello di bit di:

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

Ora, se guardiamo, ogni singolo bit è impostato esattamente due volte. Pertanto, poiché è impostato un numero pari di volte e l'esclusiva o dei numeri produrrà 0. Se manca un singolo numero, l'esclusiva o produrrà un numero che, se eseguito in esclusiva con il numero mancante, comporterà 0. Pertanto, il numero mancante e il numero risultante in ordine esclusivo sono esattamente gli stessi. Se rimuoviamo 2, lo xor risultante sarà 10(o 2).

Ora diamo un'occhiata a n + 1. Chiamiamo il numero di volte in cui ogni bit occupa n, xe il numero di volte in cui ogni bit è impostato in n+1 y. Il valore di ysarà uguale a y = x * 2perché ci sono xelementi con il n+1bit impostato su 0 e xelementi con il n+1bit impostato su 1. E poiché 2xsarà sempre pari, n+1ogni bit verrà sempre impostato un numero pari di volte.

Pertanto, poiché n=2funziona e n+1funziona, il metodo xor funzionerà per tutti i valori di n>=2.

L'algoritmo per 0 intervalli basati

Questo è abbastanza semplice Utilizza 2 * n bit di memoria, quindi per qualsiasi intervallo <= 32, 2 interi a 32 bit funzioneranno (ignorando qualsiasi memoria consumata dal descrittore di file). E fa un singolo passaggio del file.

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

L'algoritmo per gli intervalli arbitrari

Questo algoritmo funzionerà per intervalli di qualsiasi numero iniziale a qualsiasi numero finale, a condizione che l'intervallo totale sia uguale a 2 ^ n ... Questo fondamentalmente ridisegna l'intervallo per avere il minimo a 0. Ma richiede 2 passaggi attraverso il file (il primo a prendere il minimo, il secondo a calcolare l'int mancante).

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;

Arbitrary Ranges

Possiamo applicare questo metodo modificato a un insieme di intervalli arbitrari, poiché tutti gli intervalli attraverseranno una potenza di 2 ^ n almeno una volta. Funziona solo se c'è un singolo bit mancante. Richiede 2 passaggi di un file non ordinato, ma troverà ogni volta il singolo numero mancante:

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;

Fondamentalmente, ricondiziona l'intervallo intorno a 0. Quindi, conta il numero di valori non ordinati da aggiungere mentre calcola l'esclusivo o. Quindi, aggiunge 1 al conteggio dei valori non ordinati per occuparsi del valore mancante (contare quello mancante). Quindi, mantenere il valore di xoring del valore n, incrementato di 1 ogni volta fino a quando n è una potenza di 2. Il risultato viene quindi ricondizionato alla base originale. Fatto.

Ecco l'algoritmo che ho testato in PHP (usando un array anziché un file, ma lo stesso concetto):

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;
}

Alimentato in un array con qualsiasi intervallo di valori (ho testato inclusi i negativi) con uno all'interno di quell'intervallo mancante, ha trovato il valore corretto ogni volta.

Un altro approccio

Dal momento che possiamo utilizzare l'ordinamento esterno, perché non controllare solo un gap? Se assumiamo che il file sia ordinato prima dell'esecuzione di questo algoritmo:

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;

Domanda ingannevole, a meno che non sia stato citato in modo improprio. Basta leggere il file una volta per ottenere il numero intero massimo ne tornare n+1.

Naturalmente avresti bisogno di un piano di backup nel caso in cui si verifichi n+1un overflow di numeri interi.

Controlla la dimensione del file di input, quindi emetti un numero troppo grande per essere rappresentato da un file di quelle dimensioni. Questo può sembrare un trucco economico, ma è una soluzione creativa a un problema di intervista, elimina chiaramente il problema di memoria ed è tecnicamente 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);
    }
}

Dovrebbe stampare 10 ^bitcount - 1 , che sarà sempre maggiore di 2 ^bitcount . Tecnicamente, il numero che devi battere è 2 ^bitcount - (4 * 10 ⁹ - 1) , poiché sai che ci sono (4 miliardi - 1) altri numeri interi nel file e anche con una compressione perfetta occuperanno almeno un po 'ciascuno.

• L'approccio più semplice è trovare il numero minimo nel file e restituire 1 in meno. Questo utilizza la memoria O (1) e il tempo O (n) per un file di n numeri. Tuttavia, fallirà se l'intervallo di numeri è limitato, il che potrebbe rendere min-1 non un numero.

• Il metodo semplice e diretto di utilizzare una bitmap è già stato menzionato. Quel metodo usa O (n) tempo e memoria.

• È stato anche menzionato un metodo a 2 passaggi con 2 ^ 16 bucket di conteggio. Legge numeri interi 2 * n, quindi utilizza O (n) time e O (1) storage, ma non può gestire set di dati con più di 2 ^ 16 numeri. Tuttavia, è facilmente esteso a (ad esempio) 2 ^ 60 numeri interi a 64 bit eseguendo 4 passaggi anziché 2, e facilmente adattato all'utilizzo della memoria minuscola utilizzando solo il numero di bin che si adatta alla memoria e aumentando il numero di passaggi corrispondentemente, in in questo caso il tempo di esecuzione non è più O (n) ma è invece O (n * log n).

• Il metodo di XOR di riunire tutti i numeri, menzionato finora da rfrankel e infine da ircmaxell, risponde alla domanda posta nello stackoverflow n. 35185 , come ha sottolineato ltn100. Utilizza la memoria O (1) e il tempo di esecuzione O (n). Se per il momento ipotizziamo numeri interi a 32 bit, XOR ha una probabilità del 7% di produrre un numero distinto. Razionale: dati ~ 4G numeri distinti XOR'd insieme e ca. 300M non nel file, il numero di bit impostati in ogni posizione di bit ha pari probabilità di essere pari o dispari. Pertanto, 2 ^ 32 numeri hanno la stessa probabilità di sorgere come risultato XOR, di cui il 93% è già in archivio. Si noti che se i numeri nel file non sono tutti distinti, la probabilità di successo del metodo XOR aumenta.

Per qualche motivo, non appena ho letto questo problema ho pensato alla diagonalizzazione. Presumo numeri interi arbitrariamente grandi.

Leggi il primo numero Sinistra pad con zero bit fino a quando non si dispone di 4 miliardi di bit. Se il primo bit (di ordine superiore) è 0, uscita 1; else output 0. (In realtà non è necessario il pad sinistro: si genera semplicemente un 1 se non ci sono abbastanza bit nel numero.) Fare lo stesso con il secondo numero, tranne usare il secondo bit. Continua attraverso il file in questo modo. Verrà emesso un numero di 4 miliardi di bit un bit alla volta e quel numero non sarà uguale a nessun altro nel file. Prova: era lo stesso dell'ennesimo numero, quindi sarebbero d'accordo sull'ennesimo bit, ma non per costruzione.

È possibile utilizzare i flag di bit per contrassegnare se è presente un numero intero o meno.

Dopo aver attraversato l'intero file, scansionare ogni bit per determinare se il numero esiste o meno.

Supponendo che ogni numero intero sia a 32 bit, si adatteranno comodamente a 1 GB di RAM se viene eseguito il flag di bit.

Rimuovere lo spazio bianco e i caratteri non numerici dal file e aggiungere 1. Il file ora contiene un singolo numero non elencato nel file originale.

Da Reddit di Carbonetc.

Solo per completezza, ecco un'altra soluzione molto semplice, che molto probabilmente richiederà molto tempo per essere eseguita, ma utilizza pochissima memoria.

Consenti a tutti i possibili numeri interi di essere compreso nell'intervallo da int_mina int_max, e bool isNotInFile(integer)una funzione che restituisce true se il file non contiene un determinato numero intero e false else (confrontando quel determinato numero intero con ciascun numero intero nel file)

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

Per il vincolo di memoria di 10 MB:

1. Converti il ​​numero nella sua rappresentazione binaria.
2. Crea un albero binario dove left = 0 e right = 1.
3. Inserisci ogni numero nella struttura usando la sua rappresentazione binaria.
4. Se è già stato inserito un numero, le foglie saranno già state create.

Al termine, basta prendere un percorso che non è stato creato prima per creare il numero richiesto.

4 miliardi di numeri = 2 ^ 32, il che significa che 10 MB potrebbero non essere sufficienti.

MODIFICARE

Un'ottimizzazione è possibile, se sono state create due foglie finali e hanno un genitore comune, possono essere rimosse e il genitore contrassegnato come non una soluzione. Ciò taglia i rami e riduce la necessità di memoria.

EDIT II

Non è necessario costruire anche l'albero completamente. Hai solo bisogno di costruire rami profondi se i numeri sono simili. Se tagliamo anche i rami, questa soluzione potrebbe funzionare davvero.

Risponderò alla versione da 1 GB:

Non ci sono abbastanza informazioni nella domanda, quindi dichiarerò prima alcune ipotesi:

L'intero è di 32 bit con un intervallo compreso tra -2.147.483.648 e 2.147.483.647.

Pseudo-codice:

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;
    }
}

Finché facciamo risposte creative, eccone un'altra.

Utilizzare il programma di ordinamento esterno per ordinare numericamente il file di input. Funzionerà con qualsiasi quantità di memoria che potresti avere (userà l'archiviazione dei file se necessario). Leggi il file ordinato e visualizza il primo numero mancante.

Eliminazione dei bit

Un modo è quello di eliminare i bit, tuttavia ciò potrebbe non produrre effettivamente un risultato (è probabile che non lo sia). psuedocodarlo:

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

Bit conta

Tenere traccia dei conteggi dei bit; e utilizzare i bit con gli importi minimi per generare un valore. Ancora una volta, ciò non ha alcuna garanzia di generare un valore corretto.

Range Logic

Tieni traccia di un elenco di intervalli ordinati (ordinati per inizio). Un intervallo è definito dalla struttura:

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

Passare attraverso ciascun valore nel file e provare a rimuoverlo dall'intervallo corrente. Questo metodo non ha garanzie di memoria, ma dovrebbe funzionare abbastanza bene.

2 ^{128 * 10 18} + 1 (che è (2 ⁸ ) ^{16 * 10 18} + 1) - non può essere una risposta universale per oggi? Ciò rappresenta un numero che non può essere conservato nel file 16 EB, che è la dimensione massima del file in qualsiasi file system corrente.

Penso che questo sia un problema risolto (vedi sopra), ma c'è un caso laterale interessante da tenere a mente perché potrebbe essere chiesto:

Se ci sono esattamente 4.294.967.295 (2 ^ 32 - 1) numeri interi a 32 bit senza ripetizioni, e quindi ne manca solo uno, esiste una soluzione semplice.

Inizia un totale parziale a zero e per ogni numero intero nel file, aggiungi quel numero intero con overflow a 32 bit (in effetti, runningTotal = (runningTotal + nextInteger)% 4294967296). Una volta completato, aggiungi 4294967296/2 al totale parziale, sempre con overflow a 32 bit. Sottrai questo da 4294967296 e il risultato è l'intero mancante.

Il problema "solo un numero intero mancante" è risolvibile con una sola esecuzione e solo 64 bit di RAM dedicati ai dati (32 per il totale parziale, 32 da leggere nel numero intero successivo).

Corollario: le specifiche più generali sono estremamente semplici da abbinare se non ci occupiamo di quanti bit deve avere il risultato intero. Generiamo semplicemente un numero intero abbastanza grande da non poter essere contenuto nel file che ci viene fornito. Ancora una volta, questo occupa una RAM assolutamente minima. Vedi lo pseudocodice.

# 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";
  }
}

Come ha detto Ryan in pratica, ordina il file e poi vai sugli interi e quando un valore viene saltato lì, ce l'hai :)

EDIT su downvoter: l'OP ha menzionato che il file potrebbe essere ordinato, quindi questo è un metodo valido.

Se non si assume il vincolo a 32 bit, è sufficiente restituire un numero a 64 bit generato casualmente (o 128 bit se si è pessimisti). La possibilità di collisione è 1 in 2^64/(4*10^9) = 4611686018.4(circa 1 su 4 miliardi). Avresti ragione la maggior parte del tempo!

(Scherzando ... in un certo senso.)