.

Author: 15-Ab

2024 January/Daily 03-01-24.md

@@ -0,0 +1,43 @@
+## Today's 03-01-24 [Problem Link](https://leetcode.com/problems/number-of-laser-beams-in-a-bank/description/?envType=daily-question&envId=2024-01-03)
+
+
+# Intuition
+<!-- Describe your first thoughts on how to solve this problem. -->
+Basic multiplication.
+# Approach
+<!-- Describe your approach to solving the problem. -->
+- I kept track of number of '1' in a row
+- Now iterated over every row of array 
+- - counted the number of '1' in current row
+- - number of beams will the product of current number of device and previous number of devices
+- -  added the product to answer
+- -  now, the current one will become the previous one to next row
+---
+Have a look at the code , still have any confusion then please let me know in the comments
+Keep Solving.:)
+
+# Complexity
+- Time complexity : $$O(l)$$
+<!-- Add your time complexity here, e.g. $$O(n)$$ -->
+$$l$$ : length of array
+- Space complexity : $$O(1)$$
+<!-- Add your space complexity here, e.g. $$O(n)$$ -->
+
+# Code
+```
+class Solution {
+    public int numberOfBeams(String[] bank) {
+        int jawab = 0;      // to store answer
+        int picheek = 0;    // to store number of '1' in previous state
+
+        for( String r : bank){
+            int ek = (int) r.chars().filter( g -> g == '1').count(); // counting the number of '1' in current row
+            if( ek != 0){             // number of beams will the product of current number of device and previous number of devices
+                jawab += picheek*ek; // adding the product to answer
+                picheek = ek;        // now, the current one will become the previous one to next row
+            }
+        }
+        return jawab;
+    }
+}
+```

2024 January/Daily 04-01-24.md

@@ -0,0 +1,72 @@
+## Today's 04-01-24 [Problem Link](https://leetcode.com/problems/minimum-number-of-operations-to-make-array-empty/description/)
+
+# Intuition
+<!-- Describe your first thoughts on how to solve this problem. -->
+- Frequency Count :
+- - The code starts by creating a HashMap (m) to store the frequency of each number in the given array. This is crucial for determining how many times each number appears in the array.
+
+- Divisibility by 3 :
+- - The primary goal is to minimize the operations needed to make all elements 0. The code examines the frequency of each number and calculates the minimum operations required based on certain conditions.
+
+# Approach
+<!-- Describe your approach to solving the problem. -->
+- HashMap for Frequency :
+- - Iterate through the input array (nums).
+Use a HashMap (m) to store the frequency of each number in the array.
+- Calculate Operations :
+- - Iterate through the keys of the HashMap (m).
+- - For each key 'k' observe it's occurence :
+- - - If the occurrence is 1, return -1 (as it's not possible to make it 0 by subtracting 2 or 3).
+- - - if occurence of number is divisible by 3, total operations = occurences/3 
+- - - if occurence of number is of form 3*n + 1, let's try to break it down
+- - - - 3*n + 1 = 3*(n-1) + 4 = 3*(n-1) + 2*(2) -> n-1+2 operations = n+1 
+- - - if occurence of number is of form 3*n + 2, let's try to break it down
+- - - - 3*n + 2 = 3*(n) + 2*(1) -> n+1 operations 
+- Return Result :
+- - Return the total number of operations needed to make all numbers in the array divisible by 3. 
+---
+Have a look at the code , still have any confusion then please let me know in the comments
+Keep Solving.:)
+
+# Complexity
+- Time complexity : $$O(l)$$
+<!-- Add your time complexity here, e.g. $$O(n)$$ -->
+
+- Space complexity : $$O(u)$$
+
+$$l$$ : size of array
+$$u$$ : number of unique letters in array
+<!-- Add your space complexity here, e.g. $$O(n)$$ -->
+
+# Code
+```
+class Solution {
+    public int minOperations(int[] nums) {
+        boolean haveone = false;
+        HashMap<Integer, Integer> m = new HashMap<>();
+        for( int i = 0; i < nums.length; i++){
+            m.put( nums[i], m.getOrDefault(nums[i], 0) + 1);
+        }
+        int operations = 0;
+
+        // if occurence of number is divisible by 3, total operations = occurences/3 
+        // if occurence of number is of form 3*n + 1, let's try to break it down
+        //  3*n + 1 = 3*(n-1) + 4 = 3*(n-1) + 2*(2) -> n-1+2 operations = n+1 
+        // if occurence of number is of form 3*n + 2, let's try to break it down
+        //  3*n + 2 = 3*(n) + 2*(1) -> n+1 operations 
+  
+        for( int k : m.keySet()){
+            if( m.get(k) == 1){
+                return -1;
+            }
+            if( m.get(k) % 3 == 0){
+                operations += m.get(k)/3;
+            }
+            else{
+                operations += m.get(k)/3 + 1;
+            }
+        }
+        return operations;
+    }
+}
+```

README.md

@@ -1,73 +1,79 @@
 # Leetcode Daily Challenge Solutions
 
-This is my attemp to make the coding experience easier for you guys so that you can easily learn what to do in today's leetcode challenge.
+This is my attempt to make the coding experience easier for you guys so that you can easily learn what to do in today's leetcode challenge.
 
 
 ## Always here to assist you guys.
 
-## Today's 02-01-24 [Problem Link](https://leetcode.com/problems/convert-an-array-into-a-2d-array-with-conditions/solutions/4490329/daily-02-01-24/)
+## Today's 04-01-24 [Problem Link](https://leetcode.com/problems/minimum-number-of-operations-to-make-array-empty/description/)
 
 # Intuition
 <!-- Describe your first thoughts on how to solve this problem. -->
-Unitary way to think.
+- Frequency Count :
+- - The code starts by creating a HashMap (m) to store the frequency of each number in the given array. This is crucial for determining how many times each number appears in the array.
+
+- Divisibility by 3 :
+- - The primary goal is to minimize the operations needed to make all elements 0. The code examines the frequency of each number and calculates the minimum operations required based on certain conditions.
 
 # Approach
 <!-- Describe your approach to solving the problem. -->
-- I counted the frequencies of every number in the given array
-- - used HashMap for that
-- The maximum frequency of all element will be the number of answer rows
-- - as in every row there should be unique elements
-- Created and initialised answerlist with empty sub-lists
-- Now, according to their frequencies adding elements to their rows
-- - elements with frequency '1' will be present in only first row
-- - elements with frequency '2' will be present in first and second row
-- - ... and so on
+- HashMap for Frequency :
+- - Iterate through the input array (nums).
+Use a HashMap (m) to store the frequency of each number in the array.
+- Calculate Operations :
+- - Iterate through the keys of the HashMap (m).
+- - For each key 'k' observe it's occurence :
+- - - If the occurrence is 1, return -1 (as it's not possible to make it 0 by subtracting 2 or 3).
+- - - if occurence of number is divisible by 3, total operations = occurences/3 
+- - - if occurence of number is of form 3*n + 1, let's try to break it down
+- - - - 3*n + 1 = 3*(n-1) + 4 = 3*(n-1) + 2*(2) -> n-1+2 operations = n+1 
+- - - if occurence of number is of form 3*n + 2, let's try to break it down
+- - - - 3*n + 2 = 3*(n) + 2*(1) -> n+1 operations 
+- Return Result :
+- - Return the total number of operations needed to make all numbers in the array divisible by 3. 
 ---
 Have a look at the code , still have any confusion then please let me know in the comments
 Keep Solving.:)
 
-
 # Complexity
-- Time complexity : $$O(cm)$$
+- Time complexity : $$O(l)$$
 <!-- Add your time complexity here, e.g. $$O(n)$$ -->
 
-- Space complexity : $$O(c)$$
+- Space complexity : $$O(u)$$
+
+$$l$$ : size of array
+$$u$$ : number of unique letters in array
 <!-- Add your space complexity here, e.g. $$O(n)$$ -->
-$$c$$ : number of unique elements in array
-$$m$$ : maximum frequency of any element
 
 # Code
 ```
 class Solution {
-    public List<List<Integer>> findMatrix(int[] nums) {
+    public int minOperations(int[] nums) {
+        boolean haveone = false;
         HashMap<Integer, Integer> m = new HashMap<>();
-        int mf = 0; // to store maximum frequency of any integer : it will determine the number of rows
-    
-        // adding numbers in hashmap along with its frequencies
         for( int i = 0; i < nums.length; i++){
-            m.putIfAbsent(nums[i], 0);
-            m.put( nums[i], m.get(nums[i]) + 1 );
-            mf = Math.max(mf, m.get(nums[i]));
-        }
-        List<List<Integer>> l = new ArrayList<>(); // to store the answer list
-        // the element with maximum frequency will be present in every sub-list of answerlist
-        // making 'mf' rows in answer list
-        for( int i = 0; i < mf; i++){              
-            List<Integer> t = new ArrayList<>();
-            l.add(t);
+            m.put( nums[i], m.getOrDefault(nums[i], 0) + 1);
         }
-        
-        // according to their frequencies adding elements to their rows
-        // elements with frequency '1' will be present in only first row
-        // elements with frequency '2' will be present in first and second row
-        // ... and so on
+        int operations = 0;
 
-        for( int c : m.keySet() ){
-            for( int f = 0; f < m.get(c); f++){
-                l.get(f).add(c);
+        // if occurence of number is divisible by 3, total operations = occurences/3 
+        // if occurence of number is of form 3*n + 1, let's try to break it down
+        //  3*n + 1 = 3*(n-1) + 4 = 3*(n-1) + 2*(2) -> n-1+2 operations = n+1 
+        // if occurence of number is of form 3*n + 2, let's try to break it down
+        //  3*n + 2 = 3*(n) + 2*(1) -> n+1 operations 
+  
+        for( int k : m.keySet()){
+            if( m.get(k) == 1){
+                return -1;
+            }
+            if( m.get(k) % 3 == 0){
+                operations += m.get(k)/3;
+            }
+            else{
+                operations += m.get(k)/3 + 1;
             }
         }
-        return l;
+        return operations;
     }
 }
-```
+```