Added tasks 2194, 2195.

Author: javadev

README.md

@@ -1367,6 +1367,8 @@ implementation 'com.github.javadev:leetcode-in-java:1.10'
 |------|----------------|-------------|-------------|----------|---------
 | 2246 |[Longest Path With Different Adjacent Characters](src/main/java/g2201_2300/s2246_longest_path_with_different_adjacent_characters/Solution.java)| Hard | Array, String, Depth_First_Search, Tree, Graph, Topological_Sort | 75 | 97.79
 | 2200 |[Find All K-Distant Indices in an Array](src/main/java/g2101_2200/s2200_find_all_k_distant_indices_in_an_array/Solution.java)| Easy | Array | 2 | 95.30
+| 2195 |[Append K Integers With Minimal Sum](src/main/java/g2101_2200/s2195_append_k_integers_with_minimal_sum/Solution.java)| Medium | Array, Math, Sorting, Greedy | 19 | 96.88
+| 2194 |[Cells in a Range on an Excel Sheet](src/main/java/g2101_2200/s2194_cells_in_a_range_on_an_excel_sheet/Solution.java)| Easy | String | 1 | 99.92
 | 2193 |[Minimum Number of Moves to Make Palindrome](src/main/java/g2101_2200/s2193_minimum_number_of_moves_to_make_palindrome/Solution.java)| Hard | String, Greedy, Two_Pointers, Binary_Indexed_Tree | 8 | 98.76
 | 2187 |[Minimum Time to Complete Trips](src/main/java/g2101_2200/s2187_minimum_time_to_complete_trips/Solution.java)| Medium | Array, Binary_Search | 187 | 95.03
 | 2181 |[Merge Nodes in Between Zeros](src/main/java/g2101_2200/s2181_merge_nodes_in_between_zeros/Solution.java)| Medium | Simulation, Linked_List | 6 | 96.26

src/main/java/g2101_2200/s2194_cells_in_a_range_on_an_excel_sheet/Solution.java

@@ -0,0 +1,19 @@
+package g2101_2200.s2194_cells_in_a_range_on_an_excel_sheet;
+
+// #Easy #String #2022_06_06_Time_1_ms_(99.92%)_Space_42.6_MB_(99.23%)
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Solution {
+    public List<String> cellsInRange(String str) {
+        char[] c = str.toCharArray();
+        List<String> strings = new ArrayList<>();
+        for (char i = c[0]; i <= c[3]; i++) {
+            for (char j = c[1]; j <= c[4]; j++) {
+                strings.add(new String(new char[] {i, j}));
+            }
+        }
+        return strings;
+    }
+}

src/main/java/g2101_2200/s2194_cells_in_a_range_on_an_excel_sheet/readme.md

@@ -0,0 +1,48 @@
+2194\. Cells in a Range on an Excel Sheet
+
+Easy
+
+A cell `(r, c)` of an excel sheet is represented as a string `"<col><row>"` where:
+
+*   `<col>` denotes the column number `c` of the cell. It is represented by **alphabetical letters**.
+    *   For example, the <code>1<sup>st</sup></code> column is denoted by `'A'`, the <code>2<sup>nd</sup></code> by `'B'`, the <code>3<sup>rd</sup></code> by `'C'`, and so on.
+*   `<row>` is the row number `r` of the cell. The <code>r<sup>th</sup></code> row is represented by the **integer** `r`.
+
+You are given a string `s` in the format `"<col1><row1>:<col2><row2>"`, where `<col1>` represents the column `c1`, `<row1>` represents the row `r1`, `<col2>` represents the column `c2`, and `<row2>` represents the row `r2`, such that `r1 <= r2` and `c1 <= c2`.
+
+Return _the **list of cells**_ `(x, y)` _such that_ `r1 <= x <= r2` _and_ `c1 <= y <= c2`. The cells should be represented as **strings** in the format mentioned above and be sorted in **non-decreasing** order first by columns and then by rows.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2022/02/08/ex1drawio.png)
+
+**Input:** s = "K1:L2"
+
+**Output:** ["K1","K2","L1","L2"]
+
+**Explanation:**
+
+The above diagram shows the cells which should be present in the list.
+
+The red arrows denote the order in which the cells should be presented. 
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2022/02/09/exam2drawio.png)
+
+**Input:** s = "A1:F1"
+
+**Output:** ["A1","B1","C1","D1","E1","F1"]
+
+**Explanation:**
+
+The above diagram shows the cells which should be present in the list.
+
+The red arrow denotes the order in which the cells should be presented. 
+
+**Constraints:**
+
+*   `s.length == 5`
+*   `'A' <= s[0] <= s[3] <= 'Z'`
+*   `'1' <= s[1] <= s[4] <= '9'`
+*   `s` consists of uppercase English letters, digits and `':'`.

src/main/java/g2101_2200/s2195_append_k_integers_with_minimal_sum/Solution.java

@@ -0,0 +1,24 @@
+package g2101_2200.s2195_append_k_integers_with_minimal_sum;
+
+// #Medium #Array #Math #Sorting #Greedy #2022_06_06_Time_19_ms_(96.88%)_Space_60_MB_(78.44%)
+
+import java.util.Arrays;
+
+public class Solution {
+    public long minimalKSum(int[] nums, int k) {
+        Arrays.sort(nums);
+        long sum = 0;
+        int n = 0;
+        for (int i = 0; i < nums.length; i++) {
+            if (i == 0 || nums[i] != nums[i - 1]) {
+                if (nums[i] - n > k) {
+                    break;
+                }
+                sum += nums[i];
+                n++;
+            }
+        }
+        long t = n + (long) k;
+        return (1 + t) * t / 2 - sum;
+    }
+}

src/main/java/g2101_2200/s2195_append_k_integers_with_minimal_sum/readme.md

@@ -0,0 +1,37 @@
+2195\. Append K Integers With Minimal Sum
+
+Medium
+
+You are given an integer array `nums` and an integer `k`. Append `k` **unique positive** integers that do **not** appear in `nums` to `nums` such that the resulting total sum is **minimum**.
+
+Return _the sum of the_ `k` _integers appended to_ `nums`.
+
+**Example 1:**
+
+**Input:** nums = [1,4,25,10,25], k = 2
+
+**Output:** 5
+
+**Explanation:** The two unique positive integers that do not appear in nums which we append are 2 and 3.
+
+The resulting sum of nums is 1 + 4 + 25 + 10 + 25 + 2 + 3 = 70, which is the minimum.
+
+The sum of the two integers appended is 2 + 3 = 5, so we return 5.
+
+**Example 2:**
+
+**Input:** nums = [5,6], k = 6
+
+**Output:** 25
+
+**Explanation:** The six unique positive integers that do not appear in nums which we append are 1, 2, 3, 4, 7, and 8.
+
+The resulting sum of nums is 5 + 6 + 1 + 2 + 3 + 4 + 7 + 8 = 36, which is the minimum.
+
+The sum of the six integers appended is 1 + 2 + 3 + 4 + 7 + 8 = 25, so we return 25. 
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>5</sup></code>
+*   <code>1 <= nums[i] <= 10<sup>9</sup></code>
+*   <code>1 <= k <= 10<sup>8</sup></code>

src/test/java/g2101_2200/s2194_cells_in_a_range_on_an_excel_sheet/SolutionTest.java

@@ -0,0 +1,23 @@
+package g2101_2200.s2194_cells_in_a_range_on_an_excel_sheet;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import java.util.Arrays;
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void cellsInRange() {
+        assertThat(
+                new Solution().cellsInRange("K1:L2"),
+                equalTo(Arrays.asList("K1", "K2", "L1", "L2")));
+    }
+
+    @Test
+    void cellsInRange2() {
+        assertThat(
+                new Solution().cellsInRange("A1:F1"),
+                equalTo(Arrays.asList("A1", "B1", "C1", "D1", "E1", "F1")));
+    }
+}

src/test/java/g2101_2200/s2195_append_k_integers_with_minimal_sum/SolutionTest.java

@@ -0,0 +1,18 @@
+package g2101_2200.s2195_append_k_integers_with_minimal_sum;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void minimalKSum() {
+        assertThat(new Solution().minimalKSum(new int[] {1, 4, 25, 10, 25}, 2), equalTo(5L));
+    }
+
+    @Test
+    void minimalKSum2() {
+        assertThat(new Solution().minimalKSum(new int[] {5, 6}, 6), equalTo(25L));
+    }
+}