.

Author: 15-Ab

2023 December/Daily 16-12-23.md

@@ -0,0 +1,74 @@
+# Intuition
+<!-- Describe your first thoughts on how to solve this problem. -->
+To be anagram both strings should have same characters with same frequencies.
+
+# Approach
+<!-- Describe your approach to solving the problem. -->
+
+- Created a HashMap
+- - stored the characters of 's' along with its respective frequencies
+- Now checked every character of 't'
+- - if found in hashmap 
+- - - decrease the frequency of that character by 1
+- - else ( it means not in hashmap)
+- - - return false ( as different character present )
+- If 't' is anagram then all frequencies of character should be zero
+- - to check this ran a 'for' loop
+
+---
+Have a look at the code , still have any confusion then please let me know in the comments
+Keep Solving.:)
+
+# Complexity
+- Time complexity : $$O(n)$$
+<!-- Add your time complexity here, e.g. $$O(n)$$ -->
+
+- Space complexity : $$O(n)$$
+<!-- Add your space complexity here, e.g. $$O(n)$$ -->
+
+# Code
+```
+class Solution {
+    public boolean isAnagram(String s, String t) {
+        if( s.length() != t.length()){
+            return false;
+        }
+        HashMap<Character, Integer> h = new HashMap<>();
+        // filling hashmap
+        for( int i = 0; i < s.length(); i++){
+            if( h.containsKey(s.charAt(i))){
+                h.put(s.charAt(i) , h.get(s.charAt(i)) + 1);
+            }
+            else{
+                h.put(s.charAt(i) , 1);
+            }
+        }
+        /*for ( char name: h.keySet()) {
+            int value = h.get(name);
+            System.out.println( name + " " + value);
+        }*/
+        
+        // checking 't'
+        for( int i = 0; i < t.length(); i++){
+            if( h.containsKey(t.charAt(i))){
+                h.put(t.charAt(i) , h.get(t.charAt(i)) - 1);
+            }
+            else{
+                return false;
+            }
+        }
+        /*for ( char name: h.keySet()) {
+            int value = h.get(name);
+            System.out.println( name + " " + value);
+        }*/
+
+        // ensuring all frequencies are zero
+        for( char c : h.keySet()){
+            if( h.get(c) != 0){
+                return false;
+            }
+        }
+        return true;
+    }
+}
+```

2023 December/Daily 20-12-23.md

@@ -0,0 +1,40 @@
+# Intuition
+<!-- Describe your first thoughts on how to solve this problem. -->
+Sum up the first two chocolates
+
+# Approach
+<!-- Describe your approach to solving the problem. -->
+- Sorted the array
+- The first two chocolates will have the least possible expenses
+- Checked the sum of both prices with 'money'
+- - if less than 'money' then simply return the leftover
+- - else return the whole 'money' ( as asked )
+---
+Have a look at the code , still have any confusion then please let me know in the comments
+Keep Solving.:)
+
+# Complexity
+- Time complexity : $$O(logn)$$
+<!-- 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 buyChoco(int[] prices, int money) {
+        Arrays.sort(prices);
+        // Checking the sum of both prices with 'money'
+        // if less than 'money' then simply return the leftover
+        //else return the whole 'money' ( as asked )
+        if( prices[0] + prices[1] <= money){
+            return money - ( prices[0] + prices[1] ) ;
+        }
+        else{
+            return money;
+        }
+
+    }
+}
+```

2023 December/Daily 22-12-23.md

@@ -0,0 +1,57 @@
+# Intuition
+<!-- Describe your first thoughts on how to solve this problem. -->
+Little visualisation
+
+# Approach
+<!-- Describe your approach to solving the problem. -->
+- I counted the number of '1'
+- Initialised two counters
+- - 'zl' to store number of'0' on left
+- - 'or' to store number of'1' on right
+- Traversed from left to right
+- - if '0' encountered then increment the zero count
+- - else decrement the '1' count as it will no longer belong to right substring
+- - update score if required
+---
+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)$$
+$$l$$ : length of string
+<!-- 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 maxScore(String s) {
+        int ones = 0;
+
+        // Counting the '1'
+        for( int i = 0; i < s.length(); i++){
+            if( s.charAt(i) == '1'){
+                ones++;
+            }
+        }
+       int zl = 0;     // to store zeroes on left
+       int or = ones;  // to store ones in right
+       int score = Integer.MIN_VALUE;  // to store the 'score'
+
+        for( int i = 0; i < s.length()-1; i++){
+            // if '0' encountered then increment the zero count
+            if( s.charAt(i) == '0'){  
+                zl++;
+            }
+            // else decrement the '1' count as it will no longer belong to right substring
+            else{
+                or--;
+            }
+            score = Math.max(score, zl + or );
+        }
+        return score;
+    }
+}
+```

2023 December/Daily 23-12-23.md

@@ -0,0 +1,61 @@
+# Intuition
+<!-- Describe your first thoughts on how to solve this problem. -->
+Applying unitary approach
+
+# Approach
+<!-- Describe your approach to solving the problem. -->
+- I kept track of all coordinates visited along the movement 
+- - used HashMap for that
+- If any coordinates found to be repeated then simply returned 'true'
+- Otherwise 'false'
+---
+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(l^2)$$
+As I'm storing coordinates : so in worst case it may possible that it takes that much space
+<!-- Add your space complexity here, e.g. $$O(n)$$ -->
+
+# Code
+```
+class Solution {
+    public boolean isPathCrossing(String path) {
+        HashMap<Integer, HashSet<Integer> > coord = new HashMap<>();
+        int x = 0;  // to keep track of x-coordinate of present location
+        int y = 0; // to keep track of y-coordinate of present location
+        HashSet<Integer> h0 = new HashSet<Integer>();
+        h0.add(0);
+        coord.put( 0, h0 );
+        for( int i = 0; i < path.length(); i++){
+            if( path.charAt(i) == 'N'){
+                y++;
+            } 
+            else if( path.charAt(i) == 'S'){
+                y--;
+            } 
+            else if( path.charAt(i) == 'E'){
+                x++;
+            } 
+            else if( path.charAt(i) == 'W'){
+                x--;
+            } 
+            //System.out.println(x + " " + y);
+            // if new x-coordinate found then add to hashmap
+            if( ! coord.containsKey(x)){
+                coord.put(x, new HashSet<Integer>() );
+            }
+            // if coordinates found to be repeated then simply return 'true'
+            if( coord.get(x).contains(y) ){
+                return true;
+            }
+            // add the new coordinates as it isn't repeated
+            coord.get(x).add(y);
+        }
+        return false;
+    }
+}
+```

2023 December/Daily 24-12-23.md

@@ -0,0 +1,38 @@
+# Intuition
+<!-- Describe your first thoughts on how to solve this problem. -->
+Simply checked for both type of patterns ( 0101.. and 1010.. )
+
+# Approach
+<!-- Describe your approach to solving the problem. -->
+Simply checked for both type of patterns ( 0101.. and 1010.. )
+- Variable 'a10' to store the number of changes required to make string of pattern '1010..'
+- - Iterated whole string to find 'a10'
+- Variable 'a01' to store the number of changes required to make string of pattern '0101..'
+- Returned the minimum of 'a10' and 'a01'
+---
+Have a look at the code , still have any confusion then please let me know in the comments
+Keep Solving.:)
+
+# Complexity
+- Time complexity : $$O(n)$$
+<!-- 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 minOperations(String s) {
+        int a10 = 0;  // to store changes required to make string of type '1010..'
+        for( int i = 0; i < s.length(); i++){
+            if( s.charAt(i) - '0' == i % 2){
+                a10++;
+            }
+        }
+        int a01;  // to store changes required to make string of type '0101..'
+        a01 = s.length() - a10;
+        return Math.min(a10, a01);
+    }
+}
+```

2023 December/Daily 29-12-23.md

@@ -0,0 +1,43 @@
+# Intuition
+<!-- Describe your first thoughts on how to solve this problem. -->
+Dynamic to rescue.
+# Approach
+<!-- Describe your approach to solving the problem. -->
+- Broken into simpler 
+- gp[t][din] will store minimum difficulty to complete first 't' tasks in 'din' days
+---
+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^2d)$$
+<!-- Add your time complexity here, e.g. $$O(n)$$ -->
+
+- Space complexity : $$O(ld)$$
+<!-- Add your space complexity here, e.g. $$O(n)$$ -->
+$$l$$ : length of jobDifficulty
+
+# Code
+```
+class Solution {
+    public int minDifficulty(int[] jobDifficulty, int d) {
+        if( jobDifficulty.length < d){
+            return -1;
+        }
+        int[][] gp = new int[jobDifficulty.length+1][d+1];
+        // gp[t][din] will store minimum difficulty to complete first 't' tasks in 'din' days
+        Arrays.stream(gp).forEach(r -> Arrays.fill(r, Integer.MAX_VALUE/3));
+	    gp[0][0] = 0;
+
+        for( int i = 1; i <= jobDifficulty.length; i++){
+            for( int j = 1; j <= d; j++){
+                int m = 0;
+                for( int k = i - 1; k >= j - 1; k--){
+                    m = Math.max( m, jobDifficulty[k] );
+                    gp[i][j] = Math.min( gp[i][j], gp[k][j-1] + m);
+                }
+            }
+        }
+        return gp[jobDifficulty.length][d];
+    }
+}
+```

2023 December/Daily 30-12-23.md

@@ -0,0 +1,44 @@
+# Intuition
+<!-- Describe your first thoughts on how to solve this problem. -->
+Basic unitary approach.
+
+# Approach
+<!-- Describe your approach to solving the problem. -->
+- I stored characters with their number of occurences in a hashmap
+- Checked if a character can be divided equally into all the strings or not
+- - if no then return false ( as it cann't be divided equally to all strings present in the array)
+- else return true
+---
+Have a look at the code , still have any confusion then please let me know in the comments
+Keep Solving.:)
+
+# Complexity
+- Time complexity : $$O(as)$$
+<!-- Add your time complexity here, e.g. $$O(n)$$ -->
+ $$a$$ : length of array
+ $$s$$ : maximum length of any string
+- Space complexity : $$O(c)$$
+<!-- Add your space complexity here, e.g. $$O(n)$$ -->
+ $$O(c)$$ : number of distinct characters in the array
+# Code
+```
+class Solution {
+    public boolean makeEqual(String[] words) {
+        HashMap<Character, Integer> m = new HashMap<>();
+        // storing characters with their number of occurences in the hashmap
+        for( int i = 0; i< words.length; i++){
+            for( int j = 0; j < words[i].length(); j++){
+                m.putIfAbsent(words[i].charAt(j), 0);
+                m.put( words[i].charAt(j), m.get(words[i].charAt(j)) + 1 );
+            }
+        }
+        // checking if a character can be divided equally into all the strings or not
+        for( char c : m.keySet()){
+            if( m.get(c) % words.length != 0){
+                return false;
+            }
+        }
+        return true;
+    }
+}
+```