added javascript TreeMap, possibleHotelBooking problem

Author: DevDelvo

TreeMap.js

@@ -0,0 +1,247 @@
+// https://github.com/somdipdey/JavaScript-implementation-of-java.util.TreeMap-Class/blob/master/treeMap.js
+module.exports = class TreeMap {
+    constructor(){
+        this.dict = {}
+    }
+    
+    /*
+    * <summary>
+    * Value get(Object key)
+    * This method returns the value to which the specified key is mapped,
+    * or null if this map contains no mapping for the key.
+    * </summary>
+    */
+    get(key) {
+        return this.dict[key];
+    };
+
+    /*
+    * <summary>
+    * boolean containsKey(Object key)
+    * This method returns true
+    * if this map contains a mapping for the specified key.
+    * </summary>
+    */
+    containsKey(key) {
+        if( this.get(key) !== undefined) {
+            return true;
+        } else {
+            return false;
+        }
+    };
+
+    /*
+    * <summary>
+    * Value put(K key, V value)
+    * This method associates the specified value with the specified key in this map.
+    * </summary>
+    */
+    put(key, value) {
+        this.dict[key] = value;
+        if(isNumber(key))
+        {
+          if(allKeysAreNumeral(this.dict)) {
+            this.dict = sortOnKeys(this.dict);
+          }
+        }
+    };
+
+    /*
+    * <summary>
+    * Value remove(Object key)
+    * This method removes the mapping for this key from this TreeMap if present.
+    * </summary>
+    */
+    remove(key) {
+        'use strict';
+        delete this.dict[key];
+    };
+
+    /*
+    * <summary>
+    * void clear()
+    * This method removes all of the mappings from this map.
+    * </summary>
+    */
+    clear() {
+        this.dict = {};
+    };
+
+
+    /*
+    * <summary>
+    * treeMap.foreach(V value)
+    * This method returns each value for each keys in the TreeMap.
+    * </summary>
+    */
+    forEach(callback){
+        var len = this.size();
+        for (i = 0; i < len; i++) {
+            var item = this.get( Object.keys(this.dict)[i] );
+            callback(item);
+        }
+    }
+
+
+    /*
+    * <summary>
+    * int size()
+    * This method returns the number of key-value mappings in this map.
+    * </summary>
+    */
+    size() {
+        return Object.keys(this.dict).length;
+    };
+
+    /*
+    * <summary>
+    * boolean isEmpty()
+    * This method returns a boolean
+    * determining whether the TreeMap is empty or not.
+    * </summary>
+    */
+    isEmpty() {
+        return Object.keys(this.dict).length == 0;
+    };
+
+
+    /*
+    * <summary>
+    * Key floorKey(K key)
+    * This method returns the greatest key less than or equal
+    * to the given key, or null if there is no such key.
+    * </summary>
+    */
+    floorKey(key) {
+      if(!isNumber(key))
+        throw "Invalid Operation: key has to be an integer value";
+
+      if(this.containsKey(key))
+        return this.get(key);
+
+      return this.floorKey(key - 1);
+    }
+
+
+    /*
+    * <summary>
+    * Key ceilingKey(K key)
+    * This method returns the least key greater than or equal
+    * to the given key, or null if there is no such key.
+    * </summary>
+    */
+    ceilingKey(key) {
+      if(!isNumber(key))
+        throw "Invalid Operation: key has to be an integer value";
+
+      if(this.containsKey(key))
+        return this.get(key);
+
+      return this.floorKey(key + 1);
+    }
+
+
+    /*
+    * <summary>
+    * Object clone()
+    * This method returns a shallow copy of this TreeMap instance.
+    * </summary>
+    */
+    clone(){
+      return this.dict;
+    }
+
+
+    /*
+    * <summary>
+    * boolean containsValue(Object value)
+    * This method returns true if this map maps one or more keys to the specified value.
+    * </summary>
+    */
+    containsValue(value){
+      var len = this.size();
+      for (i = 0; i < len; i++) {
+          var item = this.get( Object.keys(this.dict)[i] );
+          if(value === item)
+            return true;
+      }
+
+      return false;
+    }
+
+
+    /*
+    * <summary>
+    * Set<K> keySet()
+    * This method returns a Set view of the keys contained in this map.
+    * </summary>
+    */
+    keySet(){
+      var set = [];
+      var len = this.size();
+      for (i = 0; i < len; i++) {
+        set.push(Object.keys(this.dict)[i]);
+      }
+
+      return set;
+    }
+
+
+    /*
+    * <summary>
+    * Key firstKey()
+    * This method returns the first (lowest) key currently in this map.
+    * </summary>
+    */
+    firstKey(){
+      return Object.keys(this.dict)[0];
+    }
+
+
+    /*
+    * <summary>
+    * Key lastKey()
+    * This method returns the last (highest) key currently in this map.
+    * </summary>
+    */
+    lastKey(){
+      var len = this.size();
+      return Object.keys(this.dict)[len - 1];
+    }
+
+}
+
+// some more functions which might be required to complete the operations of TreeMap -->
+
+// Checks if the input is a number or not
+function isNumber( input ) {
+  return !isNaN( input );
+}
+
+// Sorts a JavaScript dictionary by key
+function sortOnKeys(dict) {
+
+    var sorted = [];
+    for(var key in dict) {
+        sorted[sorted.length] = key;
+    }
+    sorted.sort();
+
+    var tempDict = {};
+    for(var i = 0; i < sorted.length; i++) {
+        tempDict[sorted[i]] = dict[sorted[i]];
+    }
+
+    return tempDict;
+}
+
+// Checks if all the keys in the JavaScript dictionary are numeral. 
+// If Yes, then it returns true or else it returns false
+function allKeysAreNumeral(dict) {
+  for(var key in dict) {
+      if(!isNumber(key))
+        return false;
+  }
+
+  return true;
+}

possibleHotelBooking.js

@@ -0,0 +1,61 @@
+const TreeMap = require('./TreeMap');
+
+// A hotel manager has to process N bookings of rooms for the next season. His hotel has K rooms. 
+// Bookings contain an arrival date and a departure date. 
+// He wants to find out whether there are enough rooms in the hotel to satisfy the demand.
+// Inputs:
+// - First list for arrival time of booking
+// - Second list for departure time of booking
+// - Third is K which denotes the count of rooms
+// Output:
+// - A boolean which tells whether its possible to make a booking
+// false means there are not enough rooms for N booking
+// true means there are enough rooms for N booking
+// Example:
+// Inputs:
+// - arrivals = [1, 3, 5]
+// - departures = [2, 6, 10]
+// - K = 1
+
+// Output: false. At day = 5, there are 2 guests in the hotel. But we have only one room.
+
+// sorted map solution
+function possibleHotelBookings(arrive, depart, k) {
+    // collection of events
+    const events = new Map();
+
+    // number of rooms
+    let num = arrive.length;
+
+    for (let i = 0; i< num; i++) {
+        let arrival = arrive[i];
+        let departure = depart[i];
+        // add one during an arrival;
+        let current = events.get(arrival);
+        // events.set(arrival, current === null ? 1 : current + 1);
+        current ? events.set(arrival, current + 1) : events.set(arrival, 1);
+        // remove one during a departure
+        current = events.get(departure);
+        current ? events.set(departure, current - 1) : events.set(departure, -1)
+    }
+    console.log('events => ', events)
+
+    // sort the map
+    const sortedEvents = new TreeMap();
+    for (const el of events.entries()) {
+        sortedEvents.put(el[0], el[1])
+    }
+    console.log('sorted events => ', sortedEvents.dict)
+
+    let count = 0;
+    for (const el in sortedEvents.dict) {
+        count += sortedEvents.dict[el]
+        console.log('new count', count)
+        if (count > k) return false;
+    }
+    return true;
+}
+// Time O(nlogn) average, O(n^2) worst | Space O(n)
+
+
+console.log(possibleHotelBookings([1,3,5], [2,6,10], 1)); // false