240423

Author: aluferraz

src/Main.java

@@ -13,7 +13,9 @@
 import leetcode.editor.en.Q459.RepeatedSubstringPattern;
 import leetcode.editor.en.Q461.HammingDistance;
 import leetcode.editor.en.Q516.LongestPalindromicSubsequence;
+import leetcode.editor.en.Q673.NumberOfLongestIncreasingSubsequence;
 import leetcode.editor.en.Q71.SimplifyPath;
+import leetcode.editor.en.Q727.MinimumWindowSubsequence;
 import leetcode.editor.en.Q740.DeleteAndEarn;
 import leetcode.editor.en.Q879.ProfitableSchemes;
 import leetcode.editor.en.Q946.ValidateStackSequences;
@@ -31,7 +33,7 @@
 public class Main {
     public static void main(String[] args) throws IOException {
 
-        System.out.println(new RestoreTheArray().numberOfArrays("1317", 2000));
+        System.out.println(new NumberOfLongestIncreasingSubsequence().findNumberOfLIS(toIntArrayFromFile("testcase.txt")));
 
     }
 

src/leetcode/editor/en/Q1046/LastStoneWeight.java

@@ -0,0 +1,83 @@
+package leetcode.editor.en.Q1046;
+
+import java.util.*;
+
+import javafx.util.Pair;
+
+//You are given an array of integers stones where stones[i] is the weight of 
+//the iᵗʰ stone. 
+//
+// We are playing a game with the stones. On each turn, we choose the heaviest 
+//two stones and smash them together. Suppose the heaviest two stones have weights 
+//x and y with x <= y. The result of this smash is: 
+//
+// 
+// If x == y, both stones are destroyed, and 
+// If x != y, the stone of weight x is destroyed, and the stone of weight y has 
+//new weight y - x. 
+// 
+//
+// At the end of the game, there is at most one stone left. 
+//
+// Return the weight of the last remaining stone. If there are no stones left, 
+//return 0. 
+//
+// 
+// Example 1: 
+//
+// 
+//Input: stones = [2,7,4,1,8,1]
+//Output: 1
+//Explanation: 
+//We combine 7 and 8 to get 1 so the array converts to [2,4,1,1,1] then,
+//we combine 2 and 4 to get 2 so the array converts to [2,1,1,1] then,
+//we combine 2 and 1 to get 1 so the array converts to [1,1,1] then,
+//we combine 1 and 1 to get 0 so the array converts to [1] then that's the 
+//value of the last stone.
+// 
+//
+// Example 2: 
+//
+// 
+//Input: stones = [1]
+//Output: 1
+// 
+//
+// 
+// Constraints: 
+//
+// 
+// 1 <= stones.length <= 30 
+// 1 <= stones[i] <= 1000 
+// 
+//
+// 👍 4737 👎 83
+
+
+//leetcode submit region begin(Prohibit modification and deletion)
+class Solution {
+    public int lastStoneWeight(int[] stones) {
+        PriorityQueue<Integer> pq = new PriorityQueue<>(Comparator.reverseOrder());
+        for (int stone : stones) {
+            pq.add(stone);
+        }
+
+        while (pq.size() > 1) {
+            int stoneOne = pq.poll();
+            int stoneTwo = 0;
+            if (!pq.isEmpty()) {
+                stoneTwo = pq.poll();
+            }
+            if (stoneOne == stoneTwo) continue;
+            pq.add(stoneOne - stoneTwo);
+        }
+
+        return pq.isEmpty() ? 0 : pq.poll();
+
+    }
+}
+//leetcode submit region end(Prohibit modification and deletion)
+
+
+public class LastStoneWeight extends Solution {
+}

src/leetcode/editor/en/Q2651/CalculateDelayedArrivalTime.java

@@ -0,0 +1,54 @@
+package leetcode.editor.en.Q2651;
+import java.util.*;
+import javafx.util.Pair;
+
+//You are given a positive integer arrivalTime denoting the arrival time of a 
+//train in hours, and another positive integer delayedTime denoting the amount of 
+//delay in hours. 
+//
+// Return the time when the train will arrive at the station. 
+//
+// Note that the time in this problem is in 24-hours format. 
+//
+// 
+// Example 1: 
+//
+// 
+//Input: arrivalTime = 15, delayedTime = 5 
+//Output: 20 
+//Explanation: Arrival time of the train was 15:00 hours. It is delayed by 5 
+//hours. Now it will reach at 15+5 = 20 (20:00 hours).
+// 
+//
+// Example 2: 
+//
+// 
+//Input: arrivalTime = 13, delayedTime = 11
+//Output: 0
+//Explanation: Arrival time of the train was 13:00 hours. It is delayed by 11 
+//hours. Now it will reach at 13+11=24 (Which is denoted by 00:00 in 24 hours 
+//format so return 0).
+// 
+//
+// 
+// Constraints: 
+//
+// 
+// 1 <= arrivaltime < 24 
+// 1 <= delayedTime <= 24 
+// 
+//
+// 👍 62 👎 12
+
+
+//leetcode submit region begin(Prohibit modification and deletion)
+class Solution {
+    public int findDelayedArrivalTime(int arrivalTime, int delayedTime) {
+        return (arrivalTime + delayedTime) % 24;
+    }
+}
+//leetcode submit region end(Prohibit modification and deletion)
+
+
+
+public class CalculateDelayedArrivalTime extends Solution {}

src/leetcode/editor/en/Q2652/SumMultiples.java

@@ -0,0 +1,69 @@
+package leetcode.editor.en.Q2652;
+import java.util.*;
+import javafx.util.Pair;
+
+//Given a positive integer n, find the sum of all integers in the range [1, n] 
+//inclusive that are divisible by 3, 5, or 7. 
+//
+// Return an integer denoting the sum of all numbers in the given range 
+//satisfying the constraint. 
+//
+// 
+// Example 1: 
+//
+// 
+//Input: n = 7
+//Output: 21
+//Explanation: Numbers in the range [1, 7] that are divisible by 3, 5, or 7 are 
+//3, 5, 6, 7. The sum of these numbers is 21.
+// 
+//
+// Example 2: 
+//
+// 
+//Input: n = 10
+//Output: 40
+//Explanation: Numbers in the range [1, 10] that are divisible by 3, 5, or 7 
+//are 3, 5, 6, 7, 9, 10. The sum of these numbers is 40.
+// 
+//
+// Example 3: 
+//
+// 
+//Input: n = 9
+//Output: 30
+//Explanation: Numbers in the range [1, 9] that are divisible by 3, 5, or 7 are 
+//3, 5, 6, 7, 9. The sum of these numbers is 30.
+// 
+//
+// 
+// Constraints: 
+//
+// 
+// 1 <= n <= 10³ 
+// 
+//
+// 👍 60 👎 5
+
+
+//leetcode submit region begin(Prohibit modification and deletion)
+class Solution {
+    public int sumOfMultiples(int n) {
+        int ans = 0;
+
+        for (int i = 1; i <= n; i++) {
+            if (i % 3 == 0 || i % 5 == 0 || i % 7 == 0) {
+                //  System.out.println(i);
+                ans += i;
+            }
+
+        }
+        return ans;
+
+    }
+}
+//leetcode submit region end(Prohibit modification and deletion)
+
+
+
+public class SumMultiples extends Solution {}

src/leetcode/editor/en/Q2653/SlidingSubarrayBeauty.java

@@ -0,0 +1,107 @@
+package leetcode.editor.en.Q2653;
+import java.util.*;
+import javafx.util.Pair;
+
+//Given an integer array nums containing n integers, find the beauty of each 
+//subarray of size k. 
+//
+// The beauty of a subarray is the xᵗʰ smallest integer in the subarray if it 
+//is negative, or 0 if there are fewer than x negative integers. 
+//
+// Return an integer array containing n - k + 1 integers, which denote the 
+//beauty of the subarrays in order from the first index in the array. 
+//
+// 
+// A subarray is a contiguous non-empty sequence of elements within an array. 
+// 
+//
+// 
+// Example 1: 
+//
+// 
+//Input: nums = [1,-1,-3,-2,3], k = 3, x = 2
+//Output: [-1,-2,-2]
+//Explanation: There are 3 subarrays with size k = 3. 
+//The first subarray is [1, -1, -3] and the 2ⁿᵈ smallest negative integer is -1.
+// 
+//The second subarray is [-1, -3, -2] and the 2ⁿᵈ smallest negative integer is -
+//2. 
+//The third subarray is [-3, -2, 3] and the 2ⁿᵈ smallest negative integer is -2.
+// 
+//
+// Example 2: 
+//
+// 
+//Input: nums = [-1,-2,-3,-4,-5], k = 2, x = 2
+//Output: [-1,-2,-3,-4]
+//Explanation: There are 4 subarrays with size k = 2.
+//For [-1, -2], the 2ⁿᵈ smallest negative integer is -1.
+//For [-2, -3], the 2ⁿᵈ smallest negative integer is -2.
+//For [-3, -4], the 2ⁿᵈ smallest negative integer is -3.
+//For [-4, -5], the 2ⁿᵈ smallest negative integer is -4.  
+//
+// Example 3: 
+//
+// 
+//Input: nums = [-3,1,2,-3,0,-3], k = 2, x = 1
+//Output: [-3,0,-3,-3,-3]
+//Explanation: There are 5 subarrays with size k = 2.
+//For [-3, 1], the 1ˢᵗ smallest negative integer is -3.
+//For [1, 2], there is no negative integer so the beauty is 0.
+//For [2, -3], the 1ˢᵗ smallest negative integer is -3.
+//For [-3, 0], the 1ˢᵗ smallest negative integer is -3.
+//For [0, -3], the 1ˢᵗ smallest negative integer is -3. 
+//
+// 
+// Constraints: 
+//
+// 
+// n == nums.length 
+// 1 <= n <= 10⁵ 
+// 1 <= k <= n 
+// 1 <= x <= k 
+// -50 <= nums[i] <= 50 
+// 
+//
+// 👍 249 👎 88
+
+
+//leetcode submit region begin(Prohibit modification and deletion)
+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;
+    }
+
+
+}
+//leetcode submit region end(Prohibit modification and deletion)
+
+
+
+public class SlidingSubarrayBeauty extends Solution {}