230423

Author: aluferraz

src/Contest.java

@@ -0,0 +1,39 @@
+
+import java.util.*;
+
+class Solution {
+    public int[] getSubarrayBeauty(int[] nums, int k, int x) {
+        TreeMap<Integer, Integer> numbers = new TreeMap<>();
+        LinkedList<Integer> sliding = new LinkedList<>();
+        int n = nums.length;
+        int[] ans = new int[n - k + 1];
+        int ansIdx = 0;
+        for (int num : nums) {
+            sliding.add(num);
+            numbers.put(num, numbers.getOrDefault(num, 0) + 1);
+            if (sliding.size() == k) {
+                int toRemove = sliding.pollFirst();
+                int index = 0;
+                for (Map.Entry<Integer, Integer> kv : numbers.entrySet()) {
+                    index += kv.getValue();
+                    if (index >= x) {
+                        int value = kv.getKey();
+                        if (value < 0) ans[ansIdx++] = value;
+                        else ansIdx++;
+                        break;
+                    }
+                }
+                int total = numbers.get(toRemove);
+                total--;
+                if (total == 0) numbers.remove(toRemove);
+                else numbers.put(toRemove, total);
+            }
+        }
+        return ans;
+    }
+
+
+}
+
+public class Contest extends Solution {
+}

src/Main.java

@@ -1,6 +1,7 @@
 import leetcode.editor.en.Q1014.BestSightseeingPair;
 import leetcode.editor.en.Q1051.HeightChecker;
 import leetcode.editor.en.Q122.BestTimeToBuyAndSellStockIi;
+import leetcode.editor.en.Q1416.RestoreTheArray;
 import leetcode.editor.en.Q152.MaximumProductSubarray;
 import leetcode.editor.en.Q1548.TheMostSimilarPathInAGraph;
 import leetcode.editor.en.Q1567.MaximumLengthOfSubarrayWithPositiveProduct;
@@ -22,13 +23,15 @@
 import java.io.IOException;
 import java.io.InputStream;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.LinkedList;
 import java.util.List;
 
 
 public class Main {
     public static void main(String[] args) throws IOException {
-        System.out.println(new HeightChecker().heightChecker(toIntArray("[1,1,4,2,1,3]")));
+
+        System.out.println(new RestoreTheArray().numberOfArrays("1317", 2000));
 
     }
 

src/leetcode/editor/en/Q1312/MinimumInsertionStepsToMakeAStringPalindrome.java

@@ -0,0 +1,86 @@
+package leetcode.editor.en.Q1312;
+
+import java.util.*;
+
+import javafx.util.Pair;
+
+//Given a string s. In one step you can insert any character at any index of 
+//the string. 
+//
+// Return the minimum number of steps to make s palindrome. 
+//
+// A Palindrome String is one that reads the same backward as well as forward. 
+//
+// 
+// Example 1: 
+//
+// 
+//Input: s = "zzazz"
+//Output: 0
+//Explanation: The string "zzazz" is already palindrome we do not need any 
+//insertions.
+// 
+//
+// Example 2: 
+//
+// 
+//Input: s = "mbadm"
+//Output: 2
+//Explanation: String can be "mbdadbm" or "mdbabdm".
+// 
+//
+// Example 3: 
+//
+// 
+//Input: s = "leetcode"
+//Output: 5
+//Explanation: Inserting 5 characters the string becomes "leetcodocteel".
+// 
+//
+// 
+// Constraints: 
+//
+// 
+// 1 <= s.length <= 500 
+// s consists of lowercase English letters. 
+// 
+//
+// 👍 3613 👎 48
+
+
+//leetcode submit region begin(Prohibit modification and deletion)
+class Solution {
+    Integer cache[][];
+
+    public int minInsertions(String s) {
+        cache = new Integer[s.length()][s.length()];
+        int left = 0;
+        int right = s.length() - 1;
+
+        return minInsertions(left, right, s);
+    }
+
+    private int minInsertions(int left, int right, String s) {
+        if (left >= right) {
+            return 0;
+        }
+        if (cache[left][right] != null) {
+            return cache[left][right];
+        }
+        int lChar = s.charAt(left);
+        int rChar = s.charAt(right);
+        if (lChar == rChar) {
+            cache[left][right] = minInsertions(left + 1, right - 1, s);
+            return cache[left][right];
+        }
+        int moveLeft = minInsertions(left + 1, right, s);
+        int moveRight = minInsertions(left, right - 1, s);
+        cache[left][right] = 1 + Math.min(moveLeft, moveRight);
+        return cache[left][right];
+    }
+}
+//leetcode submit region end(Prohibit modification and deletion)
+
+
+public class MinimumInsertionStepsToMakeAStringPalindrome extends Solution {
+}

src/leetcode/editor/en/Q1416/RestoreTheArray.java

@@ -0,0 +1,108 @@
+package leetcode.editor.en.Q1416;
+
+import java.math.BigInteger;
+import java.util.*;
+
+import javafx.util.Pair;
+import leetcode.editor.en.Q868.BinaryGap;
+
+//A program was supposed to print an array of integers. The program forgot to 
+//print whitespaces and the array is printed as a string of digits s and all we 
+//know is that all integers in the array were in the range [1, k] and there are no 
+//leading zeros in the array. 
+//
+// Given the string s and the integer k, return the number of the possible 
+//arrays that can be printed as s using the mentioned program. Since the answer may be 
+//very large, return it modulo 10⁹ + 7. 
+//
+// 
+// Example 1: 
+//
+// 
+//Input: s = "1000", k = 10000
+//Output: 1
+//Explanation: The only possible array is [1000]
+// 
+//
+// Example 2: 
+//
+// 
+//Input: s = "1000", k = 10
+//Output: 0
+//Explanation: There cannot be an array that was printed this way and has all 
+//integer >= 1 and <= 10.
+// 
+//
+// Example 3: 
+//
+// 
+//Input: s = "1317", k = 2000
+//Output: 8
+//Explanation: Possible arrays are [1317],[131,7],[13,17],[1,317],[13,1,7],[1,31
+//,7],[1,3,17],[1,3,1,7]
+// 
+//
+// 
+// Constraints: 
+//
+// 
+// 1 <= s.length <= 10⁵ 
+// s consists of only digits and does not contain leading zeros. 
+// 1 <= k <= 10⁹ 
+// 
+//
+// 👍 1050 👎 37
+
+
+//leetcode submit region begin(Prohibit modification and deletion)
+import java.math.BigInteger;
+
+class Solution {
+
+    private static final long MOD = 1000000007L;
+    BigInteger[] cache;
+
+    public int numberOfArrays(String s, int k) {
+        cache = new BigInteger[s.length()];
+        BigInteger ans = numberOfArrays(0, s, new BigInteger(String.valueOf(k)));
+        return ans.mod(new BigInteger("1000000007")).intValue();
+
+    }
+
+    private BigInteger numberOfArrays(int i, String s, BigInteger k) {
+        if (i == s.length()) {
+            return new BigInteger("1");
+        }
+        int c = Character.getNumericValue(s.charAt(i));
+        if (c == 0) {
+            return new BigInteger("0");
+        }
+        if (cache[i] != null) {
+            return cache[i];
+        }
+
+        BigInteger num = new BigInteger("0");
+        BigInteger ans = new BigInteger("0");
+        BigInteger ten = new BigInteger("10");
+        for (int j = i; j < s.length(); j++) {
+            num = num.multiply(ten);
+            num = num.add(new BigInteger(String.valueOf(s.charAt(j))));
+            if (num.compareTo(k) <= 0) {
+                ans = ans.add(numberOfArrays(j + 1, s, k));
+            } else {
+                break;
+            }
+        }
+        ans = ans.mod(new BigInteger("1000000007"));
+        cache[i] = ans;
+
+        return ans;
+    }
+
+
+}
+//leetcode submit region end(Prohibit modification and deletion)
+
+
+public class RestoreTheArray extends Solution {
+}