2023 august

Author: 15-Ab

2023 August/Daily 01-08-23.md

@@ -0,0 +1,67 @@
+# Intuition
+<!-- Describe your first thoughts on how to solve this problem. -->
+Little change the Subset problem ( 78 )
+
+# Approach
+<!-- Describe your approach to solving the problem. -->
+Simply extract subsets of length 'k' after finding all subsets of[ 1, 2, ... , n]
+
+To find all subsets :  
+( 78. Subsets : https://leetcode.com/problems/subsets/solutions/3740278/78-subsets-simple-intuition/ )
+
+Just attach the current number to every single subsets created before.
+
+nums = [1, 2, 3, 4]
+subsets
+[
+[ ] ,
+[ 1 ] ,
+[ 2 ] , [ 1, 2 ] ,
+[ 3 ] , [ 1, 3 ] , [ 2, 3 ], [ 1, 2, 3 ] ,
+[ 4 ] , [ 1, 4 ] , [ 2, 4 ] , [ 1, 2, 4 ] , [ 3, 4 ] , [ 1, 3, 4 ] , [ 2, 3, 4 ] , [ 1, 2, 3, 4 ]
+]
+
+After extracting of '2' length :
+
+[ 1, 2 ] , [ 1, 3 ] , [ 2, 3 ] , [ 1, 4 ] , [ 2, 4 ] , [ 3, 4 ] 
+
+
+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^2)$$
+<!-- Add your time complexity here, e.g. $$O(n)$$ -->
+
+- Space complexity:
+<!-- Add your space complexity here, e.g. $$O(n)$$ -->
+
+# Code
+```
+class Solution {
+    public List<List<Integer>> combine(int n, int k) {
+        List<List<Integer>> ans = new ArrayList<>();    // to store answer of list of length 'k'
+        List<List<Integer>> li = new ArrayList<>();    // to store all subsets
+        List<Integer> t = new ArrayList<>();
+        li.add( t);
+
+        int s = li.size();
+        for( int i = 1; i <= n; i++){
+            for( int j = 0; j < s; j++){
+                List<Integer> tl = new ArrayList<>(li.get(j));
+                tl.add( i);
+                //System.out.println( tl.toString());
+                if( tl.size() == k){                  // if current formed subset is of length 'k' then add to answer list
+                    ans.add( tl);
+                }
+
+                li.add( tl);
+            }
+            s = li.size();
+        }
+        //System.out.println( li.toString()); // to print all subsets
+        return ans;
+    }
+}
+```

2023 August/Daily 02-08-23.md

@@ -0,0 +1,60 @@
+# Intuition
+<!-- Describe your first thoughts on how to solve this problem. -->
+Applying unitary method of doing permutations in code way.
+
+# Approach
+<!-- Describe your approach to solving the problem. -->
+
+Permutations basically means arrangements, so when we permute we keep a record of what we have already included and look for various ways to arrange the numbers.
+
+Same here : 
+-  I have considered all numbers of the given array as starting number one-by-one
+-  In next step include next number but not that one which is already included in that way 
+- Keep iterating till our way reach the array size
+- Add that way to answer
+- Now step back and explore other numbers
+- All this will happen recursively
+
+
+
+
+
+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*n!)$$
+<!-- Add your time complexity here, e.g. $$O(n)$$ -->
+
+- Space complexity : $$O(n*n!)$$
+<!-- Add your space complexity here, e.g. $$O(n)$$ -->
+
+# Code
+```
+class Solution {
+    public List<List<Integer>> permute(int[] nums) {
+        
+        List<List<Integer>> a = new ArrayList<>();
+        recursepermute( nums, new boolean[nums.length], new ArrayList<>(), a);
+        return a;
+    }
+
+    static void recursepermute( int[] nums, boolean[] included, List<Integer> way, List<List<Integer>> a){
+
+        if( way.size() == nums.length){
+            a.add( new ArrayList<>( way ) );
+            return;
+        }
+
+        for( int i = 0; i < nums.length; i++){
+            if( included[i] ){                   // if that number is already included in our that way , then look for next numbers
+                continue;
+            }
+            way.add( nums[i]);                   // if not , then add to our way
+            included[i] = true;
+            recursepermute( nums, included, way, a);   // now  recurse until our way size equals desired array size
+            way.remove( way.size() - 1 );              // remove last numbers to look for another way
+            included[i] = false;
+        }
+    }
+}
+```

2023 August/Daily 03-08-23 Iterative Approach.md

@@ -0,0 +1,53 @@
+# Intuition
+<!-- Describe your first thoughts on how to solve this problem. -->
+Can be solved by using Unitary method , keep a char in hand and add one-by-one . 
+
+# Approach
+<!-- Describe your approach to solving the problem. -->
+This approach is iterative and similar to Permutations(46) : https://leetcode.com/problems/permutations/solutions/3851382/daily-02-08-23/
+
+- iterate for all digits present in digits string
+- a temporary list of string that will get modified after each iteration 
+- for every string present in answer list add characters of currently iterated digit      
+- change the answer list to currently updated answer list
+---
+Have a look at the code , still have any confusion then please let me know in the comments
+Keep Solving.:)
+
+---
+Recursive Approach : https://leetcode.com/problems/letter-combinations-of-a-phone-number/solutions/3857876/recursive-approach-daily-03-08-23/
+
+# Complexity
+- Time complexity : $$O(n*4^n)$$
+<!-- Add your time complexity here, e.g. $$O(n)$$ -->
+
+- Space complexity : $$O(4^n)$$
+<!-- Add your space complexity here, e.g. $$O(n)$$ -->
+
+# Code
+```
+class Solution {
+    public List<String> letterCombinations(String digits) {   // recursive approach : similar to permutations 46
+         if (digits.isEmpty()){
+            return new ArrayList<>();
+        }
+      
+       List<String> ans = new ArrayList<>();
+        ans.add( "");                                              // initialise answer list as empty string
+
+        String[] numTochar = { "", "", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz" };  // it stores the keypad in array form
+                            // each index correponds to respective possible characters
+
+        for( char s : digits.toCharArray() ){                       // iterate for all digits present in digits string
+            List<String> a = new ArrayList<>();                     // a temporary list of string that will get modified after each iteration 
+            for( String p : ans){                                   // for every string present in answer list ...
+                for( char n : numTochar[ s - '0'].toCharArray() ){  // ... add characters of currently iterated digit
+                    a.add( p + n);
+                }
+            }
+            ans = a;                                                // update the answer list to currently updated answers
+        }
+        return ans;
+    }
+}
+```

2023 August/Daily 03-08-23 Recursive Approach.md

@@ -0,0 +1,63 @@
+# Intuition
+<!-- Describe your first thoughts on how to solve this problem. -->
+Tried to solve by using permutations
+( https://leetcode.com/problems/permutations/solutions/3851382/daily-02-08-23/ )
+# Approach
+<!-- Describe your approach to solving the problem. -->
+Stored the first characters that will be generated by first digit of 'digits' string : then keep repeating the same fashion on rest of the characters present in 'digits' string
+
+
+- I have considered all characters of the given digits as starting number one-by-one
+- In next step include next digit which is in the digits string
+- Keep iterating till our string reach the given digit size
+- Add that way to answer
+- Now step back and explore other numbers
+- All this will happen recursively
+---
+
+Have a look at the code , still have any confusion then please let me know in the comments
+Keep Solving.:)
+
+> 
+Unitary/Iterative Approach : https://leetcode.com/problems/letter-combinations-of-a-phone-number/solutions/3857796/iterative-approach-daily-03-08-23/ ---
+
+
+# Complexity
+- Time complexity : $$O(n*4^n)$$
+<!-- Add your time complexity here, e.g. $$O(n)$$ -->
+
+- Space complexity : $$O(4^n)$$
+<!-- Add your space complexity here, e.g. $$O(n)$$ -->
+
+# Code
+```
+class Solution {
+    public List<String> letterCombinations(String digits) {
+        
+        if( digits.isEmpty() ){
+            return new ArrayList<>();
+        }
+        List<String> ans = new ArrayList<>();
+        recurseLetterCombine( digits, 0, new StringBuilder(), ans);
+        return ans;
+    }
+
+    static String[] digitTochar = { "", "", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz" }; // it stores the keypad in array form
+                                  // each index correponds to respective possible characters
+
+    static void recurseLetterCombine( String digits, int i, StringBuilder s, List<String> ans){
+
+        if( i == digits.length() ){       // when size reached then add to answer 
+            ans.add( s.toString() );
+            return;
+        }
+        for( char c : digitTochar[ digits.charAt(i) - '0' ].toCharArray() ){    // initially start from first digit : so i = 0
+            s.append( c);                                  // add current char to build string
+            recurseLetterCombine( digits, i + 1, s, ans);  // now  recurse until our typed characters size equals desired digit size
+            s.deleteCharAt( s.length() - 1);               // remove last character(way) to look for another way       
+        }
+    }
+
+
+}
+```

2023 August/Daily 04-08-23.md

@@ -0,0 +1,46 @@
+# Intuition
+<!-- Describe your first thoughts on how to solve this problem. -->
+Recursion again came ( consecutive third day in daily )
+
+# Approach
+<!-- Describe your approach to solving the problem. -->
+Solve by recursive approach similar to permutations(46) and Letter Combination of Phone Number(17).
+
+---
+
+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^3)$$
+<!-- Add your time complexity here, e.g. $$O(n)$$ -->
+
+- Space complexity : $$O(n^2 + |wordDict|)$$
+<!-- Add your space complexity here, e.g. $$O(n)$$ -->
+
+# Code
+```
+class Solution {
+    static boolean wordBreak(String s, List<String> wordDict){
+
+        return recurseWordBreak( s, 0, new HashSet<>( wordDict) ,new Boolean[ s.length() ] );
+
+    }
+
+    static boolean recurseWordBreak( String s, int i, Set<String> Dict , Boolean[] record){
+
+        if( i == s.length() ){
+            return true;
+        }
+        if( record[i] != null){
+            return record[i];
+        }
+
+        for( int j = i ; j < s.length(); j++){
+            if( Dict.contains( s.substring(i, j+1) ) && recurseWordBreak( s, j+1, Dict, record) ){
+                return record[i] = true;
+            }
+        }
+        return record[i] = false;
+    }
+}
+```

2023 August/Daily 16-08-23.md

@@ -0,0 +1,50 @@
+# Intuition
+<!-- Describe your first thoughts on how to solve this problem. -->
+Deque properties of letting operations at both start and end will help.
+
+# Approach
+<!-- Describe your approach to solving the problem. -->
+Find maximum of each window and add to answer array. 
+
+- Keep an array to store maximum numbers of each window
+- Keep a deque to maintain the sliding window         
+- - if next number is greater than previous then no need of previous one
+- -  maintain window size length 'k'
+- - after reaching 'k' numbers start adding to answer array
+
+---
+
+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 int[] maxSlidingWindow(int[] nums, int k) {
+        int[] a = new int[ nums.length - k + 1];     // to store maximum numbers of each window
+        Deque<Integer> dq = new ArrayDeque<>();      // to maintain the sliding window         
+
+        for( int i = 0; i < nums.length; i++){
+            while( !dq.isEmpty() && dq.peekLast() < nums[i] ){    // if next number is greater than previous then no need of previous one
+                dq.pollLast();
+            }
+            dq.offerLast( nums[i] );                  
+            if( i >= k && nums[i-k] == dq.peekFirst()){    // maintain window size length 'k'
+                dq.pollFirst();
+            }
+            if( i >= k - 1){                        // after reaching 'k' numbers start adding to answer array
+                a[i-k+1] = dq.peekFirst();
+                //System.out.print( a[i-k+1] + " ");
+            }
+        }
+        return a;
+    }
+}
+```

2023 August/Daily 21-08-23.md

@@ -0,0 +1,31 @@
+# Intuition
+<!-- Describe your first thoughts on how to solve this problem. -->
+Whether by hit-n-trial or any other means, this method was developed.
+
+# Approach
+<!-- Describe your approach to solving the problem. -->
+- Let a new string which is just two original string joined end-to-end.
+- Remove first and last element of new string.
+- If after removal, original string can be viewed in that, then returns 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(n^2)$$
+<!-- 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 repeatedSubstringPattern(String s) {
+        String ss = s + s;
+        return ss.substring(1, ss.length() - 1).contains(s);
+    }
+}
+```