DAY 14

Author: mahekramdasani

Day 15/It.java

@@ -0,0 +1,88 @@
+/*
+ * Given an array, rotate the array to the right by k steps, where k is non-negative.
+
+Input Format
+
+len = 7
+nums = [1,2,3,4,5,6,7], 
+k = 3
+Constraints
+
+1 <= nums.length <= 105
+-231 <= nums[i] <= 231 - 1
+0 <= k <= 105
+Output Format
+
+[5,6,7,1,2,3,4]
+Sample Input 0
+
+7
+3
+1 2 3 4 5 6 7
+Sample Output 0
+
+5 6 7 1 2 3 4
+Explanation 0
+
+rotate 1 steps to the right: [7,1,2,3,4,5,6]
+rotate 2 steps to the right: [6,7,1,2,3,4,5]
+rotate 3 steps to the right: [5,6,7,1,2,3,4]
+Sample Input 1
+
+4
+2
+-1 -100 3 99
+Sample Output 1
+
+3 99 -1 -100
+Explanation 1
+
+rotate 1 steps to the right: [99,-1,-100,3]
+rotate 2 steps to the right: [3,99,-1,-100]
+ */
+import java.io.*;
+import java.util.*;
+
+public class Solution {
+  public void rotate(int[] nums, int k) {
+        k = k % nums.length; // for length of array is less to k
+        if(k < 0){ // for -ve value
+            k += nums.length;
+        }
+        
+         //complete rotate array
+        rev(nums, 0, nums.length - 1);
+
+        //K part reversal
+        rev(nums, 0, k-1);
+
+        //Non K part reversal
+        rev(nums, k, nums.length -1);
+    }
+
+    private void rev(int[] arr, int i, int j){
+        while (i < j){
+            int temp = arr[i];
+            arr[i] = arr[j];
+            arr[j] = temp;
+            i++;
+            j--;
+        }
+
+    }
+    public static void main(String[] args) {
+        /* Enter your code here. Read input from STDIN. Print output to STDOUT. Your class should be named Solution. */
+        Scanner sc = new Scanner(System.in);
+        int n = sc.nextInt();
+        int k = sc.nextInt();
+        int[] a = new int[n];
+        for(int i =0;i<n;i++){
+            a[i] = sc.nextInt();
+        }
+        Solution s = new Solution();
+        s.rotate(a,k);
+         for(int i =0;i<n;i++){
+            System.out.print(a[i] + " ");
+         }
+    }
+}

Day 15/Made.java

@@ -0,0 +1,85 @@
+/*
+ * You are given an array of words where each word consists of lowercase English letters.
+
+wordA is a predecessor of wordB if and only if we can insert exactly one letter anywhere in wordA without changing the order of the other characters to make it equal to wordB.
+
+For example, "abc" is a predecessor of "abac", while "cba" is not a predecessor of "bcad". A word chain is a sequence of words [word1, word2, ..., wordk] with k >= 1, where word1 is a predecessor of word2, word2 is a predecessor of word3, and so on. A single word is trivially a word chain with k == 1.
+
+Return the length of the longest possible word chain with words chosen from the given list of words.
+
+Input Format
+
+len = 6 arr = ["a","b","ba","bca","bda","bdca"]
+
+Constraints
+
+1 <= words.length <= 1000
+1 <= words[i].length <= 16
+words[i] only consists of lowercase English letters.
+Output Format
+
+4
+
+Sample Input 0
+
+6
+a b ba bca bda bdca
+Sample Output 0
+
+4
+Explanation 0
+
+One of the longest word chains is ["a","ba","bda","bdca"].
+Sample Input 1
+
+5
+xbc pcxbcf xb cxbc pcxbc
+Sample Output 1
+
+5
+Explanation 1
+
+All the words can be put in a word chain ["xb", "xbc", "cxbc", "pcxbc", "pcxbcf"].
+
+Sample Input 2
+
+2
+abcd dbqca
+Sample Output 2
+
+1
+Explanation 2
+
+The trivial word chain ["abcd"] is one of the longest word chains.
+["abcd","dbqca"] is not a valid word chain because the ordering of the letters is changed.
+ */
+import java.io.*;
+import java.util.*;
+
+public class Solution {
+ public static int longestStrChain(String[] words) {
+        Map<String, Integer> dp = new HashMap<>();
+        Arrays.sort(words, (a, b)->a.length() - b.length());
+        int res = 0;
+        for (String word : words) {
+            int best = 0;
+            for (int i = 0; i < word.length(); ++i) {
+                String prev = word.substring(0, i) + word.substring(i + 1);
+                best = Math.max(best, dp.getOrDefault(prev, 0) + 1);
+            }
+            dp.put(word, best);
+            res = Math.max(res, best);
+        }
+        return res;
+    }
+    public static void main(String[] args) {
+        /* Enter your code here. Read input from STDIN. Print output to STDOUT. Your class should be named Solution. */
+        Scanner sc = new Scanner(System.in);
+        int n = sc.nextInt();
+        String[] s = new String[n];
+        for(int i =0;i<n;i++){
+            s[i] = sc.next();
+        }
+        System.out.println(longestStrChain(s));
+    }
+}

Day 15/You.java

@@ -0,0 +1,85 @@
+/*
+ * You are given an integer array matchsticks where matchsticks[i] is the length of the ith matchstick. You want to use all the matchsticks to make one square. You should not break any stick, but you can link them up, and each matchstick must be used exactly one time. Return true if you can make this square and false otherwise.
+
+Example 1:
+
+Input: matchsticks = [1,1,2,2,2] Output: true Explanation: You can form a square with length 2, one side of the square came two sticks with length 1.
+
+Example 2: Input: matchsticks = [3,3,3,3,4] Output: false Explanation: You cannot find a way to form a square with all the matchsticks.
+
+Input Format
+
+5 1 1 2 2 2
+
+Constraints
+
+1 <= matchsticks.length <= 15 1 <= matchsticks[i] <= 108
+
+Output Format
+
+true
+
+Sample Input 0
+
+5
+1 1 2 2 2
+Sample Output 0
+
+true
+Sample Input 1
+
+5
+3 3 3 3 4
+Sample Output 1
+
+false
+ */
+import java.io.*;
+import java.util.*;
+
+public class Solution {
+public boolean makesquare(int[] matchsticks) {
+        
+        int total = 0;
+        
+        for (int i : matchsticks) {
+            total += i;
+        }
+        
+        if (total % 4 != 0) return false; // if we cant make 4 equals sides then theres no way to make a square
+        // sort the array and place the largest sides first. required optimization to not TLE
+        Arrays.sort(matchsticks); 
+        return match(matchsticks, matchsticks.length - 1, 0, 0, 0, 0, total / 4);
+    }
+    
+    public boolean match(int[] matchsticks, int index, int top, int bottom, int left, int right, int target) {
+        
+        if (top == target && bottom == target && left == target && right == target) return true;
+
+        if (top > target || bottom > target || left > target || right > target) return false;
+                        
+        int val = matchsticks[index];
+        
+        boolean t = match(matchsticks, index - 1, top + val, bottom, left, right, target);
+        if (t) return true;
+        boolean b = match(matchsticks, index - 1, top, bottom + val, left, right, target);
+        if (b) return true;
+        boolean l = match(matchsticks, index - 1, top, bottom, left + val, right, target);
+        if (l) return true;
+        boolean r = match(matchsticks, index - 1, top, bottom, left, right + val, target);
+        if (r) return true;
+        
+        return false;
+    }
+    public static void main(String[] args) {
+        /* Enter your code here. Read input from STDIN. Print output to STDOUT. Your class should be named Solution. */
+        Scanner sc = new Scanner(System.in);
+        int n = sc.nextInt();
+        int[] a = new int[n];
+        for(int i = 0;i<n;i++){
+            a[i] = sc.nextInt();
+        }
+        Solution s = new Solution();
+        System.out.println(s.makesquare(a));
+    }
+}