Bu röportaj sorusu bana verildi:

Dört milyar tamsayı içeren bir girdi dosyası verildiğinde, dosyada bulunmayan bir tamsayı oluşturmak için bir algoritma sağlayın. 1 GB belleğiniz olduğunu varsayın. Yalnızca 10 MB belleğiniz varsa ne yapacağınızı takip edin.

Analizim:

Dosyanın boyutu 4 × 10 ⁹ × 4 bayt = 16 GB'dir.

Harici sıralama yapabiliriz, böylece tamsayıların aralığını bize bildiririz.

Benim sorum sıralanmış büyük tamsayı kümelerinde eksik tamsayıyı tespit etmenin en iyi yolu nedir?

Anlayışım (tüm cevapları okuduktan sonra):

32 bit tamsayılardan bahsettiğimizi varsayarsak, 2 ³² = 4 * 10 ^{9 vardır.} farklı tamsayı vardır.

Durum 1: 1 GB = 1 * 10 ^{9'umuz var} * 8 bit = 8 milyar bit belleğimiz var.

Çözüm:

Farklı bir tamsayıyı temsil eden bir bit kullanırsak, yeterlidir. sıralamaya ihtiyacımız yok.

Uygulama:

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

Durum 2: 10 MB bellek = 10 * 10 ⁶ * 8 bit = 80 milyon bit

Çözüm:

Tüm olası 16 bit önekler için, 2 ¹⁶ sayı tamsayı = 65536, 2 ¹⁶ * 4 * 8 = 2 milyon bite ihtiyacımız var. 65536 kova üretmemiz gerekiyor. Her kova için tüm olasılıkları elinde tutan 4 bayta ihtiyacımız var çünkü en kötü durum 4 milyar tam sayının hepsi aynı kovaya ait.

1. Dosyadan ilk geçişte her bir bölümün sayacını oluşturun.
2. Kovaları tarayın, 65536'dan daha az isabet alan ilk olanı bulun.
3. Dosyanın ikinci geçişinden 2. adımda yüksek 16 bit önekleri bulunan yeni kovalar oluşturun
4. 3. adımda inşa edilen kovaları tarayın, isabetsiz olan ilk kovayı bulun.

Kod yukarıdakine çok benzer.

Sonuç: Dosya geçişini artırarak hafızayı azaltıyoruz.

^{Geç gelenler için bir açıklama: Soru, sorulduğu gibi, dosyada bulunmayan tam olarak bir tamsayı olduğunu söylemez - en azından çoğu kişi bunu yorumlamaz. Yorum dizisindeki Birçok yorumlar vardır gerçi, görevin konusu varyasyonun hakkında. Ne yazık ki, yorum dizisine tanıtan yorum daha sonra yazarı tarafından silindi, bu yüzden artık yetim cevaplar her şeyi yanlış anladı gibi görünüyor. Çok kafa karıştırıcı, üzgünüm.}

"Tamsayı" nın 32 bit anlamına geldiğini varsayarsak, herhangi bir 16 bit önekle giriş dosyasında kaç sayı olduğunu saymak için 10 MB alan yeterlidir, bir geçişte tüm olası 16 bit önekler için giriş dosyası. Kovalardan en az biri 2 ¹⁶ defadan az çarpmış olacak . Bu gruptaki olası numaralardan hangilerinin zaten kullanıldığını bulmak için ikinci bir geçiş yapın.

32 bitten fazla, ancak yine de sınırlı boyutta ise : Yukarıdaki gibi yapın, 32 bit aralığının (imzalı veya imzasız; seçiminiz) dışında kalan tüm giriş numaralarını yok sayarak.

"Tamsayı" matematiksel tamsayı anlamına gelirse : Girişi bir kez okuyun ve gördüğünüz en uzun sayının en büyük sayı uzunluğunu takip edin . İşiniz bittiğinde, en fazla artı bir rakama sahip rastgele bir sayının çıktısını alın . (Dosyadaki sayılardan biri tam olarak temsil etmek için 10 MB'tan fazla süren bir bignum olabilir, ancak giriş bir dosyaysa, en azından içine uyan herhangi bir şeyin uzunluğunu temsil edebilirsiniz ).

İstatistiksel olarak bilgilendirilmiş algoritmalar, bu sorunu deterministik yaklaşımlardan daha az geçiş kullanarak çözer.

Çok büyük tamsayılara izin verilirse , O (1) zamanında benzersiz olması muhtemel bir sayı üretilebilir. GUID gibi sözde rastgele bir 128 bit tam sayı , kümedeki mevcut dört milyar tam sayıdan biriyle, her 64 milyar milyar milyar vakadan birinden daha azında çarpışacaktır.

Tamsayılar 32 bit ile sınırlıysa, tek bir geçişte 10 MB'den daha az kullanan benzersiz bir sayı üretilebilir. Sözde rastgele 32 bitlik bir tamsayının mevcut 4 milyar tamsayıdan biri ile çarpışma olasılığı yaklaşık% 93'tür (4e9 / 2 ^ 32). 1000 sahte rasgele tamsayıların çarpışması ihtimali 12.000 milyar milyar milyardan birinden daha azdır (bir çarpışma olasılığı ^ 1000). Dolayısıyla, bir program 1000 sahte rasgele aday içeren bir veri yapısını koruyor ve bilinen tamsayılarla yineliyor ve adaylardan eşleşmeleri ortadan kaldırıyorsa, dosyada olmayan en az bir tamsayıyı bulmak kesin değildir.

Bu sorunla ilgili ayrıntılı bir tartışma Jon Bentley "Sütun 1. İstiridye Kırma" Programlama İncileri Addison-Wesley s.3-10

Bentley, harici sıralama, çeşitli harici dosyaları kullanarak Birleştirme Sıralaması vb.Dahil olmak üzere çeşitli yaklaşımları tartışır. Ancak Bentley'in önerdiği en iyi yöntem, bit alanlarını kullanarak mizahi bir şekilde "Wonder Sort" olarak adlandırdığı tek bir geçiş algoritmasıdır :) Sorun geliyor, 4 milyar sayılar şu şekillerde temsil edilebilir:

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

Bitset'i uygulamak için kod basit: ( çözümler sayfasından alınmıştır )

#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 algoritması dosya üzerinde tek bir geçiş yapar set, dizideki uygun biti bağlar ve ardından bu diziyitest eksik olan sayıyı bulmak için yukarıdaki makroyu .

Kullanılabilir bellek 0,466 GB'den azsa, Bentley girişi kullanılabilir belleğe bağlı olarak aralıklara ayıran bir k-pass algoritması önerir. Çok basit bir örnek vermek gerekirse, sadece 1 bayt (yani 8 rakamı işlemek için bellek) mevcutsa ve aralık 0 ila 31 arasındaysa, bunu 0 ila 7, 8-15, 16-22 aralığına böleriz vb. ve her 32/8 = 4geçişte bu aralığı idare edin .

HTH.

Sorun, dosyada bulunmayan mümkün olan en küçük sayıyı bulmamız gerektiğini belirtmediğinden, yalnızca giriş dosyasının kendisinden daha uzun bir sayı üretebiliriz. :)

1 GB RAM varyantı için bir bit vektörü kullanabilirsiniz. 4 milyar bit == 500 MB bayt dizisi ayırmanız gerekir. Girişten okuduğunuz her sayı için ilgili biti '1' olarak ayarlayın. İşiniz bittiğinde, bitlerin üzerinde tekrarlayın, hala '0' olan ilk tanesini bulun. Endeks cevabı.

32 bit tamsayılarsa (2 ^32'ye yakın ~ 4 milyar sayı arasından seçim yapılabilir ), 4 milyar sayı listeniz olası tam sayıların en fazla% 93'ünü kaplar (4 * 10 ⁹ / (2 ³² ) ). Bu nedenle , her bit sıfıra başlatılmış olarak 2 ³² bitlik bir bit dizisi oluşturursanız (2 ²⁹ bayt ~ 500 MB RAM alır; bir bayt = 2 ³ bit = 8 bit) hatırlayın , tam sayı listenizi okuyun ve her int için karşılık gelen bit dizisi elemanını 0'dan 1'e ayarlayın; ve bit dizinizi okuyun ve hala 0 olan ilk biti döndürün.

Daha az RAM'iniz varsa (~ 10 MB), bu çözümün biraz değiştirilmesi gerekir. 10 MB ~ 83886080 bit, 0 ile 83886079 arasındaki tüm sayılar için bir bit dizisi yapmak için hala yeterlidir. Böylece, ints listenizi okuyabilirsiniz; ve yalnızca bit dizinize 0 ile 83886079 arasındaki # sayılarını kaydedin. Sayılar rastgele dağıtılırsa; (yaklaşık 100 farkının% olasılığının ezici ile 10 ^-2592069 ) siz) Eksik int bulacaksınız. Aslında, yalnızca 1 ila 2048 arasındaki sayıları seçerseniz (yalnızca 256 bayt RAM ile), zamanın çok büyük bir yüzdesini (% 99.99999999999999999999999999999999999999999999999999999999999995) bulabilirsiniz.

Ama diyelim ki yaklaşık 4 milyar rakam yerine; 2 ³² - 1 sayı ve 10 MB'den daha az RAM'iniz vardı; bu yüzden küçük bir dizi int, sadece sayıyı içermeme olasılığı düşüktür.

Eğer listedeki her int eşsiz olduğunu garanti olsaydı, sayılarını toplamak ve bir # tam toplamı (½) eksik olan toplamını çıkarmak olabilir (2 ³² ) (2 ³² - 1) eksik int bulmak için = 9223372034707292160 . Ancak, bir int iki kez meydana geldiğinde bu yöntem başarısız olur.

Ancak, her zaman bölebilir ve fethedebilirsiniz. Saf bir yöntem, dizi boyunca okumak ve ilk yarıdaki (0 ila 2 ³¹ -1) ve ikinci yarıdaki (2 ³¹ , 2 ³² ) sayıların sayısını saymak olacaktır . Ardından, daha az sayı içeren aralığı seçin ve bu aralığı yarıya bölmeyi tekrarlayın. ((2 ³¹ , 2 ³² ) içinde daha az iki sayı varsa, bir sonraki aramanız aralıktaki sayıları sayar (2 ³¹ , 3 * 2 ³⁰ -1), (3 * 2 ³⁰ , 2 ³² ). sıfır sayı aralığını bulana ve cevabınız siz oluncaya kadar yinelenir.O dizisi boyunca O (lg N) ~ 32 değeri okunmalıdır.

Bu yöntem verimsizdi. Her adımda sadece iki tamsayı kullanıyoruz (veya 4 bayt (32 bit) tamsayı ile yaklaşık 8 bayt RAM). Daha iyi bir yöntem sqrt (2 ³² ) = 2 ¹⁶ = 65536 kutuya bölmek , her biri bir depoda 65536 sayıya sahip olmaktır. Her bölmenin sayısını saklamak için 4 bayt gerekir, bu nedenle 2 ¹⁸ bayt = 256 kB'ye ihtiyacınız vardır. Yani kutu 0 (0 ila 65535 = 2 ¹⁶ -1), kutu 1 (2 ¹⁶ = 65536 ila 2 * 2 ¹⁶ -1 = 131071), kutu 2 (2 * 2 ¹⁶ = 131072 ila 3 * 2 ¹⁶ - 1 = 196.607). Python'da şöyle bir şey olurdu:

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)

~ 4 milyar tam sayı listesini okuyun; ve 2 ¹⁶ bölmenin her birine kaç tane int düştüğünü sayın ve 65536 numarasının tümüne sahip olmayan bir eksik_bin bulun. Sonra tekrar 4 milyar tam sayı listesini okudunuz; ancak bu kez yalnızca tamsayılar bu aralıktayken fark edilir; onları bulduğunuzda biraz çevirme.

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

Neden bu kadar karmaşık? Dosyada olmayan bir tam sayı mı istiyorsunuz?

Belirtilen kurallara göre, depolamanız gereken tek şey dosyada şu ana kadar karşılaştığınız en büyük tam sayıdır. Tüm dosya okunduktan sonra, 1'den büyük bir sayı döndürün.

Kurallara göre, tamsayı boyutu veya algoritma tarafından döndürülen sayı ile ilgili herhangi bir kısıtlama olmadığından, maxint'e veya başka bir şeye çarpma riski yoktur.

Bu, ikili aramanın bir varyantı kullanılarak çok az alanda çözülebilir.

1. , Sayıların izin verilen aralığın ile başlayın 0için 4294967295.

2. Orta noktayı hesaplayın.

3. Kaç tane sayıya eşit, orta nokta değerinden daha küçük veya daha yüksek olduğunu sayarak dosyada dolaşın.

4. Hiçbir sayı eşit değilse, işiniz bitmiştir. Orta nokta numarası cevaptır.

5. Aksi takdirde, en az sayıya sahip aralığı seçin ve bu yeni aralıkla 2. adımdan itibaren tekrarlayın.

Bu, dosya boyunca 32'ye kadar doğrusal tarama gerektirir, ancak aralığı ve sayıları depolamak için yalnızca birkaç bayt bellek kullanır.

Bu, Henning'in çözümü ile aynıdır, ancak 16k yerine iki kutu kullanır.

EDIT Tamam, dosyadaki tamsayıların bazı statik dağılımları izlediğini varsaydığı için bu tam olarak düşünülmedi. Görünüşe göre buna gerek yok, ama o zaman bile bunu denemelisin:

4.3 milyar 32 32-bit tamsayı vardır. Dosyada nasıl dağıldıklarını bilmiyoruz, ancak en kötü durum Shannon entropisine en yüksek olanı: eşit bir dağılım. Bu durumda, dosyada herhangi bir tamsayı oluşma olasılığı

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

Shannon entropisi ne kadar düşükse, bu olasılık ortalamada o kadar yüksek olur, ancak bu en kötü durum için bile, rasgele tamsayılarla 5 tahminden sonra ortaya çıkan bir sayı bulma şansımız% 90'dır. Sadece bu tür numaraları bir sözde jeneratörle oluşturun, bir listede saklayın. Sonra int sonra int okuyun ve tüm tahminlerinizle karşılaştırın. Bir eşleşme olduğunda, bu liste girişini kaldırın. Tüm dosyadan geçtikten sonra, birden fazla tahmininiz kalma şansı vardır. Bunlardan herhangi birini kullanın. Hiçbir tahmin kalmamış nadir (en kötü durumda% 10) olayında, yeni bir rastgele tamsayı seti, belki de bu sefer daha fazla (% 10-> 99) alın.

Bellek tüketimi: birkaç düzine bayt, karmaşıklık: O (n), tepegöz: neclectable olarak çoğu zaman ints karşılaştırmak yerine kaçınılmaz sabit disk erişimlerinde harcanacaktır.

[0, 2 ^ x - 1] aralığından eksik bir tamsayı varsa, hepsini bir arada xorulayın. Örneğin:

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

(Bunun soruyu tam olarak cevaplamadığını biliyorum , ancak çok benzer bir soru için iyi bir cevap.)

Bir değerin büyük bir kümenin parçası olup olmadığını kesinlikle çok verimli bir şekilde belirleyen olasılıklı bir Bloom Filtresi duyup duymadığınızı görmek isteyebilirler (ancak yalnızca yüksek olasılıkla setin bir üyesi olduğunu belirleyebilirler.)

Orijinal sorudaki mevcut ifadeye dayanarak, en basit çözüm:

Dosyadaki maksimum değeri bulun, sonra 1 değerini ekleyin.

A kullanın BitSet. Bayt başına 8'de bir BitSet içine paketlenmiş 4 milyar tamsayı (2 ^ 32 tamsayıya kadar varsayarak) 2 ^ 32/2 ^ 3 = 2 ^ 29 = yaklaşık 0,5 Gb'dir.

Biraz daha fazla ayrıntı eklemek için - her sayıyı okuduğunuzda, BitSet'te ilgili biti ayarlayın. Ardından, mevcut olmayan ilk sayıyı bulmak için BitSet'i geçin. Aslında, bunu tekrar tekrar rastgele bir sayı seçerek ve varsa test ederek etkili bir şekilde yapabilirsiniz.

Aslında BitSet.nextClearBit (0) size ayarlanmamış ilk biti söyleyecektir.

BitSet API'sine bakıldığında, yalnızca 0..MAX_INT'i desteklediği görülüyor, bu nedenle biri + 've sayıları için ve diğeri numaralar için olmak üzere 2 BitSet'e ihtiyacınız olabilir, ancak bellek gereksinimleri değişmez.

Boyut sınırı yoksa, en hızlı yol dosyanın uzunluğunu almak ve dosyanın uzunluğunu + 1 rasgele basamak sayısını (veya yalnızca "11111 ...") oluşturmaktır. Avantajı: dosyayı okumanıza bile gerek yoktur ve bellek kullanımını neredeyse sıfıra indirebilirsiniz. Dezavantajı: Milyarlarca basamak basacaksınız.

Bununla birlikte, tek faktör bellek kullanımını en aza indiriyorsa ve başka bir şey önemli değilse, bu en uygun çözüm olacaktır. Hatta size "kuralların en kötüye kullanılması" ödülünü bile verebilir.

Sayı aralığının her zaman 2 ^ n (2'nin çift gücü) olacağını varsayarsak, dışlayıcı veya işe yarar (başka bir posterde gösterildiği gibi). Neden olduğu kadarıyla kanıtlayalım:

Teori

2^nBir öğesi eksik olan öğelere sahip 0 tabanlı tamsayılar aralığı göz önüne alındığında , eksik sayıyı elde etmek için bilinen değerleri bir araya getirerek bu eksik öğeyi bulabilirsiniz.

Kanıt

N = 2'ye bakalım. N = 2 için, 4 benzersiz tamsayıyı temsil edebiliriz: 0, 1, 2, 3. Biraz kalıpları vardır:

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

Şimdi, bakarsak, her bit tam olarak iki kez ayarlanır. Bu nedenle, çift sayıda ayarlandığı ve münhasır-veya sayıların 0 olduğu için, tek bir sayı eksikse, münhasır- veya münhasır veya eksik sayıya sahip olduğunda bir sayı verir. Bu nedenle, eksik sayı ve sonuçta ortaya çıkan münhasır veya ored sayı tamamen aynıdır. 2'yi kaldırırsak, ortaya çıkan x veya10 (veya 2) olur.

Şimdi n + 1'e bakalım. Let birbirlerinin biraz ayarlanır sayısını diyoruz n, xve her bit ayarlanır sayısını n+1 y. Değeri yeşit olacaktır, y = x * 2çünkü bit 0 olarak ayarlanmış xelemanlar ve n+1bit 1 olarak ayarlanmış xelemanlar vardır n+1. Ve 2xher zaman eşit n+1olacağından, her bit her zaman eşit sayıda ayarlanmış olacaktır.

Bu nedenle, n=2çalışır ve n+1çalışır beri , xor yöntemi tüm değerleri için çalışacaktır n>=2.

0 Tabanlı Aralıkların Algoritması

Bu oldukça basit. 2 * n bellek kullanır, bu nedenle <= 32, 2 32 bit tam sayı aralığı için çalışır (dosya tanımlayıcı tarafından tüketilen belleği yok sayar). Ve dosyanın tek bir geçişini yapar.

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

Keyfi Tabanlı Aralıkların Algoritması

Bu algoritma, toplam aralık 2 ^ n'ye eşit olduğu sürece, herhangi bir başlangıç ​​numarasının herhangi bir bitiş numarasına kadar olan aralıklarda çalışacaktır ... Bu, temelde en az 0'a sahip olmak için aralığı yeniden temeller. Ancak 2 geçiş gerektirir dosya üzerinden (minimum kapmak için ilk, eksik int hesaplamak için ikinci).

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;

Keyfi Aralıklar

Bu değiştirilmiş yöntemi bir dizi rasgele aralığa uygulayabiliriz, çünkü tüm aralıklar en az bir kez 2 ^ n'lik bir gücü geçecektir. Bu sadece tek bir eksik bit varsa işe yarar. Sıralanmamış bir dosyanın 2 geçişini alır, ancak her seferinde eksik olan tek sayıyı bulur:

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;

Temel olarak, aralığı 0 civarında temel alır. Ardından, exclusive- veya öğesini hesaplarken eklenecek ayrılmamış değerlerin sayısını sayar. Ardından, eksik değere bakmak için sıralanmamış değerlerin sayısına 1 ekler (eksik olanı sayın). Daha sonra, n değeri 2 olana kadar her seferinde 1 artarak n değerini xoring etmeye devam edin. Sonuç daha sonra orijinal tabana geri döndürülür. Bitti.

İşte PHP test algoritması (bir dosya yerine bir dizi kullanarak, ama aynı kavram):

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

Herhangi bir değer aralığına sahip bir dizide beslenen (negatifler dahil olmak üzere test ettim), bu aralığın içinde eksik olan, her seferinde doğru değeri buldu.

Başka bir yaklaşım

Harici sıralamayı kullanabildiğimiz için, neden sadece bir boşluk kontrol etmiyoruz? Dosyanın bu algoritmanın çalıştırılmasından önce sıralandığını varsayarsak:

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;

Yanlış bir şekilde alıntılanmadığı sürece, hile sorusu. Maksimum tamsayıyı almak için dosyayı bir kez okuyun nve geri dönün n+1.

n+1Bir tamsayı taşmasına neden olması durumunda elbette bir yedekleme planına ihtiyacınız olacaktır .

Giriş dosyasının boyutunu kontrol edin, ardından bu boyutta bir dosyayla temsil edilemeyecek kadar büyük herhangi bir sayı çıktısı alın . Bu ucuz bir numara gibi görünebilir, ancak bir röportaj problemine yaratıcı bir çözümdür, hafıza sorununu düzgün bir şekilde azaltır ve teknik olarak 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);
    }
}

Her zaman 2 ^{bit sayımdan} daha büyük olacak olan 10 ^bit - 1 yazdırmalıdır . Teknik olarak, ^dövmeniz gereken sayı 2 ^{bit sayılır} - (4 * 10 ⁹ - 1) , çünkü dosyada (4 milyar - 1) başka tamsayı olduğunu biliyorsunuz ve mükemmel sıkıştırma ile bile en azından alacaklar her biri bir bit.

• En basit yaklaşım, dosyadaki minimum sayıyı bulmak ve bundan daha az 1 döndürmektir. Bu, n numaralı bir dosya için O (1) depolama alanını ve O (n) süresini kullanır. Bununla birlikte, sayı aralığı sınırlıysa başarısız olur, bu da min-1'i bir sayı yapmaz.

• Bir bitmap kullanmanın basit ve anlaşılır yönteminden daha önce bahsedilmiştir. Bu yöntem O (n) zaman ve depolamayı kullanır.

• 2 ^ 16 sayma kabına sahip 2 geçişli bir yöntemden de bahsedilmiştir. 2 * n tamsayı okur, bu nedenle O (n) zaman ve O (1) depolamayı kullanır, ancak 2 ^ 16'dan fazla sayıya sahip veri kümelerini işleyemez. Bununla birlikte, 2 yerine 4 geçiş çalıştırarak (ör.) 2 ^ 60 64 bit tamsayılara kolayca genişletilebilir ve yalnızca belleğe sığacak kadar çok bölme kullanarak ve buna göre geçiş sayısını artırarak küçük bellek kullanımına kolayca uyarlanabilir. bu durumda çalışma süresi artık O (n) değil, O (n * log n) 'dir.

• Tüm sayıları birlikte XOR'lama yöntemi, şimdiye kadar rfrankel ve uzunluk ircmaxell tarafından belirtildi , ltn100'ün belirttiği gibi stackoverflow # 35185'te sorulan soruya cevap veriyor . O (1) depolama ve O (n) çalışma süresi kullanır. Şimdilik 32 bit tamsayı varsayarsak, XOR% 7 oranında farklı bir sayı üretme olasılığına sahiptir. Gerekçe: XOR'lu ~ 4G farklı sayılar birlikte verilir ve ca. 300M dosyada değil, her bit konumundaki set bitlerinin sayısı tek veya çift olma şansına sahiptir. Bu nedenle, 2 ^ 32 sayısının XOR sonucu olarak ortaya çıkma olasılığı eşittir, bunun% 93'ü zaten dosyadadır. Dosyadaki sayıların hepsi farklı değilse, XOR yönteminin başarı olasılığının arttığını unutmayın.

Bazı nedenlerden dolayı, bu sorunu okuduğumda köşegenleştirmeyi düşündüm. Ben keyfi olarak büyük tamsayıları varsayıyorum.

İlk sayıyı okuyun. 4 milyar bitiniz olana kadar sıfır bitle sol tuşla doldurun. İlk (yüksek dereceli) bit 0 ise, çıkış 1; başka çıkış 0. (Gerçekten sol-pad yapmak zorunda değilsiniz: sayıda yeterli bit yoksa sadece 1 verirsiniz.) İkinci biti kullanmak dışında, ikinci sayı için de aynısını yapın. Dosya üzerinde bu şekilde devam edin. Bir kerede 4 milyar bitlik bir sayı çıktısı verirsiniz ve bu sayı dosyadakiyle aynı olmaz. İspat: n'inci sayı ile aynıydı, o zaman n'inci bit üzerinde hemfikir olacaklardı, ama inşaatla değiller.

Bir tamsayı olup olmadığını işaretlemek için bit bayraklarını kullanabilirsiniz.

Dosyanın tamamını gezdikten sonra, sayının var olup olmadığını belirlemek için her bir biti tarayın.

Her tamsayının 32 bit olduğunu varsayarsak, bit işaretlemesi yapılırsa 1 GB RAM'e rahatça sığarlar.

Boşluk ve sayısal olmayan karakterleri dosyadan ayırın ve 1 ekleyin. Dosyanız şimdi orijinal dosyada listelenmeyen tek bir sayı içeriyor.

Reddit'ten Carbonetc tarafından.

Tamlık uğruna, işte büyük olasılıkla çalışması çok uzun sürecek, ancak çok az bellek kullanan çok basit bir çözüm.

Tüm olası tamsayılar gelen aralık olalım int_minetmek int_maxve bool isNotInFile(integer)dosyası (dosyadaki her tamsayı ile belirli tamsayı karşılaştırarak) belli bir tamsayı ve yanlış başka içermiyorsa gerçek döndüren bir işlev

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

10 MB bellek kısıtlaması için:

1. Sayıyı ikili gösterimine dönüştürün.
2. Sol = 0 ve sağ = 1 olan bir ikili ağaç oluşturun.
3. Her sayıyı ikili gösterimini kullanarak ağaca ekleyin.
4. Bir numara önceden eklenmişse, yapraklar zaten oluşturulmuş olacaktır.

Tamamlandığında, istenen numarayı oluşturmak için daha önce oluşturulmamış bir yolu seçmeniz yeterlidir.

4 milyar sayı = 2 ^ 32, yani 10 MB yeterli olmayabilir.

DÜZENLE

İki uçlu yaprak oluşturulduysa ve ortak bir üst öğeye sahipse, bir optimizasyon mümkündür ve bu çözüm kaldırılabilir ve üst öğe bir çözüm değil olarak işaretlenebilir. Bu dalları keser ve bellek ihtiyacını azaltır.

DÜZENLEME II

Ağacı tamamen inşa etmeye gerek yoktur. Sadece sayılar benzerse derin dallar oluşturmanız gerekir. Dalları da kesersek, bu çözüm aslında işe yarayabilir.

1 GB versiyonuna cevap vereceğim:

Soruda yeterli bilgi yok, bu yüzden önce bazı varsayımları belirteceğim:

Tam sayı 32 bit olup -2.147.483.648 ila 2.147.483.647 aralığındadır.

Sözde kod:

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

Yaratıcı cevaplar yaptığımız sürece, işte bir tane daha.

Giriş dosyasını sayısal olarak sıralamak için harici sıralama programını kullanın. Bu, sahip olabileceğiniz herhangi bir bellek miktarı için çalışır (gerekirse dosya depolama alanını kullanır). Sıralanan dosyayı okuyun ve eksik olan ilk sayının çıktısını alın.

Bit Eleme

Bir yol, bitleri ortadan kaldırmaktır, ancak bu aslında bir sonuç vermeyebilir (şansı yoktur). Psuedocode:

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

Bit Sayısı

Bit sayılarını takip edin; ve bir değer üretmek için bitleri en az miktarda kullanın. Yine bunun doğru bir değer üretme garantisi yoktur.

Menzil Mantığı

Sıralı aralıkların listesini (başlangıç ​​tarafından sıralanan) takip edin. Bir aralık yapı tarafından tanımlanır:

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

Dosyadaki her bir değeri gözden geçirin ve geçerli aralıktan kaldırmayı deneyin. Bu yöntemin bellek garantisi yoktur, ancak oldukça iyi olması gerekir.

2 ^{128 * 10 18} + 1 ((2 ⁸ ) ^{16 * 10 18} + 1) - bugün için evrensel bir cevap olamaz mı? Bu, 16 EB dosyasında tutulamayan bir sayıyı temsil eder; bu, mevcut herhangi bir dosya sistemindeki maksimum dosya boyutudur.

Bunun çözülmüş bir sorun olduğunu düşünüyorum (yukarıya bakın), ancak akılda tutulması gereken ilginç bir yan durum var, çünkü sorulabilir:

Tam olarak 4.294.967.295 (2 ^ 32-1) 32 bitlik tamsayılar yoksa ve bu nedenle yalnızca bir tanesi eksikse, basit bir çözüm vardır.

Çalışan bir toplamı sıfır olarak başlatın ve dosyadaki her tam sayı için bu biti 32 bit taşma ile ekleyin (etkili bir şekilde runningtotal = (runningTotal + nextInteger)% 4294967296). Tamamlandığında, yine 32 bit taşma ile çalışan toplama 4294967296/2 ekleyin. Bunu 4294967296'dan çıkarın ve sonuç eksik tam sayıdır.

"Yalnızca bir eksik tamsayı" sorunu yalnızca bir çalışma ve yalnızca 64 bit RAM (veriler için ayrılan RAM, bir sonraki tamsayıda okumak için 32) ile çözülebilir.

Sonuç: Tamsayı sonucunun kaç biti olması gerektiğinden endişe etmiyorsak, daha genel spesifikasyonun eşleştirilmesi son derece basittir. Sadece bize verilen dosyada bulunamayacak kadar büyük bir tamsayı üretiyoruz. Yine, bu kesinlikle minimum RAM gerektirir. Sözde koduna bakın.

# 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'ın temelde söylediği gibi, dosyayı sıralayın ve tamsayıların üzerine gidin ve bir değer atlandığında orada var :)

Downvoters'ta DÜZENLE : OP, dosyanın geçerli bir yöntem olması için sıralanabileceğini belirtti.

32 bitlik kısıtlamayı kabul etmiyorsanız, rastgele oluşturulmuş bir 64 bit sayı (veya kötümserseniz 128 bit) döndürmeniz yeterlidir. Çarpışma şansı1 in 2^64/(4*10^9) = 4611686018.4 (kabaca 4 milyarda 1). Çoğu zaman haklısın!

(Şaka ... biraz.)