Add special array problem

Author: sudheerj

README.md

@@ -66,6 +66,7 @@ List of Programs related to data structures and algorithms
 | 25  | Destination City                |        [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/25.destinationCity/destinationCity.js)        | [JavaScript](https://livecodes.io/?console=open&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/25.destinationCity/destinationCity.js)               |        [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/25.destinationCity/destinationCity.md)        | Easy | Array traversal & set |
 | 26  | Set mismatch                |        [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/26.setMismatch/setMismatch.js)        | [JavaScript](https://livecodes.io/?console=open&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/26.setMismatch/setMismatch.js)               |        [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/26.setMismatch/setMismatch.md)        | Easy | Array traversal & marking numbers |
 | 27  | Intersection of arrays                |        [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/27.intersectionOfArrays/intersectionOfArrays.js)        | [JavaScript](https://livecodes.io/?console=open&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/27.intersectionOfArrays/intersectionOfArrays.js)               |        [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/27.intersectionOfArrays/intersectionOfArrays.md)        | Easy | Set and array traversal |
+| 29  | Special array                |        [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/29.specialArray/specialArray.js)        | [JavaScript](https://livecodes.io/?console=open&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/29.specialArray/specialArray.js)               |        [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/29.specialArray/specialArray.md)        | Easy | Frequency counter and array traversal |
 
 ### String
 

src/java1/algorithms/array/specialArray/SpecialArray.java

@@ -0,0 +1,35 @@
+package java1.algorithms.array.specialArray;
+
+public class SpecialArray {
+    private static int specialArray(int[] nums) {
+        int len = nums.length;
+        int[] counts = new int[len+1];
+
+        for(int num: nums){
+            if(num >=len) {
+                counts[len]++;
+            } else {
+                counts[num]++;
+            }
+        }
+        
+        int elementsGreaterThanX = 0;
+        for (int x = len; x >= 1; x--) {
+            elementsGreaterThanX += counts[x];
+            if(elementsGreaterThanX == x) {
+                return x;
+            }
+        }
+
+        return -1;
+    } 
+
+    public static void main(String[] args) {
+        int[] nums1 = new int[]{2,3};
+        int[] nums2 = new int[]{0,0,0};
+        int[] nums3 = new int[]{0,4,3,0,4};
+        System.out.println(specialArray(nums1));
+        System.out.println(specialArray(nums2));
+        System.out.println(specialArray(nums3));        
+    }
+}

src/java1/algorithms/array/specialArray/SpecialArraymd

@@ -0,0 +1,38 @@
+**Description:**
+Given an array of non-negative integers `nums`, determine if there exists a number `x` such that exactly `x` numbers in the array are greater than or equal to `x`. If such an `x` exists, return it; otherwise, return -1. The value of `x` is unique if the array is special.
+
+### Examples
+Example 1:
+
+Input: nums = [2,3]
+Output: 2
+
+Example 2:
+
+Input: nums = [0,0,0]
+Output: -1
+
+Example 3:
+
+Input: nums = [0,4,3,0,4]
+Output: -1
+
+**Algorithmic Steps**
+This problem is solved with the help of counting element frequencies and array traversal over the elements. The algorithmic approach can be summarized as follows:
+
+1. Create a function named `specialArray` and accepts input array(`nums`), which is used to determine the element `x` such that `x` number of elements greater or equal to x.
+   
+2. Define a counts arrays with `len+1` elements, where each element is initialized to zero. Here, `len` is the number of elements in an input array.
+   
+3. Iterate over an input array(`nums`) and update each element's count frequency. If the element is greater (or equal) than length of an array, update the count frequency at length index. 
+
+4. Define a counter variable `elementsGreaterThanX` to caculate the total count of elements greater upto particular index.
+   
+5. Iterate over an input array(`nums`) in a backward direction. In each iteration, update the counter `elementsGreaterThanX` by adding counter frequency at each index(`x`). If the total count is equals to current index, return the element `x` as an output
+   
+6. Return -1 if there is no element exists.
+
+**Time and Space complexity:**
+This algorithm has a time complexity of `O(n)`, where `n` is the number of elements in an input array. This is because we need to iterate over all the elements twice, one for finding the counter frequency and other one comparing the total count to each index.
+ 
+It takes constant time complexity of `O(n)`. This is due to array counter used to calculate the frequency of elements.

src/java1/algorithms/array/timeToBuyTickets/TimeToBuyTickets.java

@@ -0,0 +1,5 @@
+package java1.algorithms.array.timeToBuyTickets;
+
+public class TimeToBuyTickets {
+    
+}

src/java1/algorithms/array/timeToBuyTickets/TimeToBuyTickets.md

@@ -0,0 +1,31 @@
+function specialArray(nums){
+    const len = nums.length;
+    const counts = new Array(len+1).fill(0);
+
+    //Step1: Count frequencies
+    for (const num of nums) {
+        if(num >= len) {
+            counts[len]++;
+        } else {
+            counts[num]++;
+        }
+    }
+
+    let elementsGreaterThanX = 0;
+    //Step2: Return x number of elements greater or equal to x
+    for (let x = len; x >=1 ; x--) {
+        elementsGreaterThanX += counts[x];
+        if(elementsGreaterThanX === x) {
+            return x;
+        }  
+    }
+
+    return -1;
+}
+
+const nums1 = [2,3];
+const nums2 = [0,0,0];
+const nums3 = [0,4,3,0,4];
+console.log(specialArray(nums1));
+console.log(specialArray(nums2));
+console.log(specialArray(nums3));

src/javascript/algorithms/array/28.timeToBuyTickets/timeToBuyTickets.js

@@ -0,0 +1,38 @@
+**Description:**
+Given an array of non-negative integers `nums`, determine if there exists a number `x` such that exactly `x` numbers in the array are greater than or equal to `x`. If such an `x` exists, return it; otherwise, return -1. The value of `x` is unique if the array is special.
+
+### Examples
+Example 1:
+
+Input: nums = [2,3]
+Output: 2
+
+Example 2:
+
+Input: nums = [0,0,0]
+Output: -1
+
+Example 3:
+
+Input: nums = [0,4,3,0,4]
+Output: -1
+
+**Algorithmic Steps**
+This problem is solved with the help of counting element frequencies and array traversal over the elements. The algorithmic approach can be summarized as follows:
+
+1. Create a function named `specialArray` and accepts input array(`nums`), which is used to determine the element `x` such that `x` number of elements greater or equal to x.
+   
+2. Define a counts arrays with `len+1` elements, where each element is initialized to zero. Here, `len` is the number of elements in an input array.
+   
+3. Iterate over an input array(`nums`) and update each element's count frequency. If the element is greater (or equal) than length of an array, update the count frequency at length index. 
+
+4. Define a counter variable `elementsGreaterThanX` to caculate the total count of elements greater upto particular index.
+   
+5. Iterate over an input array(`nums`) in a backward direction. In each iteration, update the counter `elementsGreaterThanX` by adding counter frequency at each index(`x`). If the total count is equals to current index, return the element `x` as an output
+   
+6. Return -1 if there is no element exists.
+
+**Time and Space complexity:**
+This algorithm has a time complexity of `O(n)`, where `n` is the number of elements in an input array. This is because we need to iterate over all the elements twice, one for finding the counter frequency and other one comparing the total count to each index.
+ 
+It takes constant time complexity of `O(n)`. This is due to array counter used to calculate the frequency of elements.