.

Author: 15-Ab

2024 January/Daily 01-01-24.md

@@ -0,0 +1,53 @@
+# 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.
+
+
+## A very Happy Near Year to all you guys, may god give you strength to overcome what you want.
+## Always here to assist you guys.
+
+## Todays 01-01-24 [Problem Link](https://leetcode.com/problems/assign-cookies/description/?envType=daily-question&envId=2024-01-01)
+
+# Intuition
+<!-- Describe your first thoughts on how to solve this problem. -->
+Unitary method.
+
+# Approach
+<!-- Describe your approach to solving the problem. -->
+- I sorted both arrays - 'g' & 's'
+- Started from first element of 'g' 
+- - checked from first element for element greater than 'g[i]' in 's[j]'
+- - if found then incremented the count and nullify that 's[j]' so that that cookie cann't be considered in next child
+- Ran this loop for all elements of 'g'
+---
+Have a look at the code , still have any confusion then please let me know in the comments
+Keep Solving.:)
+ 
+# Complexity
+- Time complexity : $$O(gs)$$
+<!-- Add your time complexity here, e.g. $$O(n)$$ -->
+
+- Space complexity : $$O(1)$$
+<!-- Add your space complexity here, e.g. $$O(n)$$ -->
+
+# Code
+```
+class Solution {
+    public int findContentChildren(int[] g, int[] s) {
+        // sorting both the arrays
+        Arrays.sort(g);
+        Arrays.sort(s);
+        int c = 0;      // to store the number of contended children
+        for( int i = 0; i < g.length; i++){
+            for( int j = 0; j < s.length; j++){
+                if( s[j] >= g[i]){
+                    c++;
+                    s[j] = 0;
+                    break;
+                }
+            }
+        }
+        return c;
+    }
+}
+```

2024 January/Daily 02-01-24.md

@@ -0,0 +1,66 @@
+## 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/)
+
+# Intuition
+<!-- Describe your first thoughts on how to solve this problem. -->
+Unitary way to think.
+
+# 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
+---
+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)$$
+<!-- Add your time complexity here, e.g. $$O(n)$$ -->
+
+- Space complexity : $$O(c)$$
+<!-- 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) {
+        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);
+        }
+        
+        // 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
+
+        for( int c : m.keySet() ){
+            for( int f = 0; f < m.get(c); f++){
+                l.get(f).add(c);
+            }
+        }
+        return l;
+    }
+}
+```

README.md

@@ -3,51 +3,71 @@
 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.
 
 
-## A very Happy Near Year to all you guys, may god give you strength to overcome what you want.
 ## Always here to assist you guys.
 
-## Todays 01-01-24 [Problem Link](https://leetcode.com/problems/assign-cookies/description/?envType=daily-question&envId=2024-01-01)
+## 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/)
 
 # Intuition
 <!-- Describe your first thoughts on how to solve this problem. -->
-Unitary method.
+Unitary way to think.
 
 # Approach
 <!-- Describe your approach to solving the problem. -->
-- I sorted both arrays - 'g' & 's'
-- Started from first element of 'g' 
-- - checked from first element for element greater than 'g[i]' in 's[j]'
-- - if found then incremented the count and nullify that 's[j]' so that that cookie cann't be considered in next child
-- Ran this loop for all elements of 'g'
+- 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
 ---
 Have a look at the code , still have any confusion then please let me know in the comments
 Keep Solving.:)
- 
+
+
 # Complexity
-- Time complexity : $$O(gs)$$
+- Time complexity : $$O(cm)$$
 <!-- Add your time complexity here, e.g. $$O(n)$$ -->
 
-- Space complexity : $$O(1)$$
+- Space complexity : $$O(c)$$
 <!-- 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 int findContentChildren(int[] g, int[] s) {
-        // sorting both the arrays
-        Arrays.sort(g);
-        Arrays.sort(s);
-        int c = 0;      // to store the number of contended children
-        for( int i = 0; i < g.length; i++){
-            for( int j = 0; j < s.length; j++){
-                if( s[j] >= g[i]){
-                    c++;
-                    s[j] = 0;
-                    break;
-                }
+    public List<List<Integer>> findMatrix(int[] nums) {
+        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);
+        }
+        
+        // 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
+
+        for( int c : m.keySet() ){
+            for( int f = 0; f < m.get(c); f++){
+                l.get(f).add(c);
             }
         }
-        return c;
+        return l;
     }
 }
 ```