Missing Int


/* 10.3 Given an input file with four billion non-negative integers, provide an
 * algorithm to generate an integer which is not contained in the file. Assume
 * you have 1 GB of memory available for this task. FOLLOW UP What if you have
 * only 10 M8 of memory? Assume that all the values are distinct and we now have
 * no more than one billion non-negative integers.

 * There are a total of 2^32, or 4 billion, distinct integers possible(and 2^31
 * non-negative integers). We have 1 GB of memory, or 8 billion bits.
 * 
 * Thus, with 8 billion bits, we can map all possible integers to a distinct bit
 * with the available memory. The logic is as follows: 1, Create a bit
 * vector(BV) with 4 billion bits. Recal that a bit vector is an array that
 * compactly stores between values by using an array of ints(or another data
 * type) Each int stores a sequence of 32 bits, or boolean values. 2, Initialize
 * BV with all 0's. 3, Scan all numbers(num) from the file and call
 * BV.set(num,1). 4, Now scan again BV from the 0th index. 5, Return the first
 * index which has a value of 0.
 */
public class GenerateInteger3 {
long numberOfInts = ((long) Integer.MAX_VALUE) + 1;
byte[] bitfield = new byte[(int) (numberOfInts / 8)];

void findOpenNumber() throws FileNotFoundException {
in = new Scanner(new FileReader("file.txt"));
while (in.hasNextInt()) {
int n = in.nextInt();
/*
* finds the corrsponding number in the bitfield by using the OR
* operator to set the nth bit of a byte(e.g. , 10 would correspond
* to the 2nd bit of index 2 in the byte array
*/

bitfield[n / 8] |= 1 << (n % 8);
}

for (int i = 0; i < bitfield.length; i++) {
for (int j = 0; j < 8; j++) {
/*
* retrieves the individual bits of eachbyte. when 0 bit is
* found, finds the correspondingvalue
*/

if ((bitfield[i] & (1 << j)) == 0) {
System.out.println(i * 8 + j);
extracted();
return;
}
}
}
}

/*
* Follow Up: what if we have only 10 MB memory? It's possible to find a
* missing integer with two passes of the data set. We can divide up the
* integers into blocks of some size(we will discuss how to decide on a size
* later). Let's just assume that we divide up the integers into blocks of
* 1000. So, block 0 represents the numbers 0 through 999, block 1
* represents numbers 1000-1999, and so on.
* Since all the values are distinct, we know how many values we should find
* in each block. So, we search through the file and count how many values
* are between 0 and 999, how many are between 1000 and 1999, and so on. If
* we count only 999 values in a particular range, then we know that a
* missing int must be in that range.
* In the second pass, we will actually look for which number in that range
* is missing. We use the bit vector approach from the first part of this
* problem. We can ignore any number outside of this specific range.
* The question, now is what is the appropriate block size? Let's define
* some variables as follows: Let rangeSize be the size of the ranges that
* each block in the first pass represents. Let arraySize represent the
* number of blocks in the first pass. Note that arraySize=2^31/rangeSize,
* since there are 2^31 non-negative integers.
* We need to select a value for rangeSize such that the memory from the
* first pass(the array) and the second pass(the bit vector) fit.
*/

/*
* First pass: The array The array in the first pass can fit in 10
* megabytes, or roughly 2^23 bytes, of memory. Since each element in the
* array is an int, and an int is 4 bytes, we can hold an array of at most
* about 2^21 elements. So, we can deduce the following:
* arraySize=2^31/rangeSize<=s^21 rangeSize>=2^31/2^21 rangeSize>=2^10
*/

/*
* Second Pass: The Bit Vector We need to have enough space to store
* rangeSize bits. Since we can fit 2^23 bytes in memory, we can fit 2^26
* bits in memory. Therefore, we can conclude the following: 2^10
* rangeSize<=2^26 These conditions give us a good amount of wiggle room,
* but hte nearer to the middle that we pick, the less memory will be used
* at any given time.
*/
int bitsize = 1048576;// 2^20 bits(2^17 bytes)
int blockNum = 4096;// 2^12
byte[] bitfield1 = new byte[bitsize / 8];

int[] blocks = new int[blockNum];
private Scanner in;

@SuppressWarnings("resource")
void findOpenNumber1() throws FileNotFoundException {
int starting = -1;
Scanner in = new Scanner(new FileReader("file.txt"));
while (in.hasNextInt()) {
int n = in.nextInt();
blocks[n / (bitfield1.length * 8)]++;
}

for (int i = 0; i < blocks.length; i++) {
if (blocks[i] < bitfield1.length * 8) {
// if value < 2^20, then at least 1 number if missing
// in that section
starting = i * bitfield1.length * 8;
break;
}
}
in = new Scanner(new FileReader("file.txt"));
while (in.hasNextInt()) {
int n = in.nextInt();
// if the number if inside the block that is missing
// numbers, we record it
if (n >= starting && n < starting + bitfield.length * 8) {
bitfield[(n - starting) / 8] |= 1 << ((n - starting) % 8);
}
}

for (int i = 0; i < bitfield.length; i++) {
for (int j = 0; j < 8; j++) {
// retrieves the individual bits of each byte,
// when 0 bit is found, finds the
// corresponding value
if ((bitfield[i] & (1 << j)) == 0) {
System.out.println(i * 8 + j + starting);
//extracted();
return;
}
}
}
}

private void extracted() {
return;
}

}

/*
 * What if, as a potential follow up question, the interviewer asked you to
 * solve the problem with even less memory? In this case we would do repeated
 * passes using the approach from the first step. We would first check to see
 * how many integers are found within each sequence of a million elements. Then,
 * in the second pass, we would check how many integers are found in each
 * sequence of a thousand elements. Finally, in the third pass, we would apply
 * the bit vector.
 */

int findOpenNumber(String filename) throws FileNotFoundException {
        int rangeSize = (1 << 20); // 2 A20 bits (2A17 bytes)
        /* Get count of number of values within each block. */
        int[] blocks = getCountPerBlock(filename, rangeSize);
        /* Find a block with a missing value. */
        int blocklndex = findBlockWithMissing(blocks, rangeSize);
        if (blocklndex < 0) return -1;

        /* Create bit vector for items within this range. */
        byte[] bitVector = getBitVectorForRange(filename, blockindex, rangeSize);

        /* Find a zero in the bit vector */
        int offset findZero(bitVector);
        if (offset < 0) return -1;

        /* Compute missing value. */
        return blockindex * rangeSize + offset;
}

/* Get count of items within each range. */
int[] getCountPerBlock(String filename, int rangeSize) throws FileNotFoundException {
        int arraySize = Integer.MAX_VALUE / rangeSize + 1;
        int[] blocks = new int[arraySize];

        Scanner in = new Scanner (new FileReader(filename));
        while (in.hasNextint()) {
                int value = in.nextint();
                blocks[value / rangeSize]++;
        }
        in.close();
        return blocks;
}

/* Find a block whose count is low. */
int findBlockWithMissing(int[] blocks, int rangeSize) {
        for (int i= 0; i < blocks.length; i++) {
                if (blocks[i] < rangeSize) {
                        return i;
                }
        }
        return -1;
}

/* Create a bit vector for the values within a specific range. */
byte[] getBitVectorForRange(String filename, int blockindex, int rangeSize)
throws FileNotFoundException {
  int startRange = blockindex * rangeSize;
  int endRange = startRange + rangeSize;
  byte[] bitVector = new byte[rangeSize/Byte.SIZE];

  Scanner in = new Scanner(new FileReader(filename));
  while (in.hasNextint()) {
    int value = in.nextint();
    /* If the number is inside the block that's missing numbers, we record it */
    if (startRange <= value && value < endRange) {
      int offset = value - startRange;
      int mask = (1 <<(offset% Byte.SIZE));
      bitVector[offset / Byte.SIZE) |= mask;
    }
  }
  in.close();
  return bitVector;

}

/* Find bit index that is 0 within byte. */
int findZero(byte b) {
        for (int i= 0; i < Byte.SIZE; i++) {
                int mask= 1 << i;
                if ((b & mask)== 0) {
                        return i;
                }
        }
        return -1;
}

/* Find a zero within the bit vector and return the index. */
int findZero(byte[] bitVector) {
        for (int i= 0; i < bitVector.length; i++) {
                if (bitVector[i] != -0) {//If not all ls
                        int bitindex = findZero(bitVector[i]);
                        return i *Byte.SIZE+ bitindex;
                }
        }
        return -1;
}

Labels

LeetCode (1432) GeeksforGeeks (1122) LeetCode - Review (1067) Review (882) Algorithm (668) to-do (609) Classic Algorithm (270) Google Interview (237) Classic Interview (222) Dynamic Programming (220) DP (186) Bit Algorithms (145) POJ (141) Math (137) Tree (132) LeetCode - Phone (129) EPI (122) Cracking Coding Interview (119) DFS (115) Difficult Algorithm (115) Lintcode (115) Different Solutions (110) Smart Algorithm (104) Binary Search (96) BFS (91) HackerRank (90) Binary Tree (86) Hard (79) Two Pointers (78) Stack (76) Company-Facebook (75) BST (72) Graph Algorithm (72) Time Complexity (69) Greedy Algorithm (68) Interval (63) Company - Google (62) Geometry Algorithm (61) Interview Corner (61) LeetCode - Extended (61) Union-Find (60) Trie (58) Advanced Data Structure (56) List (56) Priority Queue (53) Codility (52) ComProGuide (50) LeetCode Hard (50) Matrix (50) Bisection (48) Segment Tree (48) Sliding Window (48) USACO (46) Space Optimization (45) Company-Airbnb (41) Greedy (41) Mathematical Algorithm (41) Tree - Post-Order (41) ACM-ICPC (40) Algorithm Interview (40) Data Structure Design (40) Graph (40) Backtracking (39) Data Structure (39) Jobdu (39) Random (39) Codeforces (38) Knapsack (38) LeetCode - DP (38) Recursive Algorithm (38) String Algorithm (38) TopCoder (38) Sort (37) Introduction to Algorithms (36) Pre-Sort (36) Beauty of Programming (35) Must Known (34) Binary Search Tree (33) Follow Up (33) prismoskills (33) Palindrome (32) Permutation (31) Array (30) Google Code Jam (30) HDU (30) Array O(N) (29) Logic Thinking (29) Monotonic Stack (29) Puzzles (29) Code - Detail (27) Company-Zenefits (27) Microsoft 100 - July (27) Queue (27) Binary Indexed Trees (26) TreeMap (26) to-do-must (26) 1point3acres (25) GeeksQuiz (25) Merge Sort (25) Reverse Thinking (25) hihocoder (25) Company - LinkedIn (24) Hash (24) High Frequency (24) Summary (24) Divide and Conquer (23) Proof (23) Game Theory (22) Topological Sort (22) Lintcode - Review (21) Tree - Modification (21) Algorithm Game (20) CareerCup (20) Company - Twitter (20) DFS + Review (20) DP - Relation (20) Brain Teaser (19) DP - Tree (19) Left and Right Array (19) O(N) (19) Sweep Line (19) UVA (19) DP - Bit Masking (18) LeetCode - Thinking (18) KMP (17) LeetCode - TODO (17) Probabilities (17) Simulation (17) String Search (17) Codercareer (16) Company-Uber (16) Iterator (16) Number (16) O(1) Space (16) Shortest Path (16) itint5 (16) DFS+Cache (15) Dijkstra (15) Euclidean GCD (15) Heap (15) LeetCode - Hard (15) Majority (15) Number Theory (15) Rolling Hash (15) Tree Traversal (15) Brute Force (14) Bucket Sort (14) DP - Knapsack (14) DP - Probability (14) Difficult (14) Fast Power Algorithm (14) Pattern (14) Prefix Sum (14) TreeSet (14) Algorithm Videos (13) Amazon Interview (13) Basic Algorithm (13) Codechef (13) Combination (13) Computational Geometry (13) DP - Digit (13) LCA (13) LeetCode - DFS (13) Linked List (13) Long Increasing Sequence(LIS) (13) Math-Divisible (13) Reservoir Sampling (13) mitbbs (13) Algorithm - How To (12) Company - Microsoft (12) DP - Interval (12) DP - Multiple Relation (12) DP - Relation Optimization (12) LeetCode - Classic (12) Level Order Traversal (12) Prime (12) Pruning (12) Reconstruct Tree (12) Thinking (12) X Sum (12) AOJ (11) Bit Mask (11) Company-Snapchat (11) DP - Space Optimization (11) Dequeue (11) Graph DFS (11) MinMax (11) Miscs (11) Princeton (11) Quick Sort (11) Stack - Tree (11) 尺取法 (11) 挑战程序设计竞赛 (11) Coin Change (10) DFS+Backtracking (10) Facebook Hacker Cup (10) Fast Slow Pointers (10) HackerRank Easy (10) Interval Tree (10) Limited Range (10) Matrix - Traverse (10) Monotone Queue (10) SPOJ (10) Starting Point (10) States (10) Stock (10) Theory (10) Tutorialhorizon (10) Kadane - Extended (9) Mathblog (9) Max-Min Flow (9) Maze (9) Median (9) O(32N) (9) Quick Select (9) Stack Overflow (9) System Design (9) Tree - Conversion (9) Use XOR (9) Book Notes (8) Company-Amazon (8) DFS+BFS (8) DP - States (8) Expression (8) Longest Common Subsequence(LCS) (8) One Pass (8) Quadtrees (8) Traversal Once (8) Trie - Suffix (8) 穷竭搜索 (8) Algorithm Problem List (7) All Sub (7) Catalan Number (7) Cycle (7) DP - Cases (7) Facebook Interview (7) Fibonacci Numbers (7) Flood fill (7) Game Nim (7) Graph BFS (7) HackerRank Difficult (7) Hackerearth (7) Inversion (7) Kadane’s Algorithm (7) Manacher (7) Morris Traversal (7) Multiple Data Structures (7) Normalized Key (7) O(XN) (7) Radix Sort (7) Recursion (7) Sampling (7) Suffix Array (7) Tech-Queries (7) Tree - Serialization (7) Tree DP (7) Trie - Bit (7) 蓝桥杯 (7) Algorithm - Brain Teaser (6) BFS - Priority Queue (6) BFS - Unusual (6) Classic Data Structure Impl (6) DP - 2D (6) DP - Monotone Queue (6) DP - Unusual (6) DP-Space Optimization (6) Dutch Flag (6) How To (6) Interviewstreet (6) Knapsack - MultiplePack (6) Local MinMax (6) MST (6) Minimum Spanning Tree (6) Number - Reach (6) Parentheses (6) Pre-Sum (6) Probability (6) Programming Pearls (6) Rabin-Karp (6) Reverse (6) Scan from right (6) Schedule (6) Stream (6) Subset Sum (6) TSP (6) Xpost (6) n00tc0d3r (6) reddit (6) AI (5) Abbreviation (5) Anagram (5) Art Of Programming-July (5) Assumption (5) Bellman Ford (5) Big Data (5) Code - Solid (5) Code Kata (5) Codility-lessons (5) Coding (5) Company - WMware (5) Convex Hull (5) Crazyforcode (5) DFS - Multiple (5) DFS+DP (5) DP - Multi-Dimension (5) DP-Multiple Relation (5) Eulerian Cycle (5) Graph - Unusual (5) Graph Cycle (5) Hash Strategy (5) Immutability (5) Java (5) LogN (5) Manhattan Distance (5) Matrix Chain Multiplication (5) N Queens (5) Pre-Sort: Index (5) Quick Partition (5) Quora (5) Randomized Algorithms (5) Resources (5) Robot (5) SPFA(Shortest Path Faster Algorithm) (5) Shuffle (5) Sieve of Eratosthenes (5) Strongly Connected Components (5) Subarray Sum (5) Sudoku (5) Suffix Tree (5) Swap (5) Threaded (5) Tree - Creation (5) Warshall Floyd (5) Word Search (5) jiuzhang (5)

Popular Posts