ฉันได้รับคำถามสัมภาษณ์นี้:

ให้อินพุตไฟล์ที่มีจำนวนเต็มสี่พันล้านชุดให้อัลกอริทึมในการสร้างจำนวนเต็มซึ่งไม่ได้อยู่ในไฟล์ สมมติว่าคุณมีหน่วยความจำ 1 GB ติดตามสิ่งที่คุณจะทำถ้าคุณมีหน่วยความจำเพียง 10 MB

การวิเคราะห์ของฉัน:

ขนาดของไฟล์คือ 4 × 10 ⁹ × 4 ไบต์ = 16 GB

เราสามารถทำการจัดเรียงภายนอกได้ดังนั้นจึงแจ้งให้เราทราบช่วงของจำนวนเต็ม

คำถามของฉันคือวิธีที่ดีที่สุดในการตรวจจับจำนวนเต็มหายไปในชุดจำนวนเต็มเรียงลำดับขนาดใหญ่?

ความเข้าใจของฉัน (หลังจากอ่านคำตอบทั้งหมด):

สมมติว่าเรากำลังพูดถึงจำนวนเต็ม 32 บิตมี 2 ³² = 4 * 10 ⁹จำนวนเต็มชัดเจน

กรณีที่ 1: เรามี 1 GB = 1 * 10 ⁹ * 8 บิต = หน่วยความจำ 8 พันล้านบิต

สารละลาย:

ถ้าเราใช้หนึ่งบิตที่เป็นตัวแทนของจำนวนเต็มจำนวนหนึ่งก็เพียงพอแล้ว เราไม่ต้องการการจัดเรียง

การดำเนินงาน:

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: หน่วยความจำ 10 MB = 10 * 10 ⁶ * 8 บิต = 80 ล้านบิต

สารละลาย:

สำหรับคำนำหน้า 16- บิตที่เป็นไปได้ทั้งหมดมีจำนวนเต็ม^{16 16} = 65536 เราต้องการ 2 ¹⁶ * 4 * 8 = 2 ล้านบิต เราต้องการสร้างถัง 65536 สำหรับที่เก็บข้อมูลแต่ละชุดเราจำเป็นต้องมี 4 ไบต์เพื่อเก็บความเป็นไปได้ทั้งหมดเนื่องจากกรณีที่เลวร้ายที่สุดคือจำนวนเต็ม 4 พันล้านทั้งหมดที่อยู่ในที่เก็บข้อมูลชุดเดียวกัน

1. สร้างตัวนับของที่เก็บข้อมูลแต่ละชุดผ่านการส่งผ่านครั้งแรกผ่านไฟล์
2. สแกนถังหาคนแรกที่มีน้อยกว่า 65536 ครั้ง
3. สร้างที่เก็บข้อมูลใหม่ซึ่งเราพบว่ามีคำนำหน้าสูง 16 บิตในขั้นตอนที่ 2 ถึงการส่งผ่านครั้งที่สองของไฟล์
4. สแกนที่เก็บข้อมูลที่สร้างในขั้นตอนที่ 3 ค้นหาที่เก็บข้อมูลชุดแรกซึ่งไม่มีการเข้าชม

รหัสนี้คล้ายกับรหัสด้านบน

สรุป: เราลดหน่วยความจำผ่านการเพิ่มไฟล์ผ่าน

^{คำชี้แจงสำหรับผู้มาสาย: คำถามตามที่ถามไม่ได้บอกว่ามีจำนวนเต็มหนึ่งตัวที่ไม่ได้อยู่ในไฟล์อย่างน้อยนั่นไม่ใช่วิธีที่คนส่วนใหญ่ตีความมัน ความคิดเห็นจำนวนมากในหัวข้อการแสดงความคิดเห็นเป็นเกี่ยวกับรูปแบบของงานที่แม้ว่า น่าเสียดายที่ความคิดเห็นที่นำไปใช้กับเธรดความคิดเห็นถูกลบในภายหลังโดยผู้เขียนดังนั้นตอนนี้ดูเหมือนว่าการตอบกลับที่ถูกโยงถึงเพียงเข้าใจผิดทุกอย่าง มันสับสนมากขอโทษ}

สมมติว่า "จำนวนเต็ม" หมายถึง 32 บิต : พื้นที่ว่าง 10 MB นั้นเพียงพอสำหรับคุณที่จะนับว่ามีตัวเลขจำนวนเท่าใดในไฟล์อินพุตที่มีส่วนนำหน้า 16 บิตใด ๆ สำหรับคำนำหน้า 16 บิตที่เป็นไปได้ทั้งหมดในครั้งเดียวผ่าน ไฟล์อินพุต อย่างน้อยหนึ่งถังจะถูกโจมตีน้อยกว่า 2 ¹⁶ครั้ง ใช้รหัสผ่านที่สองเพื่อค้นหาว่ามีหมายเลขใดบ้างที่เป็นไปได้ในที่ฝากข้อมูลนั้นแล้ว

ถ้ามันมีความหมายมากกว่า 32 บิต แต่ยังคงมีขนาดที่ จำกัด : ทำตามข้างบนโดยไม่สนใจหมายเลขอินพุตทั้งหมดที่อยู่นอกช่วง (ลงนามหรือไม่ได้ลงนาม; ตัวเลือกของคุณ) ช่วง 32 บิต

หาก "จำนวนเต็ม" หมายถึงจำนวนเต็มทางคณิตศาสตร์ : อ่านผ่านอินพุตหนึ่งครั้งและติดตามความยาวจำนวนที่มากที่สุดของจำนวนที่ยาวที่สุดที่คุณเคยเห็น เมื่อคุณทำเสร็จแล้วให้ส่งออกสูงสุดบวกหนึ่งหมายเลขสุ่มที่มีหนึ่งหลัก (หนึ่งในตัวเลขในไฟล์อาจเป็น bignum ที่ใช้เวลามากกว่า 10 MB เพื่อแสดงอย่างแน่นอน แต่หากอินพุตเป็นไฟล์อย่างน้อยคุณก็สามารถแสดงความยาวของสิ่งใดก็ได้ที่อยู่ในนั้น)

อัลกอริทึมที่ได้รับข้อมูลเชิงสถิติแก้ปัญหานี้โดยใช้การผ่านที่น้อยกว่าวิธีการที่กำหนดไว้

หากอนุญาตให้มีจำนวนเต็มมากจะทำให้สามารถสร้างตัวเลขที่น่าจะไม่ซ้ำกันในเวลา O (1) หลอกสุ่มจำนวนเต็ม 128 บิตเช่นGUIDจะมีเพียงหนึ่งชนกับของที่มีอยู่สี่พันล้านจำนวนเต็มในชุดในเวลาน้อยกว่าหนึ่งจากทุก 64000000000 พันล้านพันล้านกรณี

หากจำนวนเต็มถูก จำกัด ไว้ที่ 32 บิตแล้วหนึ่งสามารถสร้างตัวเลขที่น่าจะไม่ซ้ำกันในรอบเดียวโดยใช้น้อยกว่า 10 MB อัตราต่อรองที่เป็นจำนวนเต็ม 32 บิตหลอกเทียมจะชนกับหนึ่งใน 4 พันล้านที่มีอยู่คือประมาณ 93% (4e9 / 2 ^ 32) อัตราต่อรองที่ 1,000 จำนวนเต็มหลอกหลอกทั้งหมดจะชนกันน้อยกว่าหนึ่งใน 12,000 ล้านล้านล้าน (อัตราต่อรองของการปะทะกัน ^ 1000) ดังนั้นหากโปรแกรมรักษาโครงสร้างข้อมูลที่มีตัวเลือกสุ่มหลอก 1,000 ตัวและทำซ้ำผ่านจำนวนเต็มที่รู้จักการกำจัดการจับคู่จากผู้สมัครมันเป็นเพียงการค้นหาอย่างน้อยหนึ่งจำนวนเต็มที่ไม่ได้อยู่ในไฟล์

การอภิปรายอย่างละเอียดเกี่ยวกับปัญหานี้ได้รับการกล่าวถึงในJon Bentley "คอลัมน์ 1 แคร็กเดอะออยสเตอร์" การเขียนโปรแกรม Pearls Addison-Wesley pp.3-10

เบนท์ลีย์กล่าวถึงวิธีการหลายอย่างรวมถึงการจัดเรียงภายนอกผสานการจัดเรียงโดยใช้ไฟล์ภายนอกหลาย ๆ วิธี แต่วิธีที่ดีที่สุดที่เบนท์ลีย์แนะนำคืออัลกอริธึมการส่งผ่านเดี่ยวที่ใช้ฟิลด์บิตซึ่งเขาเรียกว่า ตัวเลขสามารถแสดงเป็น:

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

รหัสที่จะใช้บิตเซ็ตนั้นง่ายมาก: (นำมาจากหน้าโซลูชัน )

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

อัลกอริทึมของเบนท์ลีย์ทำการส่งผ่านไฟล์ไฟล์เดียวโดยsetใช้บิตที่เหมาะสมในอาร์เรย์จากนั้นตรวจสอบอาร์เรย์นี้โดยใช้testมาโครด้านบนเพื่อค้นหาหมายเลขที่หายไป

หากหน่วยความจำที่มีอยู่น้อยกว่า 0.466 GB, Bentley แนะนำอัลกอริทึม k-pass ซึ่งแบ่งอินพุตเป็นช่วงขึ้นอยู่กับหน่วยความจำที่มีอยู่ เพื่อยกตัวอย่างง่ายๆมากถ้ามีเพียง 1 ไบต์ (เช่นหน่วยความจำเพื่อจัดการตัวเลข 8 ตัว) และมีช่วงตั้งแต่ 0 ถึง 31 เราแบ่งสิ่งนี้เป็น 0 ถึง 7, 8-15, 16-22 และอื่น ๆ และจัดการช่วงนี้ในแต่ละ32/8 = 4รอบ

HTH

เนื่องจากปัญหาไม่ได้ระบุว่าเราต้องค้นหาจำนวนที่น้อยที่สุดที่ไม่ได้อยู่ในไฟล์เราจึงสามารถสร้างตัวเลขที่ยาวกว่าไฟล์อินพุตได้ :)

สำหรับตัวแปร RAM ขนาด 1 GB คุณสามารถใช้บิตเวกเตอร์ได้ คุณต้องจัดสรร 4 พันล้านบิต == 500 MB ไบต์อาร์เรย์ สำหรับแต่ละหมายเลขที่คุณอ่านจากอินพุตให้ตั้งค่าบิตที่สอดคล้องกันเป็น '1' เมื่อคุณทำเสร็จแล้ววนซ้ำบิตค้นหาครั้งแรกที่ยังคง '0' ดัชนีของมันคือคำตอบ

หากพวกเขาเป็นจำนวนเต็ม 32- บิต (น่าจะมาจากตัวเลือกของ ~ 4 พันล้านหมายเลขใกล้กับ 2 ³² ) รายการของคุณ 4 พันล้านหมายเลขจะใช้เวลามากที่สุด 93% ของจำนวนเต็มที่เป็นไปได้ (4 * 10 ⁹ / (2 ³² ) ) ดังนั้นถ้าคุณสร้างบิตอาเรย์ของ 2 ³²บิตโดยแต่ละบิตเริ่มต้นเป็นศูนย์ (ซึ่งจะใช้เวลา 2 ²⁹ไบต์ถึง 500 เมกะไบต์แรม; จำไบต์ = 2 ³บิต = 8 บิต) อ่านรายการจำนวนเต็มของคุณและ สำหรับแต่ละ int ตั้งองค์ประกอบบิต - อาเรย์ที่สอดคล้องกันจาก 0 ถึง 1; จากนั้นอ่านบิตเรตของคุณแล้วส่งกลับบิตแรกที่ยังคงเป็น 0

ในกรณีที่คุณมี RAM น้อยกว่า (~ 10 MB) โซลูชันนี้จะต้องแก้ไขเล็กน้อย 10 MB ~ 83886080 บิตยังคงเพียงพอที่จะทำบิตเรย์สำหรับตัวเลขทั้งหมดระหว่าง 0 ถึง 83886079 ดังนั้นคุณสามารถอ่านรายการ int ของคุณ และบันทึกเฉพาะ #s ที่อยู่ระหว่าง 0 ถึง 83886079 ในอาร์เรย์บิตของคุณ หากตัวเลขมีการกระจายแบบสุ่ม; ด้วยความน่าจะเป็นที่ล้นหลาม (มันแตกต่างกัน 100% ประมาณ10 ^-2592069 ) คุณจะพบ int ที่ขาดหายไป) ในความเป็นจริงถ้าคุณเลือกตัวเลข 1 ถึง 2048 (มี RAM 256 ไบต์เท่านั้น) คุณยังคงพบว่าจำนวนที่ขาดหายไปนั้นเป็นเปอร์เซ็นต์ที่น่าเหลือเชื่อ (99.9999999999999999999999999999999999999999999999999999999999999999999999999999999999

แต่สมมุติว่าแทนที่จะมีตัวเลขประมาณ 4 พันล้านตัว คุณมีบางอย่างเช่น 2 ³² - 1 ตัวเลขและ RAM น้อยกว่า 10 MB ดังนั้นช่วงเล็ก ๆ ของ ints นั้นมีความเป็นไปได้เพียงเล็กน้อยที่ไม่ได้มีจำนวน

หากคุณรับประกันว่าแต่ละ int ในรายการนั้นไม่ซ้ำกันคุณสามารถหาผลรวมของตัวเลขและลบผลรวมด้วยจำนวน # ที่หายไปกับผลรวมทั้งหมด (½) (2 ³² ) (2 ³² - 1) = 9223372034707292160 เพื่อหา int ที่ขาดหายไป . อย่างไรก็ตามหากเกิด int ขึ้นสองครั้งวิธีนี้จะล้มเหลว

อย่างไรก็ตามคุณสามารถแบ่งและพิชิตได้เสมอ วิธีการที่ไร้เดียงสาคืออ่านอาร์เรย์และนับจำนวนตัวเลขที่อยู่ในครึ่งแรก (0 ถึง 2 ³¹ -1) และครึ่งหลัง (2 ³¹ , 2 ³² ) จากนั้นเลือกช่วงที่มีตัวเลขน้อยลงและแบ่งช่วงนั้นซ้ำครึ่ง (พูดว่าถ้ามีจำนวนน้อยกว่าสองใน (2 ³¹ , 2 ³² ) ดังนั้นการค้นหาครั้งต่อไปของคุณจะนับจำนวนในช่วง (2 ³¹ , 3 * 2 ³⁰ -1), (3 * 2 ³⁰ , 2 ³² ) ทำซ้ำจนกว่าคุณจะพบช่วงที่มีตัวเลขเป็นศูนย์และคุณมีคำตอบของคุณควรใช้ O (lg N) ~ 32 อ่านผ่านอาร์เรย์

วิธีการนั้นไม่มีประสิทธิภาพ เราใช้จำนวนเต็มสองตัวเท่านั้นในแต่ละขั้นตอน (หรือประมาณ 8 ไบต์ของ RAM พร้อมด้วยจำนวนเต็ม 4 ไบต์ (32- บิต)) วิธีที่ดีกว่าคือการแบ่งออกเป็น sqrt (2 ³² ) = 2 ¹⁶ = 65536 bins แต่ละอันมี 65536 หมายเลขในถังขยะ แต่ละ bin ต้องการ 4 ไบต์เพื่อเก็บจำนวนของมันดังนั้นคุณต้องมี 2 ¹⁸ไบต์ = 256 kB ดังนั้น bin 0 คือ (0 ถึง 65535 = 2 ¹⁶ -1), bin 1 คือ (2 ¹⁶ = 65536 ถึง 2 * 2 ¹⁶ -1 = 131071), bin 2 คือ (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)

อ่านรายการจำนวนเต็ม ~ 4 พันล้าน; และนับจำนวน ints ที่อยู่ในแต่ละ 2 ¹⁶ถังขยะและค้นหา incomplete_bin ที่ไม่มีหมายเลขทั้งหมด 65536 จากนั้นคุณอ่านจำนวนเต็ม 4 พันล้านรายการอีกครั้ง แต่คราวนี้สังเกตได้ก็ต่อเมื่อจำนวนเต็มอยู่ในช่วงนั้น พลิกบิตเมื่อคุณพบพวกเขา

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. เริ่มต้นด้วยช่วงที่ได้รับอนุญาตของตัวเลขที่จะ04294967295

2. คำนวณจุดกึ่งกลาง

3. วนดูไฟล์นับจำนวนเท่ากันน้อยกว่าหรือสูงกว่าค่าจุดกึ่งกลาง

4. ถ้าไม่มีตัวเลขเท่ากันคุณก็ทำเสร็จแล้ว ตัวเลขจุดกึ่งกลางคือคำตอบ

5. หรือเลือกช่วงที่มีตัวเลขน้อยที่สุดและทำซ้ำจากขั้นตอนที่ 2 ด้วยช่วงใหม่นี้

สิ่งนี้จะต้องสแกนเชิงเส้นสูงสุดถึง 32 ไฟล์ แต่จะใช้หน่วยความจำเพียงไม่กี่ไบต์ในการจัดเก็บช่วงและจำนวน

นี่เป็นหลักเหมือนกับโซลูชันของ Henningยกเว้นว่าจะใช้ถังขยะสองถังแทน 16k

แก้ไขตกลงไม่คิดค่อนข้างผ่านมันถือว่าเป็นจำนวนเต็มในไฟล์ตามการกระจายคงที่ เห็นได้ชัดว่าพวกเขาไม่จำเป็นต้องทำ แต่ถึงอย่างนั้นก็ควรลอง:

มีจำนวนเต็ม≈4.3พันล้าน 32- บิต เราไม่ทราบว่ามีการแจกจ่ายไฟล์อย่างไร แต่กรณีที่เลวร้ายที่สุดคือกรณีที่มีเอนโทรปีของแชนนอนสูงที่สุด: การกระจายเท่ากัน ในกรณีนี้ความน่าจะเป็นสำหรับเลขจำนวนเต็มหนึ่งค่าที่ไม่เกิดขึ้นในไฟล์คือ

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

ยิ่งค่าเอนโทรปีของแชนนอนลดลงความน่าจะเป็นนี้จะสูงขึ้นโดยเฉลี่ย แต่สำหรับกรณีที่แย่ที่สุดนี้เรามีโอกาส 90% ที่จะหาจำนวนที่ไม่เกิดขึ้นหลังจาก 5 เดาด้วยจำนวนเต็มแบบสุ่ม เพียงแค่สร้างหมายเลขดังกล่าวด้วยเครื่องกำเนิดไฟฟ้าเทียมเทียมเก็บไว้ในรายการ จากนั้นอ่าน int หลังจาก int และเปรียบเทียบกับการคาดเดาทั้งหมดของคุณ เมื่อมีการแข่งขันให้ลบรายการนี้ หลังจากผ่านไฟล์ทั้งหมดไปแล้วคุณจะมีโอกาสเหลืออีกหนึ่งครั้ง ใช้ใด ๆ ของพวกเขา ในกรณีที่หายาก (10% แม้ในกรณีที่เลวร้ายที่สุด) ที่ไม่มีการเดาเหลือให้รับชุดจำนวนเต็มแบบสุ่มใหม่ซึ่งอาจมากกว่าครั้งนี้ (10> 99%)

การใช้หน่วยความจำ: สองสามสิบไบต์ความซับซ้อน: O (n) ค่าใช้จ่าย: ไม่สามารถรวบรวมได้เนื่องจากส่วนใหญ่จะใช้เวลาในการเข้าถึงฮาร์ดดิสก์ที่หลีกเลี่ยงไม่ได้แทนที่จะเปรียบเทียบ ints อยู่ดี

หากคุณมีจำนวนเต็มหนึ่งตัวที่หายไปจากช่วง [0, 2 ^ x - 1] จากนั้นก็ให้ xor ทั้งหมดเข้าด้วยกัน ตัวอย่างเช่น:

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

(ฉันรู้ว่านี่ไม่ได้ตอบคำถามอย่างแน่นอนแต่เป็นคำตอบที่ดีสำหรับคำถามที่คล้ายกันมาก)

พวกเขาอาจจะดูว่าคุณเคยได้ยินเกี่ยวกับตัวกรองความน่าจะเป็นบลูมซึ่งสามารถกำหนดได้อย่างมีประสิทธิภาพอย่างแน่นอนหากค่าไม่ได้เป็นส่วนหนึ่งของชุดใหญ่ (แต่สามารถตัดสินได้ด้วยความน่าจะเป็นสูงเท่านั้น

ขึ้นอยู่กับถ้อยคำปัจจุบันในคำถามเดิมทางออกที่ง่ายที่สุดคือ:

ค้นหาค่าสูงสุดในไฟล์แล้วเพิ่ม 1 ลงไป

ใช้ BitSetการใช้งานจำนวนเต็ม 4 พันล้าน (สมมติว่าเป็นจำนวนเต็ม 2 ^ 32) ลงใน BitSet ที่ 8 ต่อไบต์คือ 2 ^ 32/2 ^ 3 = 2 ^ 29 = ประมาณ 0.5 Gb

ในการเพิ่มรายละเอียดเพิ่มเติมทุกครั้งที่คุณอ่านตัวเลขให้ตั้งค่าบิตที่เกี่ยวข้องใน BitSet จากนั้นทำผ่าน BitSet เพื่อค้นหาหมายเลขแรกที่ไม่มีอยู่ ในความเป็นจริงคุณสามารถทำเช่นนี้ได้อย่างมีประสิทธิภาพโดยการเลือกหมายเลขสุ่มและทดสอบซ้ำถ้ามี

จริง ๆ แล้ว BitSet.nextClearBit (0) จะบอกคุณบิตแรกที่ไม่ได้ตั้งค่า

เมื่อดูที่ BitSet API ดูเหมือนว่ารองรับเพียง 0..MAX_INT ดังนั้นคุณอาจต้องใช้ 2 BitSets หนึ่งชุดสำหรับหมายเลข + และหนึ่งหมายเลขสำหรับรับ แต่ความต้องการหน่วยความจำไม่เปลี่ยนแปลง

หากไม่มีการ จำกัด ขนาดวิธีที่เร็วที่สุดคือการใช้ความยาวของไฟล์และสร้างความยาวของไฟล์ + ตัวเลขสุ่ม 1 จำนวน (หรือเพียงแค่ "11111 ... " s) ข้อได้เปรียบ: คุณไม่จำเป็นต้องอ่านไฟล์และคุณสามารถลดการใช้หน่วยความจำให้เกือบเป็นศูนย์ได้ ข้อเสีย: คุณจะพิมพ์ตัวเลขเป็นพันล้าน

อย่างไรก็ตามหากปัจจัยเดียวคือการลดการใช้หน่วยความจำและไม่มีสิ่งอื่นใดที่สำคัญนี่จะเป็นทางออกที่ดีที่สุด มันอาจทำให้คุณได้รับรางวัล "การละเมิดกฎที่เลวร้ายที่สุด"

หากเราสมมติว่าช่วงของตัวเลขจะเป็น 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 ถ้าหมายเลขเดียวหายไปแบบเอกสิทธิ์เฉพาะบุคคลหรือจะให้ผลจำนวนที่เมื่อเอกสิทธิ์ ored ด้วยหมายเลขที่ขาดหายไปจะทำให้ 0 ดังนั้นหมายเลขที่ขาดหายไปและหมายเลขพิเศษที่ได้รับนั้นจะเหมือนกันทุกประการ หากเราลบ 2 ผลที่ได้คือ xor10 (หรือ 2)

ทีนี้ลองดู n + 1 ขอเรียกจำนวนครั้งในแต่ละบิตตั้งอยู่ในn, และจำนวนครั้งในแต่ละบิตตั้งอยู่ในx n+1 yค่าของyจะเท่ากับy = x * 2เนื่องจากมีxองค์ประกอบที่มีการn+1ตั้งค่าบิตเป็น 0 และxองค์ประกอบที่มีการn+1ตั้งค่าบิตเป็น 1 และเนื่องจาก2xจะเสมอกันเสมอn+1จะมีการตั้งค่าแต่ละบิตเป็นจำนวนครั้ง

ดังนั้นตั้งแต่n=2ผลงานและผลงานวิธีการแฮคเกอร์จะทำงานทุกค่าของn+1n>=2

อัลกอริทึมสำหรับช่วง 0 ตาม

มันค่อนข้างง่าย มันใช้หน่วยความจำ 2 * n บิตดังนั้นสำหรับช่วง <= 32, 2 32 บิตจำนวนเต็มจะทำงาน (ละเว้นหน่วยความจำใด ๆ ที่ใช้โดย file descriptor) และมันทำให้ไฟล์เดียวผ่าน

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 ถึงจำนวนของค่าที่ไม่เรียงลำดับเพื่อดูแลค่าที่หายไป (นับหนึ่งค่าที่หายไป) จากนั้นให้ xoring ค่า n เพิ่มขึ้นทีละ 1 ครั้งจนกว่า n คือกำลังของ 2 ผลลัพธ์จะถูกนำกลับไปใช้ฐานเดิมอีกครั้ง เสร็จสิ้น

นี่คืออัลกอริทึมที่ฉันทดสอบใน 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;

คำถามเคล็ดลับเว้นแต่จะได้รับการยกมาอย่างไม่เหมาะสม แค่อ่านผ่านไฟล์ครั้งเดียวที่จะได้รับจำนวนเต็มสูงสุดและผลตอบแทนnn+1

แน่นอนคุณต้องมีแผนสำรองในกรณีที่n+1ทำให้เกิดการล้นจำนวนเต็ม

ตรวจสอบขนาดของไฟล์อินพุตจากนั้นเอาท์พุทตัวเลขใด ๆที่มีขนาดใหญ่เกินไปที่จะแสดงโดยไฟล์ที่มีขนาดนั้น นี่อาจเป็นเคล็ดลับราคาถูก แต่มันเป็นทางออกที่สร้างสรรค์สำหรับปัญหาการสัมภาษณ์มันแอบเลี่ยงปัญหาหน่วยความจำอย่างเป็นระเบียบ

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)เนื่องจากคุณรู้ว่ามี (4 พันล้าน -1) จำนวนเต็มอื่น ๆ ในไฟล์และแม้จะมีการบีบอัดข้อมูลที่สมบูรณ์แบบ หนึ่งบิตแต่ละ

• วิธีที่ง่ายที่สุดคือการหาจำนวนขั้นต่ำในไฟล์และส่งคืน 1 น้อยกว่านั้น สิ่งนี้ใช้ที่เก็บข้อมูล O (1) และเวลา O (n) สำหรับไฟล์ที่มีตัวเลข n อย่างไรก็ตามมันจะล้มเหลวถ้าช่วงของจำนวนถูก จำกัด ซึ่งอาจทำให้ min-1 ไม่ใช่ -a-number

• วิธีการที่เรียบง่ายและตรงไปตรงมาของการใช้บิตแมปได้ถูกกล่าวถึงแล้ว วิธีนั้นใช้เวลา O (n) และการเก็บข้อมูล

• นอกจากนี้ยังมีการกล่าวถึงวิธี 2-pass พร้อมการนับจำนวน 2 ^ 16 มันอ่านจำนวนเต็ม 2 * n ดังนั้นใช้เวลา O (n) และที่เก็บข้อมูล O (1) แต่ไม่สามารถจัดการชุดข้อมูลที่มีตัวเลขมากกว่า 2 ^ 16 อย่างไรก็ตามมันขยายได้อย่างง่ายดายไปยัง (เช่น) 2 ^ 60 จำนวนเต็ม 64- บิต 64 บิตโดยวิ่ง 4 รอบแทน 2 และปรับใช้หน่วยความจำขนาดเล็กได้อย่างง่ายดายโดยใช้ถังขยะจำนวนมากเท่าที่พอดีกับหน่วยความจำและเพิ่มจำนวนรอบ เวลารันไทม์ของเคสใดจะไม่ใช่ O (n) อีกต่อไป แต่จะเป็น O (n * log n)

• วิธีการของ XOR'ing ตัวเลขทั้งหมดเข้าด้วยกันกล่าวถึงโดย rfrankel และที่ความยาวโดย ircmaxell ตอบคำถามที่ถามในstackoverflow # 35185 ตามที่ ltn100 ชี้ให้เห็น มันใช้ที่เก็บข้อมูล O (1) และเวลาทำงานของ O (n) หากในขณะนี้เราถือว่าจำนวนเต็ม 32 บิต XOR มีความน่าจะเป็น 7% ในการสร้างตัวเลขที่แตกต่าง เหตุผล: เนื่องจากตัวเลขที่แตกต่างกัน ~ 4G ที่ XOR จะรวมกันและสามารถ 300M ไม่ได้อยู่ในไฟล์จำนวนบิตที่ตั้งค่าในแต่ละตำแหน่งบิตมีโอกาสเท่ากันที่จะเป็นเลขคี่หรือคู่ ดังนั้นตัวเลข 2 ^ 32 จึงมีความเป็นไปได้ที่จะเกิดขึ้นอย่างเท่าเทียมกันเนื่องจากผลลัพธ์ XOR ซึ่ง 93% อยู่ในไฟล์แล้ว โปรดทราบว่าหากตัวเลขในไฟล์ไม่แตกต่างกันทั้งหมดความน่าจะเป็นของความสำเร็จของวิธี XOR จะเพิ่มขึ้น

ด้วยเหตุผลบางอย่างทันทีที่ฉันอ่านปัญหานี้ฉันก็นึกถึงเส้นทแยงมุม ฉันสมมติว่าเป็นจำนวนเต็มขนาดใหญ่โดยพลการ

อ่านหมายเลขแรก ปล่อยแผ่นไว้กับศูนย์บิตจนกว่าคุณจะมี 4 พันล้านบิต ถ้าบิตแรก (ลำดับสูง) เป็น 0 เอาต์พุต 1; เอาท์พุทอื่น 0 (คุณไม่จำเป็นต้องกดซ้าย: คุณแค่เอาท์พุท 1 ถ้าจำนวนบิตไม่เพียงพอ) ทำแบบเดียวกันกับตัวเลขที่สองยกเว้นใช้บิตที่สอง ดำเนินการต่อผ่านไฟล์ด้วยวิธีนี้ คุณจะส่งออกทีละ 4 พันล้านบิตทีละบิตและหมายเลขนั้นจะไม่เหมือนกับในไฟล์ หลักฐาน: มันเหมือนกับหมายเลข n แล้วพวกเขาก็จะเห็นด้วยกับบิตที่ n แต่พวกเขาไม่ได้สร้าง

คุณสามารถใช้ค่าสถานะบิตเพื่อทำเครื่องหมายว่ามีจำนวนเต็มหรือไม่

หลังจากสำรวจไฟล์ทั้งหมดแล้วให้สแกนแต่ละบิตเพื่อดูว่ามีจำนวนหรือไม่

สมมติว่าแต่ละจำนวนเต็มคือ 32 บิตพวกเขาจะพอดีใน RAM 1 GB หากทำการตั้งค่าสถานะบิต

ตัดพื้นที่สีขาวและอักขระที่ไม่ใช่ตัวเลขออกจากไฟล์และต่อท้าย 1. ไฟล์ของคุณมีหมายเลขเดียวที่ไม่อยู่ในไฟล์ต้นฉบับ

จาก Reddit โดย Carbonetc

นี่เป็นอีกวิธีการแก้ปัญหาที่ง่ายมากซึ่งส่วนใหญ่ใช้เวลานานในการรัน แต่ใช้หน่วยความจำน้อยมาก

ปล่อยให้จำนวนเต็มที่เป็นไปได้ทั้งหมดอยู่ในช่วงจากint_minถึงint_maxและ bool isNotInFile(integer)ฟังก์ชันที่คืนค่าเป็นจริงหากไฟล์ไม่มีจำนวนเต็มและ false อย่างอื่น (โดยการเปรียบเทียบจำนวนเต็มนั้นกับจำนวนเต็มแต่ละตัวในไฟล์)

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

สำหรับข้อ จำกัด หน่วยความจำ 10 MB:

1. แปลงตัวเลขเป็นการแทนแบบไบนารี่
2. สร้างต้นไม้ไบนารีที่ left = 0 และ right = 1
3. แทรกแต่ละหมายเลขในต้นไม้โดยใช้การแทนเลขฐานสอง
4. ถ้าใส่หมายเลขแล้วใบไม้จะถูกสร้างขึ้นแล้ว

เมื่อเสร็จแล้วเพียงนำเส้นทางที่ไม่ได้สร้างมาก่อนเพื่อสร้างหมายเลขที่ร้องขอ

4 พันล้านหมายเลข = 2 ^ 32 หมายถึง 10 MB อาจไม่เพียงพอ

แก้ไข

การเพิ่มประสิทธิภาพเป็นไปได้ถ้าสองปลายใบไม้ถูกสร้างขึ้นและมีพาเรนต์ร่วมจากนั้นก็สามารถลบออกได้และพาเรนต์ถูกตั้งค่าสถานะว่าไม่ใช่โซลูชัน สิ่งนี้จะตัดกิ่งไม้และลดความต้องการหน่วยความจำ

แก้ไขครั้งที่สอง

ไม่จำเป็นต้องสร้างต้นไม้โดยสมบูรณ์เช่นกัน คุณจะต้องสร้างกิ่งก้านสาขาลึกถ้าตัวเลขใกล้เคียงกัน หากเราตัดกิ่งไม้ด้วยวิธีนี้อาจใช้งานได้จริง

ฉันจะตอบรุ่น 1 GB:

มีข้อมูลไม่เพียงพอในคำถามดังนั้นฉันจะระบุสมมติฐานบางอย่างก่อน:

จำนวนเต็มคือ 32 บิตด้วยช่วง -2,147,483,648 ถึง 2,147,483,647

หลอกรหัส:

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

ตราบใดที่เราทำคำตอบที่สร้างสรรค์นี่ก็เป็นอีกคำตอบหนึ่ง

ใช้โปรแกรมเรียงลำดับภายนอกเพื่อเรียงลำดับไฟล์อินพุตเป็นตัวเลข วิธีนี้จะใช้งานได้ตามจำนวนหน่วยความจำที่คุณมี (จะใช้ที่เก็บไฟล์หากจำเป็น) อ่านไฟล์ที่เรียงแล้วและส่งออกหมายเลขแรกที่ขาดหายไป

การกำจัดบิต

วิธีหนึ่งคือการกำจัดบิตอย่างไรก็ตามสิ่งนี้อาจไม่ได้ผลลัพธ์จริง ๆ (โอกาสที่มันจะไม่เกิดขึ้น) Psuedocode:

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- บิตโดยไม่มีการทำซ้ำดังนั้นจึงหายไปเพียงหนึ่งเดียวนั่นคือวิธีแก้ปัญหาอย่างง่าย

เริ่มต้นผลรวมสะสมที่ศูนย์และสำหรับแต่ละจำนวนเต็มในไฟล์ให้เพิ่มจำนวนเต็มนั้นด้วยโอเวอร์โฟลว์ 32- บิต (อย่างมีประสิทธิภาพ, runningTotal = (runningTotal + nextInteger)% 4294967296) เมื่อเสร็จแล้วให้เพิ่ม 4294967296/2 ในผลรวมการรันอีกครั้งด้วยการโอเวอร์โฟลว์แบบ 32 บิต ลบออกจาก 4294967296 และผลลัพธ์คือจำนวนเต็มที่ขาดหายไป

ปัญหา "จำนวนเต็มที่หายไปเพียงหนึ่งเดียว" สามารถแก้ไขได้ด้วยการเรียกใช้เพียงครั้งเดียวและ RAM 64 บิตเท่านั้นที่ทุ่มเทให้กับข้อมูล (32 สำหรับผลรวมทั้งหมดที่กำลังทำงาน 32 เพื่ออ่านในจำนวนเต็มถัดไป)

ผลที่ตามมา: ข้อกำหนดทั่วไปที่มากขึ้นนั้นง่ายมากที่จะจับคู่หากเราไม่ได้กังวลว่าจะต้องมีผลลัพธ์จำนวนเต็มกี่บิต เราเพิ่งสร้างจำนวนเต็มที่มากพอที่จะไม่สามารถอยู่ในไฟล์ที่เราได้รับ อีกครั้งนี้ใช้ 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(ประมาณ 1 ใน 4 พันล้าน) คุณจะถูกต้องเกือบตลอดเวลา!

(ล้อเล่น ... เป็นแบบ)