more question practiced

Author: ronak232

Easy-Questions/climbing_stairs.js

@@ -0,0 +1,71 @@
+// using dynamic programming (tabulation or iterative approach) bottom-up
+
+// #### base case 
+// 1. when we only have 0-th stair or 1-th stair in this case 
+// we only have 1 choice to climb stairs dp[0] - 1 or dp[1] = 0
+// so the answer we got is only 1 ways can we climb to the top...
+
+// 2. When we have case for  (n >=2)
+// we iterate through the for i = 2 till n  (i.e. i = 2 to i <= n)
+// * The number of ways to climb to step i is the sum of:
+// 	* dp[i - 1] (ways to climb to the previous step and take 1 step).
+// 	* dp[i - 2] (ways to climb to the step before last and take 2 steps).
+
+// using this formula 
+// **dp[i]=dp[i−1]+dp[i−2]** we get the total number of ways to climb stairs
+
+// while returing dp[n] where n --> n-th number of stair
+
+// Brute force solution 
+
+// TC - O(2^n)
+// Recursion based 
+var climbStairs = function (n) {
+    if (n === 0 || n === 1) return 1;
+    return climbStairs(n - 1) + climbStairs(n - 2);
+};
+
+
+/**
+ * @param {number} n
+ * @return {number}
+ */
+var climbStairs = function (n) {
+    if (n === 0 || n === 1) return 1;
+    let dp = [1, 1];
+    for (let i = 2; i <= n; i++) {
+        dp[i] = dp[i - 1] + dp[i - 2];
+    }
+    return dp[n];
+};
+
+
+
+// Dry run with n = 5
+
+// Initialization:
+
+// n = 5.
+// dp = [1, 1] (base cases).
+// Iterative Loop:
+
+// Step 2 (i = 2):
+
+// dp[2] = dp[1] + dp[0] = 1 + 1 = 2.
+// dp = [1, 1, 2].
+// Step 3 (i = 3):
+
+// dp[3] = dp[2] + dp[1] = 2 + 1 = 3.
+// dp = [1, 1, 2, 3].
+// Step 4 (i = 4):
+
+// dp[4] = dp[3] + dp[2] = 3 + 2 = 5.
+// dp = [1, 1, 2, 3, 5].
+// Step 5 (i = 5):
+
+// dp[5] = dp[4] + dp[3] = 5 + 3 = 8.
+// dp = [1, 1, 2, 3, 5, 8].
+// Result:
+
+// Return dp[5] = 8.
+

Easy-Questions/happyNumber.js

@@ -0,0 +1,36 @@
+/**
+ * @param {number} n
+ * @return {boolean}
+ * 
+ * why n < 10 and n = 1 or n = 7
+ * for n = 1 or n = 7 ---> 1 square is 1 and 7 → 49 → 97 → 130 → 10 → 1
+ * Input: n = 4
+    First iteration:
+    4 → 4² = 16.
+    Second iteration:
+    16 → 1² + 6² = 37.
+    Third iteration:
+    37 → 3² + 7² = 58.
+    Infinite loop:
+    The sequence 58 → 89 → 145 → 42 → 20 → 4 repeats indefinitely.
+ * All other single-digit numbers (2, 3, 4, ..., 9) lead to infinite cycles, not 1.
+    recursivly calling the isHappy(n=1) only calls when n = 1 or n= 7 else it goes to false 
+ */
+var isHappy = function (n) {
+    // base case for n < 10
+    if (n < 10) {
+        if (n === 1 || n === 7) { // always true for n value --> 1 and 7 
+            return true;
+        }
+        return false;
+    }
+    let res = 0;
+    while (n > 0) {
+        let digit = n % 10;
+        res = res + Math.pow(digit, 2);
+        n = Math.floor(n / 10)
+    }
+    return isHappy(res)
+};
+
+

Easy-Questions/isSubsequence.js

@@ -0,0 +1,22 @@
+/**
+ * @param {string} s
+ * @param {string} t
+ * @return {boolean}
+ * 
+ * using two pointer approach
+ * Traverse through t while keeping track of a pointer j for s.
+   For every character in t, if the character matches s[j], move the pointer j forward.
+   If j equals s.length, it means all characters in s are matched in t in order.
+ */
+var isSubsequence = function (s, t) {
+    let len = s.length;
+    if(len === 0) return true;
+    let j = 0;
+    for(let i = 0; i<t.length; i++) {
+        if(s[j] === t[i]) {
+            j++;
+        }
+        if(j === len) return true;
+    }
+    return false;
+};

Easy-Questions/maximum_freq_elements_counts.js

@@ -0,0 +1,78 @@
+function maxFrequencyElements(nums) {
+    let hashMap = new Map();
+    let maxFreq = 0;
+    
+    for(let value of nums) {
+        hashMap.set(value, (hashMap.get(value) || 0 ) + 1);
+        maxFreq = Math.max(maxFreq, hashMap.get(value));
+    }
+    let totalFreq = 0;
+    for(let value of hashMap.values()) {
+        if(value === maxFreq) {
+            totalFreq += maxFreq;
+        }
+    }   
+    return totalFreq;
+};
+
+let arr = [1, 2, 2, 3, 1, 4];
+const res = maxFrequencyElements(arr);
+console.log(res);
+
+
+/**
+ * Test Case 1: Normal Input
+    Input: nums = [1, 2, 2, 3, 1, 4]
+
+    Step-by-Step Execution:
+
+    Frequency Calculation:
+
+    Initialize hashMap = new Map().
+    Loop through nums:
+    1 → hashMap = {1: 1}
+    2 → hashMap = {1: 1, 2: 1}
+    2 → hashMap = {1: 1, 2: 2}
+    3 → hashMap = {1: 1, 2: 2, 3: 1}
+    1 → hashMap = {1: 2, 2: 2, 3: 1}
+    4 → hashMap = {1: 2, 2: 2, 3: 1, 4: 1}
+    Find Maximum Frequency:
+
+    Loop through hashMap.values(hashMap) = [2, 2, 1, 1].
+    Compare each value with maxFreq:
+    maxFreq = max(0, 2) = 2
+    maxFreq = max(2, 2) = 2
+    maxFreq = max(2, 1) = 2
+    maxFreq = max(2, 1) = 2
+    Sum Frequencies with maxFreq:
+
+    Initialize totalFreq = 0.
+    Loop through hashMap.values(hashMap) = [2, 2, 1, 1]:
+    2 === maxFreq → totalFreq += 2 → totalFreq = 2
+    2 === maxFreq → totalFreq += 2 → totalFreq = 4
+    1 !== maxFreq → skip
+    1 !== maxFreq → skip
+    Output: 4
+
+Test Case 2: Single Element Array
+    Input: nums = [7]
+
+    Step-by-Step Execution:
+
+    Frequency Calculation:
+
+    Initialize hashMap = new Map().
+    Loop through nums:
+    7 → hashMap = {7: 1}
+    Find Maximum Frequency:
+
+    Loop through hashMap.values(hashMap) = [1].
+    Compare each value with maxFreq:
+    maxFreq = max(0, 1) = 1
+    Sum Frequencies with maxFreq:
+
+    Initialize totalFreq = 0.
+    Loop through hashMap.values(hashMap) = [1]:
+    1 === maxFreq → totalFreq += 1 → totalFreq = 1
+    Output: 1
+ */

Easy-Questions/missingNumber.js

@@ -1,49 +1,47 @@
 var arr = [1, 2, 4, 5];
 
-// Remeber point we are taking i = actual length of array 
+// Remeber point we are taking i = actual length of array
 // j ---> arr.length - 1 hypothetical range
 
-
 /**
  * @param arr[]
  * @returns missing number;
- * 
- * Brute solution 
+ *
+ * Brute solution
  * Time complexity O(n^2) --> Worst case
  * Space complexity O(1)
- * Keeping the track of ith number exist in array with nested loop iteration i.e. arr[j] === i 
+ * Keeping the track of ith number exist in array with nested loop iteration i.e. arr[j] === i
  */
 
-
 function missingNumberBrute(arr) {
-    for(let i = 0; i < arr.length; i++) {
-        let flag = 0;
-        for(let j = 0; j < arr.length - 1; j++)  {
-            if(arr[j] === i) {
-                flag = 1;
-                break
-            }
-        }
-       if(flag === 0) {
-        return arr[i];
-       }
+  for (let i = 0; i < arr.length; i++) {
+    let flag = 0;
+    for (let j = 0; j < arr.length - 1; j++) {
+      if (arr[j] === i) {
+        flag = 1;
+        break;
+      }
     }
+    if (flag === 0) {
+      return arr[i];
+    }
+  }
 }
 let res1 = missingNumberBrute(arr);
 console.log(res1);
 
 /**
  * 2nd Approach
  * @param arr[]
- * finding the missing number 
+ * finding the missing number
  * using Sum of all natural number
  * Time Complexity O(n)
  * Space Complexity O(1)
  */
 // Explanation
 // Uses the formula for the sum of the first n natural numbers:
 
-      // Sum =𝑛 × ( 𝑛  +1) / 2
+// Sum =𝑛 × ( 𝑛  +1) / 2
 
 // This works because n is the number of elements the array should have.
 
@@ -53,16 +51,15 @@ console.log(res1);
 // Difference:
 // The missing number is the difference between the expected sum and the actual sum.
 
-
 function missingNumber(arr) {
-    let sum = 0;
-    let n = arr.length + 1;
-    let sumOfNum = (n * (n + 1 )) / 2;
-    for(let i = 0; i < arr.length; i++) {
-        sum += arr[i];
-    }
-    let res = sumOfNum - sum;
-    return res;
+  let sum = 0;
+  let n = arr.length + 1;
+  let sumOfNum = (n * (n + 1)) / 2;
+  for (let i = 0; i < arr.length; i++) {
+    sum += arr[i];
+  }
+  let res = sumOfNum - sum;
+  return res;
 }
 
 let res = missingNumber(arr);
@@ -71,16 +68,13 @@ console.log(res);
 let xor1 = 0;
 let xor2 = 0;
 
-for(let i = 0; i< arr.length; i++) {
-    xor1 = xor1 ^ i; // i.e 1^2^3^4^5
+for (let i = 0; i < arr.length; i++) {
+  xor1 = xor1 ^ i; // i.e 1^2^3^4^5
 }
 
-for(let i = 0; i < arr.length - 1; i++) {
-    xor2 = xor2 ^ i;
+for (let i = 0; i < arr.length - 1; i++) {
+  xor2 = xor2 ^ i;
 }
 
 let missingNum = xor1 ^ xor2;
 console.log(missingNum);
-
-
-

Easy-Questions/number_of_unique_char.js

@@ -0,0 +1,16 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+var firstUniqChar = function(s) {
+    let arr = Array(26).fill(0); // Initialize an array of size 26 with 0
+    for (let ch of s) {
+        arr[ch.charCodeAt(0) - 'a'.charCodeAt(0)]++; // Increment the count for the character
+    }
+    for (let i = 0; i < s.length; i++) {
+        if (arr[s[i].charCodeAt(0) - 'a'.charCodeAt(0)] === 1) {
+            return i; // Return the index of the first unique character
+        }
+    }
+    return -1; // Return -1 if no unique character exists
+};