update

OneCodeMonkey · OneCodeMonkey · commit f749ae674fc6 · 2024-11-16T23:29:37.000+08:00
diff --git a/codeForces/Codeforces_1877A_Goals_of_Victory.java b/codeForces/Codeforces_1877A_Goals_of_Victory.java
@@ -0,0 +1,20 @@
+// AC: 311 ms 
+// Memory: 800 KB
+// .
+// T:O(sum(ni)), S:O(1)
+// 
+import java.util.Scanner;
+
+public class Codeforces_1877A_Goals_of_Victory {
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        int t = sc.nextInt();
+        for (int i = 0; i < t; i++) {
+            int n = sc.nextInt(), sum = 0;
+            for (int j = 0; j < n - 1; j++) {
+                sum += sc.nextInt();
+            }
+            System.out.println(-sum);
+        }
+    }
+}
diff --git a/codeForces/Codeforces_1896A_Jagged_Swaps.java b/codeForces/Codeforces_1896A_Jagged_Swaps.java
@@ -0,0 +1,32 @@
+// AC: 358 ms 
+// Memory: 900 KB
+// Just assure the first element is the smallest of the permutation.
+// T:O(sum(ni)), S:O(1)
+// 
+import java.util.Scanner;
+
+public class Codeforces_1896A_Jagged_Swaps {
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        int t = sc.nextInt();
+        for (int i = 0; i < t; i++) {
+            int n = sc.nextInt(), start = 0;
+            boolean flag = true;
+            for (int j = 0; j < n; j++) {
+                int a = sc.nextInt();
+                if (!flag) {
+                    continue;
+                }
+                if (j == 0) {
+                    start = a;
+                } else {
+                    if (a < start) {
+                        flag = false;
+                    }
+                }
+            }
+
+            System.out.println(flag ? "YES" : "NO");
+        }
+    }
+}
diff --git a/codeForces/Codeforces_1900A_Cover_in_Water.java b/codeForces/Codeforces_1900A_Cover_in_Water.java
@@ -0,0 +1,28 @@
+// AC: 296 ms 
+// Memory: 900 KB
+// .
+// T:O(sum(ni)), S:O(max(ni))
+// 
+import java.util.Scanner;
+
+public class Codeforces_1900A_Cover_in_Water {
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        int t = sc.nextInt();
+        for (int i = 0; i < t; i++) {
+            int n = sc.nextInt(), ret = 0;
+            String s = sc.next();
+            if (s.contains("...")) {
+                ret = 2;
+            } else {
+                for (char c : s.toCharArray()) {
+                    if (c == '.') {
+                        ret++;
+                    }
+                }
+            }
+
+            System.out.println(ret);
+        }
+    }
+}
diff --git a/codeForces/Codeforces_1913A_Rating_Increase.java b/codeForces/Codeforces_1913A_Rating_Increase.java
@@ -0,0 +1,30 @@
+// AC: 327 ms 
+// Memory: 800 K
+// .
+// T:O(t), S:O(1)
+// 
+import java.util.Scanner;
+
+public class Codeforces_1913A_Rating_Increase {
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        int t = sc.nextInt();
+        for (int i = 0; i < t; i++) {
+            String s = sc.next();
+            int len = s.length(), a = 0, b = 0;
+            for (int j = 1; j <= len / 2; j++) {
+                if (s.charAt(j) == '0') {
+                    continue;
+                }
+                int a1 = Integer.parseInt(s.substring(0, j)), b1 = Integer.parseInt(s.substring(j));
+                if (b1 > a1) {
+                    b = b1;
+                    a = a1;
+                    break;
+                }
+            }
+
+            System.out.println(a == 0 ? -1 : (a + " " + b));
+        }
+    }
+}
diff --git a/leetcode_solved/leetcode_3345_Smallest_Divisible_Digit_Product_I.java b/leetcode_solved/leetcode_3345_Smallest_Divisible_Digit_Product_I.java
@@ -0,0 +1,22 @@
+// Runtime 0 ms Beats 100.00%
+// Memory 40.63 MB Beats 100.00%
+// .
+// T:O(1), S:O(1)
+// 
+class Solution {
+    public int smallestNumber(int n, int t) {
+        int ret = 0, digitProduct = 1, n2 = n / 10;
+        while (n2 > 0) {
+            digitProduct *= n2 % 10;
+            n2 /= 10;
+        }
+        for (int i = n; i <= (n / 10 * 10 + 10); i++) {
+            if ((digitProduct * (i % 10)) % t == 0) {
+                ret = i;
+                break;
+            }
+        }
+
+        return ret;
+    }
+}
diff --git a/leetcode_solved/leetcode_3349_Adjacent_Increasing_Subarrays_Detection_I.java b/leetcode_solved/leetcode_3349_Adjacent_Increasing_Subarrays_Detection_I.java
@@ -0,0 +1,29 @@
+// Runtime 1 ms Beats 100.00%
+// Memory 44.36 MB Beats 100.00%
+// Array.
+// T:O(n), S:O(1)
+// 
+class Solution {
+    public boolean hasIncreasingSubarrays(List<Integer> nums, int k) {
+        if (k == 1) {
+            return true;
+        }
+        int len = nums.size(), cur = 1, prevIncrLen = 0;
+        for (int i = 1; i < len; i++) {
+            if (nums.get(i) > nums.get(i - 1)) {
+                cur++;
+                if (cur >= 2 * k || (cur >= k && prevIncrLen >= k)) {
+                    return true;
+                }
+            } else {
+                if (cur >= k && prevIncrLen >= k) {
+                    return true;
+                }
+                prevIncrLen = cur;
+                cur = 1;
+            }
+        }
+
+        return false;
+    }
+}
diff --git a/leetcode_solved/leetcode_3350_Adjacent_Increasing_Subarrays_Detection_II.java b/leetcode_solved/leetcode_3350_Adjacent_Increasing_Subarrays_Detection_II.java
@@ -0,0 +1,26 @@
+// Runtime 14 ms Beats 100.00% 
+// Memory 88.69 MB Beats 66.67%
+// Array. Same as: Leetcode 3349.
+// T:O(n), S:O(1)
+// 
+class Solution {
+    public int maxIncreasingSubarrays(List<Integer> nums) {
+        int len = nums.size(), k = 1;
+        if (len == 2) {
+            return k;
+        }
+        int cur = 1, prevIncrLen = 0;
+        for (int i = 1; i < len; i++) {
+            if (nums.get(i) > nums.get(i - 1)) {
+                cur++;
+                k = Math.max(k, cur / 2);
+            } else {
+                prevIncrLen = cur;
+                cur = 1;
+            }
+            k = Math.max(k, Math.min(prevIncrLen, cur));
+        }
+
+        return k;
+    }
+}
