hashtable-interview question

Author: rohan-paul

.gitignore

@@ -40,15 +40,15 @@ validation-report.json
 
 # Folders to ignore
 node_modules
+Project-Note-PAUL
 
 # Ignore all logfiles and tempfiles.
 !/log/.keep
 /tmp
 /.gems
 
-testing-code-3.js
-testing-scribling-code.js
-testing-code-1.js
-testing-4.js
-test-5.js
-Cracking-The-Coding-Interview-Note-Gitignore-IT.odt
+random-code-1.js
+random-code-2.js
+random-code-3.js
+random-code-4.js
+performance-1.js

Hash_Table/generic_hash_table_implementation.js

@@ -6,9 +6,15 @@ class HashTable {
     this.value = [];
   }
 
-  /* The Hash-function takes a key and converts it to a number which will be the index at which to store it. In my hash() function below, I am computing a hash value by summing the ASCII value of each character of the string (the argument passed-in) using the JavaScript function charCodeAt() to return a character’s ASCII value after multiplying the ASCII value by a multiplier H, which in this case, is an odd prime 37. And the reason to choose 37 being, by some empirical research, if we take over 50,000 English words (formed as the union of the word lists provided in two variants of Unix), using the constants 31, 33, 37, 39, and 41 will produce less than 7 collisions in each case, while creating a hasing function.
+/* The Hash-function takes a key and converts it to a number which will be the index at which to store it. In my hash() function below, I am computing a hash value by summing the ASCII value of each character of the string (the argument passed-in) using the JavaScript function charCodeAt() to return a character’s ASCII value after multiplying the ASCII value by a multiplier H, which in this case, is an odd prime 37. And the reason to choose 37 being, by some empirical research, if we take over 50,000 English words (formed as the union of the word lists provided in two variants of Unix), using the constants 31, 33, 37, 39, and 41 will produce less than 7 collisions in each case, while creating a hashing function.
 
-Note that this remainder method (modulo arithmetic) will typically be present in some form in all hash functions, since the result must be in the range of slot names. In the below cae (total %= this.table.length). Because, the hash function will turn its passed-in argument and return an integer in the range of slot names, between 0 and m-1. */
+Note that this remainder method (modulo arithmetic) will typically be present in some form in all hash functions, since the result must be in the range of slot names. In the below cae (total %= this.table.length). Because, the hash function will turn its passed-in argument and return an integer in the range of slot names, between 0 and m-1.
+A perfect hash can be created if the number and construction of the keys are known factors. For example, a perfect hash for a list of ten product numbers that are sure to differ in their 4th and 5th digits can be easily constructed like so,
+unsigned hash(unsigned pid)
+{
+    return pid / 1000 % 100;
+}
+*/
 
   // the first implementation of my hash table
   hash(string) {
@@ -25,7 +31,7 @@ Note that this remainder method (modulo arithmetic) will typically be present in
     return parseInt(total);
   }
 
-  // function to console.log the distribution of the key-values. They key being the ones that were generated by the Hash Function after hashing and values what was passed in the hashing functoin as the arguments.
+  // function to console.log the distribution of the key-values. They key being the ones that were generated by the Hash Function after hashing and values what was passed in the hashing function as the arguments.
   showDistro() {
     for (const key in this.table) {
       if (this.table[key] !== undefined) {

Hash_Table/hashmap_interview_question.js

@@ -0,0 +1,91 @@
+/*Implement a HashMap class without using JavaScript’s built-in objects ({}) or Maps. You are provided a hash() function that takes a string and returns a number (the numbers are mostly unique, but sometimes two different strings will return the same number):
+
+function hash (string) {
+  return string
+    .split('')
+    .reduce((a, b) => ((a << 5) + a) + b.charCodeAt(0), 5381)
+}
+Your HashMap should support just 2 methods, get, set:
+
+let map = new HashMap
+map.set('abc', 123)                   // undefined
+map.set('foo', 'bar')                 // undefined
+map.set('foo', 'baz')                 // undefined
+map.get('abc')                        // 123
+map.get('foo')                        // 'baz'
+map.get('def')                        // undefined*/
+
+// hash function (provided in the problem)
+
+class HashMap {
+	constructor() {
+		this.data = [] 
+		/* Create an empty array whose each index position is a slot or bucket. So this bucket is an array of arrays. So, I will access a value in bucket, which is the inner-array
+		bucket[indexInBucket][i]    */
+	}
+
+	// This hash function was already given in the original problem
+	hash(string) {
+		return string
+			.split('')
+			.reduce((a, b) => ((a << 5) + a) + b.charCodeAt(0), 5381)
+	}
+
+	get(key) {
+		let index = hash(key); // First I have to hash the given key to get the index postion in the hashtable
+		let bucket = this.data[index];
+		if (!bucket) {
+			return undefined;
+		}
+
+		for ([k, v] of bucket) {
+			if (key = k) {
+				return v;
+			}
+		}
+	}
+
+	/*Function for storing a value in the Hash. In this the "key" is the non-hashed version of index position of the HashTable. So, I have to first get it hashed to create the actual key of the hashTable with which to store the value in the HashTable.
+	*/
+	set(key, value) {
+		let index = hash(key);
+
+		// If the hashed-key does not exist yet then create an empty array with that hashed-key
+		if(!this.data[index]) {
+			this.data[index] = [];
+		}
+
+		/*"bucket" is the slot or bucket at which I will store the passed-in "value" argument. */
+		let bucket = this.data[index];
+		let indexInBucket = 0; // Initialize the first index no to be searched in bucket with '0'
+
+		/*Now before storing the value at the first empty index position that is found >> 
+		Search for the bucket index position starting from zero. Implement collision-resolution. 
+		So, first check if there's any value stored at all, in bucket[indexInBucket] >> If true, then check, if this specific key is the one that was assigned to store that value.
+		*/
+		while (bucket[indexInBucket]) {
+			if(bucket[indexInBucket] == key) {
+				break
+			}
+			indexInBucket++
+		}
+		// And after I have checked for No-collision, store the value. Note that this code for storing is outside the value of the while loop.
+		bucket[indexInBucket] = [key, value];
+	}
+}
+
+// Now test with some key-values - 
+// ISSUES - I have to implemnt this test following the best practice file structure.
+
+/*import { test } from 'ava'
+
+test('HashMap', t => {
+  let map = new HashMap
+  map.set('abc', 123)
+  map.set('foo', 'bar')
+  map.set('foo', 'baz')
+  t.is(map.get('abc'), 123)
+  t.is(map.get('foo'), 'baz')
+  t.is(map.get('def'), undefined)
+})*/
+