Added tasks 598, 599, 600.

Author: javadev

src/main/java/g0501_0600/s0598_range_addition_ii/Solution.java

@@ -0,0 +1,19 @@
+package g0501_0600.s0598_range_addition_ii;
+
+// #Easy #Array #Math
+
+public class Solution {
+ /*
+ * Since the incrementing starts from zero to op[0] and op[1], we only need to find the range that
+ * has the most overlaps. Thus we keep finding the minimum of both x and y.
+ */
+ public int maxCount(int m, int n, int[][] ops) {
+ int x = m;
+ int y = n;
+ for (int[] op : ops) {
+ x = Math.min(x, op[0]);
+ y = Math.min(y, op[1]);
+ }
+ return x * y;
+ }
+}

src/main/java/g0501_0600/s0598_range_addition_ii/readme.md

@@ -0,0 +1,37 @@
+598\. Range Addition II
+
+Easy
+
+You are given an `m x n` matrix `M` initialized with all `0`'s and an array of operations `ops`, where <code>ops[i] = [a<sub>i</sub>, b<sub>i</sub>]</code> means `M[x][y]` should be incremented by one for all <code>0 <= x < a<sub>i</sub></code> and <code>0 <= y < b<sub>i</sub></code>.
+
+Count and return _the number of maximum integers in the matrix after performing all the operations_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/10/02/ex1.jpg)
+
+**Input:** m = 3, n = 3, ops = [[2,2],[3,3]]
+
+**Output:** 4
+
+**Explanation:** The maximum integer in M is 2, and there are four of it in M. So return 4. 
+
+**Example 2:**
+
+**Input:** m = 3, n = 3, ops = [[2,2],[3,3],[3,3],[3,3],[2,2],[3,3],[3,3],[3,3],[2,2],[3,3],[3,3],[3,3]]
+
+**Output:** 4 
+
+**Example 3:**
+
+**Input:** m = 3, n = 3, ops = []
+
+**Output:** 9 
+
+**Constraints:**
+
+* <code>1 <= m, n <= 4 * 10<sup>4</sup></code>
+* <code>0 <= ops.length <= 10<sup>4</sup></code>
+* `ops[i].length == 2`
+* <code>1 <= a<sub>i</sub> <= m</code>
+* <code>1 <= b<sub>i</sub> <= n</code>

src/main/java/g0501_0600/s0599_minimum_index_sum_of_two_lists/Solution.java

@@ -0,0 +1,40 @@
+package g0501_0600.s0599_minimum_index_sum_of_two_lists;
+
+// #Easy #Array #String #Hash_Table
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class Solution {
+ public String[] findRestaurant(String[] list1, String[] list2) {
+ int min = 1000000;
+ Map<String, Integer> hm = new HashMap<>();
+ List<String> result = new ArrayList<>();
+ fillMap(list1, hm);
+ // find min value
+ for (int i = 0; i < list2.length; i++) {
+ if (hm.containsKey(list2[i])) {
+ int value = hm.get(list2[i]) + i;
+ // a new min value was found
+ if (value < min) {
+ min = value;
+ // Clean the arraylist
+ result.clear();
+ // add new min value
+ result.add(list2[i]);
+ } else if (value == min) {
+ result.add(list2[i]);
+ }
+ }
+ }
+ return result.toArray(new String[result.size()]);
+ }
+
+ public void fillMap(String[] a, Map<String, Integer> hm) {
+ for (int i = 0; i < a.length; i++) {
+ hm.put(a[i], i);
+ }
+ }
+}

src/main/java/g0501_0600/s0599_minimum_index_sum_of_two_lists/readme.md

@@ -0,0 +1,31 @@
+599\. Minimum Index Sum of Two Lists
+
+Easy
+
+Suppose Andy and Doris want to choose a restaurant for dinner, and they both have a list of favorite restaurants represented by strings.
+
+You need to help them find out their **common interest** with the **least list index sum**. If there is a choice tie between answers, output all of them with no order requirement. You could assume there always exists an answer.
+
+**Example 1:**
+
+**Input:** list1 = ["Shogun","Tapioca Express","Burger King","KFC"], list2 = ["Piatti","The Grill at Torrey Pines","Hungry Hunter Steakhouse","Shogun"]
+
+**Output:** ["Shogun"]
+
+**Explanation:** The only restaurant they both like is "Shogun". 
+
+**Example 2:**
+
+**Input:** list1 = ["Shogun","Tapioca Express","Burger King","KFC"], list2 = ["KFC","Shogun","Burger King"]
+
+**Output:** ["Shogun"]
+
+**Explanation:** The restaurant they both like and have the least index sum is "Shogun" with index sum 1 (0+1). 
+
+**Constraints:**
+
+* `1 <= list1.length, list2.length <= 1000`
+* `1 <= list1[i].length, list2[i].length <= 30`
+* `list1[i]` and `list2[i]` consist of spaces `' '` and English letters.
+* All the stings of `list1` are **unique**.
+* All the stings of `list2` are **unique**.

src/main/java/g0501_0600/s0600_non_negative_integers_without_consecutive_ones/Solution.java

@@ -0,0 +1,29 @@
+package g0501_0600.s0600_non_negative_integers_without_consecutive_ones;
+
+// #Hard #Dynamic_Programming
+
+public class Solution {
+ public int findIntegers(int n) {
+ int[] f = new int[32];
+ f[0] = 1;
+ f[1] = 2;
+ int ans = 0;
+ int preBit = 0;
+ for (int i = 2; i < 32; i++) {
+ f[i] = f[i - 1] + f[i - 2];
+ }
+ for (int k = 31; k >= 0; k--) {
+ if ((n & (1 << k)) != 0) {
+ // if that bit is on
+ ans += f[k];
+ if (preBit != 0) {
+ return ans;
+ }
+ preBit = 1;
+ } else {
+ preBit = 0;
+ }
+ }
+ return ans + 1;
+ }
+}

src/main/java/g0501_0600/s0600_non_negative_integers_without_consecutive_ones/readme.md

@@ -0,0 +1,38 @@
+600\. Non-negative Integers without Consecutive Ones
+
+Hard
+
+Given a positive integer `n`, return the number of the integers in the range `[0, n]` whose binary representations **do not** contain consecutive ones.
+
+**Example 1:**
+
+**Input:** n = 5
+
+**Output:** 5
+
+**Explanation:**
+
+ Here are the non-negative integers <= 5 with their corresponding binary representations:
+ 0 : 0
+ 1 : 1
+ 2 : 10
+ 3 : 11
+ 4 : 100
+ 5 : 101
+ Among them, only integer 3 disobeys the rule (two consecutive ones) and the other 5 satisfy the rule. 
+
+**Example 2:**
+
+**Input:** n = 1
+
+**Output:** 2 
+
+**Example 3:**
+
+**Input:** n = 2
+
+**Output:** 3 
+
+**Constraints:**
+
+* <code>1 <= n <= 10<sup>9</sup></code>

src/test/java/g0501_0600/s0598_range_addition_ii/SolutionTest.java

@@ -0,0 +1,22 @@
+package g0501_0600.s0598_range_addition_ii;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import com_github_leetcode.CommonUtils;
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+ @Test
+ void maxCount() {
+ assertThat(
+ new Solution()
+ .maxCount(
+ 3,
+ 3,
+ CommonUtils
+ .convertLeetCodeIrregularLengths2DArrayInputIntoJavaArray(
+ "[2,2],[3,3]")),
+ equalTo(4));
+ }
+}

src/test/java/g0501_0600/s0599_minimum_index_sum_of_two_lists/SolutionTest.java

@@ -0,0 +1,23 @@
+package g0501_0600.s0599_minimum_index_sum_of_two_lists;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+ @Test
+ void findRestaurant() {
+ assertThat(
+ new Solution()
+ .findRestaurant(
+ new String[] {"Shogun", "Tapioca Express", "Burger King", "KFC"},
+ new String[] {
+ "Piatti",
+ "The Grill at Torrey Pines",
+ "Hungry Hunter Steakhouse",
+ "Shogun"
+ }),
+ equalTo(new String[] {"Shogun"}));
+ }
+}

src/test/java/g0501_0600/s0600_non_negative_integers_without_consecutive_ones/SolutionTest.java

@@ -0,0 +1,18 @@
+package g0501_0600.s0600_non_negative_integers_without_consecutive_ones;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+ @Test
+ void findIntegers() {
+ assertThat(new Solution().findIntegers(5), equalTo(5));
+ }
+
+ @Test
+ void findIntegers2() {
+ assertThat(new Solution().findIntegers(100000000), equalTo(514229));
+ }
+}