hash maps

Author: amejiarosario

.vscode/launch.json

@@ -0,0 +1,14 @@
+{
+  // Use IntelliSense to learn about possible attributes.
+  // Hover to view descriptions of existing attributes.
+  // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "type": "node",
+      "request": "launch",
+      "name": "HashMap",
+      "program": "${workspaceFolder}/src/runtimes/linear/hash-map.js"
+    }
+  ]
+}

src/runtimes/linear/find-max.js

@@ -0,0 +1,20 @@
+function findMax(n) {
+  let max;
+  let counter = 0;
+
+  for (let i = 0; i < n.length; i++) {
+    counter++;
+    if(max === undefined || max < n[i]) {
+      max = n[i];
+    }
+  }
+
+  console.log(`n: ${n.length}, counter: ${counter}`);
+  return max;
+}
+
+const assert = require('assert');
+assert.equal(findMax([3, 1, 2]), 3);
+assert.equal(findMax([4,5,6,1,9,2,8,3,7]), 9);
+assert.equal(findMax([4,2,8,3,7,0,-1]), 8);
+

src/runtimes/linear/hash-map-1.js

@@ -0,0 +1,74 @@
+/**
+ * Hash Map data structure implementation
+ */
+class HashMap {
+
+  /**
+   * Initialize array that holds the values. Default is size 1,000
+   * @param {number} size
+   */
+  constructor(size = 2) {
+    this.array = new Array(size);
+  }
+
+  /**
+   * insert a key/value pair into the hash map
+   * @param {any} key
+   * @param {any} value
+   */
+  set(key, value) {
+    const index = this.getIndex(key);
+    if(this.array[index]) {
+      this.array[index].push({key, value});
+    } else {
+      this.array[index] = [{key, value}];
+    }
+    return this;
+  }
+
+  /**
+   * Gets the value out of the hash map
+   * @param {any} key
+   */
+  get(key) {
+    const hashIndex = this.getIndex(key);
+    for (let index = 0; index < this.array[hashIndex].length; index++) {
+      const entry = this.array[hashIndex][index];
+      if(entry.key === key) {
+        return entry.value
+      }
+    }
+  }
+
+  /**
+   * Very bad hash function that causes tons of collisions
+   * @param {any} key
+   */
+  hash(key) {
+    return key.toString().length;
+  }
+
+  /**
+   * Get the array index after applying the hash funtion to the given key
+   * @param {any} key
+   */
+  getIndex(key) {
+    const indexHash = this.hash(key);
+    const index = indexHash % this.array.length;
+    return index;
+  }
+}
+
+const assert = require('assert');
+const hashMap = new HashMap();
+
+hashMap.set('cat', 2);
+hashMap.set('rat', 7);
+hashMap.set('dog', 1);
+hashMap.set('art', 1);
+
+console.log(hashMap.array);
+
+assert.equal(hashMap.get('cat'), 2);
+assert.equal(hashMap.get('rat'), 7);
+assert.equal(hashMap.get('dog'), 1);

src/runtimes/linear/hash-map-2.js

@@ -0,0 +1,83 @@
+/**
+ * Hash Map data structure implementation
+ */
+class HashMap {
+
+  /**
+   * Initialize array that holds the values. Default is size 1,000
+   * @param {number} size
+   */
+  constructor(size = 4) {
+    this.array = new Array(size);
+  }
+
+  /**
+   * insert a key/value pair into the hash map
+   * @param {any} key
+   * @param {any} value
+   */
+  set(key, value) {
+    const index = this.getIndex(key);
+    if(this.array[index]) {
+      this.array[index].push({key, value});
+    } else {
+      this.array[index] = [{key, value}];
+    }
+    return this;
+  }
+
+  /**
+   * Gets the value out of the hash map
+   * @param {any} key
+   */
+  get(key) {
+    const hashIndex = this.getIndex(key);
+    for (let index = 0; index < this.array[hashIndex].length; index++) {
+      const entry = this.array[hashIndex][index];
+      if(entry.key === key) {
+        return entry.value
+      }
+    }
+  }
+
+  /**
+   * This hash function returns the sum of the char codes.
+   * Limitation same characters return the same code regardless of the order
+   * @param {any} key
+   */
+  hash(key) {
+    let hashValue = 0;
+    const stringKey = key.toString();
+
+    for (let index = 0; index < stringKey.length; index++) {
+      const charCode = stringKey.charCodeAt(index);
+      hashValue += charCode;
+    }
+
+    return hashValue;
+  }
+
+  /**
+   * Get the array index after applying the hash funtion to the given key
+   * @param {any} key
+   */
+  getIndex(key) {
+    const indexHash = this.hash(key);
+    const index = indexHash % this.array.length;
+    return index;
+  }
+}
+
+const assert = require('assert');
+const hashMap = new HashMap();
+
+hashMap.set('cat', 2);
+hashMap.set('rat', 7);
+hashMap.set('dog', 1);
+hashMap.set('art', 0); // <-- collision with rat
+
+console.log(hashMap.array);
+
+assert.equal(hashMap.get('cat'), 2);
+assert.equal(hashMap.get('rat'), 7);
+assert.equal(hashMap.get('dog'), 1);

src/runtimes/linear/hash-map-3.js

@@ -0,0 +1,83 @@
+/**
+ * Hash Map data structure implementation
+ */
+class HashMap {
+
+  /**
+   * Initialize array that holds the values. Default is size 1,000
+   * @param {number} size
+   */
+  constructor(size = 1000) {
+    this.array = new Array(size);
+  }
+
+  /**
+   * insert a key/value pair into the hash map
+   * @param {any} key
+   * @param {any} value
+   */
+  set(key, value) {
+    const index = this.getIndex(key);
+    if(this.array[index]) {
+      this.array[index].push({key, value});
+    } else {
+      this.array[index] = [{key, value}];
+    }
+    return this;
+  }
+
+  /**
+   * Gets the value out of the hash map
+   * @param {any} key
+   */
+  get(key) {
+    const hashIndex = this.getIndex(key);
+    const values = this.array[hashIndex];
+    for (let index = 0; index < values.length; index++) {
+      const entry = values[index];
+      if(entry.key === key) {
+        return entry.value
+      }
+    }
+  }
+
+  /**
+   * Decent hash function where each char code is added with an offset depending on the possition
+   * @param {any} key
+   */
+  hash(key) {
+    let hashValue = 0;
+    const stringKey = key.toString();
+
+    for (let index = 0; index < stringKey.length; index++) {
+      const charCode = stringKey.charCodeAt(index);
+      hashValue += charCode << (index * 8);
+    }
+
+    return hashValue;
+  }
+
+  /**
+   * Get the array index after applying the hash funtion to the given key
+   * @param {any} key
+   */
+  getIndex(key) {
+    const indexHash = this.hash(key);
+    const index = indexHash % this.array.length;
+    return index;
+  }
+}
+
+const assert = require('assert');
+const hashMap = new HashMap();
+
+hashMap.set('cat', 2);
+hashMap.set('rat', 7);
+hashMap.set('dog', 1);
+hashMap.set('art', 0); // <-- NO more collision with rat
+
+console.log(hashMap.array);
+
+assert.equal(hashMap.get('cat'), 2);
+assert.equal(hashMap.get('rat'), 7);
+assert.equal(hashMap.get('dog'), 1);

src/runtimes/linear/is-even.js

@@ -0,0 +1,11 @@
+function isEvenOrOdd(n) {
+  return n % 2 ? 'Odd' : 'Even';
+  // return n & 1 ? 'Odd' : 'Even';
+}
+
+const assert = require('assert');
+assert.equal(isEvenOrOdd(100), 'Even');
+assert.equal(isEvenOrOdd(101), 'Odd');
+assert.equal(isEvenOrOdd(24), 'Even');
+assert.equal(isEvenOrOdd(7), 'Odd');
+assert.equal(isEvenOrOdd(1), 'Odd');