Added tasks 3184-3213

Author: javadev

README.md

@@ -37,25 +37,21 @@ A **subarray** is a contiguous subsequence of the array.
 
 ```java
 public class Solution {
-    public int maxProduct(int[] arr) {
-        int ans = Integer.MIN_VALUE;
-        int cprod = 1;
-        for (int j : arr) {
-            cprod = cprod * j;
-            ans = Math.max(ans, cprod);
-            if (cprod == 0) {
-                cprod = 1;
+    public int maxProduct(int[] nums) {
+        int currentMaxProd = nums[0];
+        int currentMinProd = nums[0];
+        int overAllMaxProd = nums[0];
+        for (int i = 1; i < nums.length; i++) {
+            if (nums[i] < 0) {
+                int temp = currentMaxProd;
+                currentMaxProd = currentMinProd;
+                currentMinProd = temp;
             }
+            currentMaxProd = Math.max(nums[i], nums[i] * currentMaxProd);
+            currentMinProd = Math.min(nums[i], nums[i] * currentMinProd);
+            overAllMaxProd = Math.max(overAllMaxProd, currentMaxProd);
         }
-        cprod = 1;
-        for (int i = arr.length - 1; i >= 0; i--) {
-            cprod = cprod * arr[i];
-            ans = Math.max(ans, cprod);
-            if (cprod == 0) {
-                cprod = 1;
-            }
-        }
-        return ans;
+        return overAllMaxProd;
     }
 }
 ```

src/main/java/g0101_0200/s0152_maximum_product_subarray/readme.md

@@ -54,8 +54,9 @@ The query result format is in the following example.
 
 ```sql
 # Write your MySQL query statement below
-select distinct num as ConsecutiveNums from
-(select num, lag(num,1) over(order by id) as l1, lag(num,2) over(order by id) as l2
-from Logs) con_thr
-where num = l1 and num = l2
+SELECT DISTINCT l1.num AS ConsecutiveNums
+FROM Logs l1
+JOIN Logs l2 ON l1.id = l2.id - 1
+JOIN Logs l3 ON l1.id = l3.id - 2
+WHERE l1.num = l2.num AND l2.num = l3.num;
 ```

src/main/java/g0101_0200/s0180_consecutive_numbers/readme.md

@@ -0,0 +1,58 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-Java?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-Java)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-Java?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-Java/fork)
+
+## 3184\. Count Pairs That Form a Complete Day I
+
+Easy
+
+Given an integer array `hours` representing times in **hours**, return an integer denoting the number of pairs `i`, `j` where `i < j` and `hours[i] + hours[j]` forms a **complete day**.
+
+A **complete day** is defined as a time duration that is an **exact** **multiple** of 24 hours.
+
+For example, 1 day is 24 hours, 2 days is 48 hours, 3 days is 72 hours, and so on.
+
+**Example 1:**
+
+**Input:** hours = [12,12,30,24,24]
+
+**Output:** 2
+
+**Explanation:**
+
+The pairs of indices that form a complete day are `(0, 1)` and `(3, 4)`.
+
+**Example 2:**
+
+**Input:** hours = [72,48,24,3]
+
+**Output:** 3
+
+**Explanation:**
+
+The pairs of indices that form a complete day are `(0, 1)`, `(0, 2)`, and `(1, 2)`.
+
+**Constraints:**
+
+*   `1 <= hours.length <= 100`
+*   <code>1 <= hours[i] <= 10<sup>9</sup></code>
+
+## Solution
+
+```java
+public class Solution {
+    public int countCompleteDayPairs(int[] hours) {
+        int[] modular = new int[26];
+        int ans = 0;
+        for (int hour : hours) {
+            int mod = hour % 24;
+            ans += modular[24 - mod];
+            if (mod == 0) {
+                modular[24]++;
+            } else {
+                modular[mod]++;
+            }
+        }
+        return ans;
+    }
+}
+```

src/main/java/g3101_3200/s3184_count_pairs_that_form_a_complete_day_i/readme.md

@@ -0,0 +1,52 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-Java?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-Java)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-Java?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-Java/fork)
+
+## 3185\. Count Pairs That Form a Complete Day II
+
+Medium
+
+Given an integer array `hours` representing times in **hours**, return an integer denoting the number of pairs `i`, `j` where `i < j` and `hours[i] + hours[j]` forms a **complete day**.
+
+A **complete day** is defined as a time duration that is an **exact** **multiple** of 24 hours.
+
+For example, 1 day is 24 hours, 2 days is 48 hours, 3 days is 72 hours, and so on.
+
+**Example 1:**
+
+**Input:** hours = [12,12,30,24,24]
+
+**Output:** 2
+
+**Explanation:** The pairs of indices that form a complete day are `(0, 1)` and `(3, 4)`.
+
+**Example 2:**
+
+**Input:** hours = [72,48,24,3]
+
+**Output:** 3
+
+**Explanation:** The pairs of indices that form a complete day are `(0, 1)`, `(0, 2)`, and `(1, 2)`.
+
+**Constraints:**
+
+*   <code>1 <= hours.length <= 5 * 10<sup>5</sup></code>
+*   <code>1 <= hours[i] <= 10<sup>9</sup></code>
+
+## Solution
+
+```java
+public class Solution {
+    public long countCompleteDayPairs(int[] hours) {
+        long[] hour = new long[24];
+        for (int j : hours) {
+            hour[j % 24]++;
+        }
+        long counter = hour[0] * (hour[0] - 1) / 2;
+        counter += hour[12] * (hour[12] - 1) / 2;
+        for (int i = 1; i < 12; i++) {
+            counter += hour[i] * hour[24 - i];
+        }
+        return counter;
+    }
+}
+```

src/main/java/g3101_3200/s3185_count_pairs_that_form_a_complete_day_ii/readme.md

@@ -0,0 +1,112 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-Java?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-Java)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-Java?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-Java/fork)
+
+## 3186\. Maximum Total Damage With Spell Casting
+
+Medium
+
+A magician has various spells.
+
+You are given an array `power`, where each element represents the damage of a spell. Multiple spells can have the same damage value.
+
+It is a known fact that if a magician decides to cast a spell with a damage of `power[i]`, they **cannot** cast any spell with a damage of `power[i] - 2`, `power[i] - 1`, `power[i] + 1`, or `power[i] + 2`.
+
+Each spell can be cast **only once**.
+
+Return the **maximum** possible _total damage_ that a magician can cast.
+
+**Example 1:**
+
+**Input:** power = [1,1,3,4]
+
+**Output:** 6
+
+**Explanation:**
+
+The maximum possible damage of 6 is produced by casting spells 0, 1, 3 with damage 1, 1, 4.
+
+**Example 2:**
+
+**Input:** power = [7,1,6,6]
+
+**Output:** 13
+
+**Explanation:**
+
+The maximum possible damage of 13 is produced by casting spells 1, 2, 3 with damage 1, 6, 6.
+
+**Constraints:**
+
+*   <code>1 <= power.length <= 10<sup>5</sup></code>
+*   <code>1 <= power[i] <= 10<sup>9</sup></code>
+
+## Solution
+
+```java
+import java.util.Arrays;
+
+public class Solution {
+    public long maximumTotalDamage(int[] power) {
+        int maxPower = 0;
+        for (int p : power) {
+            if (p > maxPower) {
+                maxPower = p;
+            }
+        }
+        return (maxPower <= 1_000_000) ? smallPower(power, maxPower) : bigPower(power);
+    }
+
+    private long smallPower(int[] power, int maxPower) {
+        int[] counts = new int[maxPower + 6];
+        for (int p : power) {
+            counts[p]++;
+        }
+        long[] dp = new long[maxPower + 6];
+        dp[1] = counts[1];
+        dp[2] = Math.max(counts[2] * 2L, dp[1]);
+        for (int i = 3; i <= maxPower; i++) {
+            dp[i] = Math.max(counts[i] * i + dp[i - 3], Math.max(dp[i - 1], dp[i - 2]));
+        }
+        return dp[maxPower];
+    }
+
+    private long bigPower(int[] power) {
+        Arrays.sort(power);
+        int n = power.length;
+        long[] prevs = new long[4];
+        int curPower = power[0];
+        int count = 1;
+        long result = 0;
+        for (int i = 1; i <= n; i++) {
+            int p = (i == n) ? 1_000_000_009 : power[i];
+            if (p == curPower) {
+                count++;
+            } else {
+                long curVal =
+                        Math.max((long) curPower * count + prevs[3], Math.max(prevs[1], prevs[2]));
+                int diff = Math.min(p - curPower, prevs.length - 1);
+                long nextCurVal = (diff == 1) ? 0 : Math.max(prevs[3], Math.max(curVal, prevs[2]));
+                // Shift the values in prevs[].
+                int k = prevs.length - 1;
+                if (diff < prevs.length - 1) {
+                    while (k > diff) {
+                        prevs[k] = prevs[k-- - diff];
+                    }
+                    prevs[k--] = curVal;
+                }
+                while (k > 0) {
+                    prevs[k--] = nextCurVal;
+                }
+                curPower = p;
+                count = 1;
+            }
+        }
+        for (long v : prevs) {
+            if (v > result) {
+                result = v;
+            }
+        }
+        return result;
+    }
+}
+```