Add maximum balloons problem

Author: sudheerj

README.md

@@ -205,6 +205,7 @@ List of Programs related to data structures and algorithms
 | 7 |   Valid Sudoku                           | [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/hashtable/7.validSudoku/validSudoku.js)                                                                                                                                                                           | [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/hashtable/7.validSudoku/validSudoku.js)                                                                                                                                                                                                               | [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/hashtable/7.validSudoku/validSudoku.md)                                                                                                                                                                                  | Medium       |    Using Map and Set methods                     |
 | 8 |   Letter combinations                           | [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/hashtable/8.letterCombinations/letterCombinations.js)                                                                                                                                                                           | [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/hashtable/8.letterCombinations/letterCombinations.js)                                                                                                                                                                                                               | [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/hashtable/8.letterCombinations/letterCombinations.md)                                                                                                                                                                                  | Medium       |    Backtracking with hash table mapping                 |
 | 9 |   LRU Cache                           | [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/hashtable/9.lruCache/lruCache.js)                                                                                                                                                                           | [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/hashtable/9.lruCache/lruCache.js)                                                                                                                                                                                                               | [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/hashtable/9.lruCache/lruCache.md)                                                                                                                                                                                  | Medium       |    Combination of Hash Table and doubly linked list                 |
+| 10 |   Maximum number of balloons                           | [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/hashtable/10.maximumBalloons/maximumBalloons.js)                                                                                                                                                                           | [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/hashtable/10.maximumBalloons/maximumBalloons.js)                                                                                                                                                                                                               | [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/hashtable/10.maximumBalloons/maximumBalloons.md)                                                                                                                                                                                  | Easy       |    Hash map on characters                 |
 
 ## Sorting
 

src/java1/algorithms/hashmap/maximumBalloons/MaximumBalloons.java

@@ -0,0 +1,41 @@
+package java1.algorithms.hashmap.maximumBalloons;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class MaximumBalloons {
+    private static int maxNumBalloons(String text){
+        Map<Character, Integer> balloonMap = new HashMap<>();
+        balloonMap.put('b', 1);
+        balloonMap.put('a', 1);
+        balloonMap.put('l', 2);
+        balloonMap.put('o', 2);
+        balloonMap.put('n', 1);
+
+        Map<Character, Integer> countTextMap = new HashMap<>();
+
+        for (Character ch : text.toCharArray()) {
+            if(balloonMap.containsKey(ch)) {
+                countTextMap.put(ch, countTextMap.getOrDefault(ch, 0)+1);
+            }
+        }
+
+        int minBalloons = Integer.MAX_VALUE;
+
+        for (Character ch : balloonMap.keySet()) {
+            if(countTextMap.get(ch) == 0) {
+                return 0;
+            }
+
+            minBalloons = Math.min(minBalloons, countTextMap.get(ch)/balloonMap.get(ch));
+        }
+
+        return minBalloons;
+    }
+    public static void main(String[] args) {
+        String text1 = "lenobxlao";
+        System.out.println(maxNumBalloons(text1));
+        String text2 = "lollbcolatnaboon";
+        System.out.println(maxNumBalloons(text2));
+    }
+}

src/java1/algorithms/hashmap/maximumBalloons/MaximumBalloons.md

@@ -0,0 +1,38 @@
+**Problem statement:**
+Given a string `text`, find the maximum number of possible instances of the word "balloon" using the characters of given text. Each character in text is used at most once.
+
+## Examples:
+Example 1:
+
+Input: text = "lenobxlao"
+
+Output: 1
+
+
+Example 2: 
+
+Input: text = "lollbcolatnaboon"
+
+Output: 2
+
+
+**Algorithmic Steps**
+This problem is solved with the help of map(or object) data structure to store the character count. The algorithmic approach can be summarized as follows: 
+
+1. Initialize a balloon map(`balloonMap`) to store the number of occurances of each character in "balloon" word.
+    
+2. Define a character occurances of given text(`text`) in `countTextMap` variable.
+   
+3. Iterate over characters of given text and update `countTextMap` with it's character occurances. The character count is calculated only for the characters which present in "balloon" word. 
+   
+4. Define a `minBalloons` variable, initialized to maximum value.
+
+5. Iterate over characters of balloon word, calculate the possible number of balloon words based on given text.
+   
+6. Return `minBalloons` indicating the possible maximum number of balloon words.
+   
+
+**Time and Space complexity:**
+This algorithm has a time complexity of `O(n)`, Where `n` is the length of the input string (`text`). This is because we traverse the entire string once to count characters and then iterate over the fixed size(5 characters) of the `balloonMap`.
+
+Here, it takes constant time complexity of `O(1)`. This is because the size of `balloonMap` is constant and doesn't scale with input size. Eventhough `countTextMap` grows based on number of characters in `text`, its size is capped by the distinct characters of "balloon" word.

src/javascript/algorithms/hashtable/10.maximumBalloons/maximumBalloons.js

@@ -0,0 +1,26 @@
+function maxNumBalloons(text){
+    let balloonObj = {'b': 1, 'a': 1, 'l':2, 'o':2, 'n': 1};
+    let countTextObj = {};
+
+    for (const ch of text) {
+        if(balloonObj[ch]) {
+            countTextObj[ch] = (countTextObj[ch] || 0) +1;
+        }
+    }
+
+    let minBalloons = Number.POSITIVE_INFINITY;
+
+    for (const ch in balloonObj) {
+        if(!countTextObj[ch]) {
+            return 0;
+        }
+        minBalloons = Math.min(minBalloons, Math.floor(countTextObj[ch]/balloonObj[ch]));
+    }
+
+    return minBalloons;
+}
+
+const text1 = "lenobxlao";
+console.log(maxNumBalloons(text1));
+const text2 = "lollbcolatnaboon";
+console.log(maxNumBalloons(text2));

src/javascript/algorithms/hashtable/10.maximumBalloons/maximumBalloons.md

@@ -0,0 +1,38 @@
+**Problem statement:**
+Given a string `text`, find the maximum number of possible instances of the word "balloon" using the characters of given text. Each character in text is used at most once.
+
+## Examples:
+Example 1:
+
+Input: text = "lenobxlao"
+
+Output: 1
+
+
+Example 2: 
+
+Input: text = "lollbcolatnaboon"
+
+Output: 2
+
+
+**Algorithmic Steps**
+This problem is solved with the help of map(or object) data structure to store the character count. The algorithmic approach can be summarized as follows: 
+
+1. Initialize a balloon object(`balloonObj`) to store the number of occurances of each character in "balloon" word.
+    
+2. Define a character occurances of given text(`text`) in `countTextObj` variable.
+   
+3. Iterate over characters of given text and update `countTextObj` with it's character occurances. The character count is calculated only for the characters which present in "balloon" word. 
+   
+4. Define a `minBalloons` variable, initialized to infinity.
+
+5. Iterate over characters of balloon word, calculate the possible number of balloon words based on given text.
+   
+6. Return `minBalloons` indicating the possible maximum number of balloon words.
+   
+
+**Time and Space complexity:**
+This algorithm has a time complexity of `O(n)`, Where `n` is the length of the input string (`text`). This is because we traverse the string once to count characters and then iterate over the fixed size(5 characters) of the `balloonObj`.
+
+Here, it takes constant time complexity of `O(1)`. This is because the size of `balloonObj` is constant and doesn't scale with input size. Eventhough `countTextObj` grows based on number of characters in `text`, its size is capped by the distinct characters of "balloon" word.