Added tasks 2161, 2162.

Author: AryamanMishra

src/main/java/g2101_2200/s2161_partition_array_according_to_given_pivot/Solution.java

@@ -0,0 +1,31 @@
+package g2101_2200.s2161_partition_array_according_to_given_pivot;
+
+// #Medium #Array #Two_Pointers #Simulation #2022_06_04_Time_7_ms_(72.76%)_Space_168.9_MB_(26.82%)
+
+public class Solution {
+ public int[] pivotArray(int[] nums, int pivot) {
+ int[] ans = new int[nums.length];
+ int point = 0;
+ int equal = 0;
+ for (int i : nums) {
+ if (i < pivot) {
+ ans[point] = i;
+ ++point;
+ } else if (i == pivot) {
+ ++equal;
+ }
+ }
+ while (equal > 0) {
+ ans[point] = pivot;
+ ++point;
+ --equal;
+ }
+ for (int i : nums) {
+ if (i > pivot) {
+ ans[point] = i;
+ ++point;
+ }
+ }
+ return ans;
+ }
+}

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

@@ -0,0 +1,46 @@
+2161\. Partition Array According to Given Pivot
+
+Medium
+
+You are given a **0-indexed** integer array `nums` and an integer `pivot`. Rearrange `nums` such that the following conditions are satisfied:
+
+* Every element less than `pivot` appears **before** every element greater than `pivot`.
+* Every element equal to `pivot` appears **in between** the elements less than and greater than `pivot`.
+* The **relative order** of the elements less than `pivot` and the elements greater than `pivot` is maintained.
+ * More formally, consider every <code>p<sub>i</sub></code>, <code>p<sub>j</sub></code> where <code>p<sub>i</sub></code> is the new position of the <code>i<sup>th</sup></code> element and <code>p<sub>j</sub></code> is the new position of the <code>j<sup>th</sup></code> element. For elements less than `pivot`, if `i < j` and `nums[i] < pivot` and `nums[j] < pivot`, then <code>p<sub>i</sub> < p<sub>j</sub></code>. Similarly for elements greater than `pivot`, if `i < j` and `nums[i] > pivot` and `nums[j] > pivot`, then <code>p<sub>i</sub> < p<sub>j</sub></code>.
+
+Return `nums` _after the rearrangement._
+
+**Example 1:**
+
+**Input:** nums = [9,12,5,10,14,3,10], pivot = 10
+
+**Output:** [9,5,3,10,10,12,14]
+
+**Explanation:** The elements 9, 5, and 3 are less than the pivot so they are on the left side of the array. 
+
+The elements 12 and 14 are greater than the pivot so they are on the right side of the array. 
+
+The relative ordering of the elements less than and greater than pivot is also maintained. 
+
+[9, 5, 3] and [12, 14] are the respective orderings. 
+
+**Example 2:**
+
+**Input:** nums = [-3,4,3,2], pivot = 2
+
+**Output:** [-3,2,4,3]
+
+**Explanation:** The element -3 is less than the pivot so it is on the left side of the array. 
+
+elements 4 and 3 are greater than the pivot so they are on the right side of the array. 
+
+The relative ordering of the elements less than and greater than pivot is also maintained. 
+
+[-3] and [4, 3] are the respective orderings. 
+
+**Constraints:**
+
+* <code>1 <= nums.length <= 10<sup>5</sup></code>
+* <code>-10<sup>6</sup> <= nums[i] <= 10<sup>6</sup></code>
+* `pivot` equals to an element of `nums`.

src/main/java/g2101_2200/s2162_minimum_cost_to_set_cooking_time/Solution.java

@@ -0,0 +1,31 @@
+package g2101_2200.s2162_minimum_cost_to_set_cooking_time;
+
+// #Medium #Math #Enumeration #2022_06_04_Time_1_ms_(95.82%)_Space_40.8_MB_(69.87%)
+
+public class Solution {
+ public int minCostSetTime(int startAt, int moveCost, int pushCost, int targetSeconds) {
+ int mins = targetSeconds / 60;
+ int secs = targetSeconds % 60;
+ return Math.min(
+ cost(mins, secs, startAt, moveCost, pushCost),
+ cost(mins - 1, secs + 60, startAt, moveCost, pushCost));
+ }
+
+ private int cost(int mins, int secs, int startAt, int moveCost, int pushCost) {
+ if (mins > 99 || secs > 99 || mins < 0 || secs < 0) {
+ return Integer.MAX_VALUE;
+ }
+ String s = Integer.toString(mins * 100 + secs);
+ char curr = (char) (startAt + '0');
+ int res = 0;
+ for (int i = 0; i < s.length(); i++) {
+ if (s.charAt(i) == curr) {
+ res += pushCost;
+ } else {
+ res += pushCost + moveCost;
+ curr = s.charAt(i);
+ }
+ }
+ return res;
+ }
+}

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

@@ -0,0 +1,73 @@
+2162\. Minimum Cost to Set Cooking Time
+
+Medium
+
+A generic microwave supports cooking times for:
+
+* at least `1` second.
+* at most `99` minutes and `99` seconds.
+
+To set the cooking time, you push **at most four digits**. The microwave normalizes what you push as four digits by **prepending zeroes**. It interprets the **first** two digits as the minutes and the **last** two digits as the seconds. It then **adds** them up as the cooking time. For example,
+
+* You push `9` `5` `4` (three digits). It is normalized as `0954` and interpreted as `9` minutes and `54` seconds.
+* You push `0` `0` `0` `8` (four digits). It is interpreted as `0` minutes and `8` seconds.
+* You push `8` `0` `9` `0`. It is interpreted as `80` minutes and `90` seconds.
+* You push `8` `1` `3` `0`. It is interpreted as `81` minutes and `30` seconds.
+
+You are given integers `startAt`, `moveCost`, `pushCost`, and `targetSeconds`. **Initially**, your finger is on the digit `startAt`. Moving the finger above **any specific digit** costs `moveCost` units of fatigue. Pushing the digit below the finger **once** costs `pushCost` units of fatigue.
+
+There can be multiple ways to set the microwave to cook for `targetSeconds` seconds but you are interested in the way with the minimum cost.
+
+Return _the **minimum cost** to set_ `targetSeconds` _seconds of cooking time_.
+
+Remember that one minute consists of `60` seconds.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/12/30/1.png)
+
+**Input:** startAt = 1, moveCost = 2, pushCost = 1, targetSeconds = 600
+
+**Output:** 6
+
+**Explanation:** The following are the possible ways to set the cooking time. 
+
+- 1 0 0 0, interpreted as 10 minutes and 0 seconds. 
+
+The finger is already on digit 1, pushes 1 (with cost 1), moves to 0 (with cost 2), pushes 0 (with cost 1), pushes 0 (with cost 1), and pushes 0 (with cost 1). 
+
+The cost is: 1 + 2 + 1 + 1 + 1 = 6. This is the minimum cost. 
+
+- 0 9 6 0, interpreted as 9 minutes and 60 seconds. That is also 600 seconds. 
+
+The finger moves to 0 (with cost 2), pushes 0 (with cost 1), moves to 9 (with cost 2), pushes 9 (with cost 1), moves to 6 (with cost 2), pushes 6 (with cost 1), moves to 0 (with cost 2), and pushes 0 (with cost 1). 
+
+The cost is: 2 + 1 + 2 + 1 + 2 + 1 + 2 + 1 = 12. 
+
+- 9 6 0, normalized as 0960 and interpreted as 9 minutes and 60 seconds. 
+
+The finger moves to 9 (with cost 2), pushes 9 (with cost 1), moves to 6 (with cost 2), pushes 6 (with cost 1), moves to 0 (with cost 2), and pushes 0 (with cost 1). 
+
+The cost is: 2 + 1 + 2 + 1 + 2 + 1 = 9. 
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2021/12/30/2.png)
+
+**Input:** startAt = 0, moveCost = 1, pushCost = 2, targetSeconds = 76
+
+**Output:** 6
+
+**Explanation:** The optimal way is to push two digits: 7 6, interpreted as 76 seconds. 
+
+The finger moves to 7 (with cost 1), pushes 7 (with cost 2), moves to 6 (with cost 1), and pushes 6 (with cost 2). 
+
+The total cost is: 1 + 2 + 1 + 2 = 6 
+
+Note other possible ways are 0076, 076, 0116, and 116, but none of them produces the minimum cost. 
+
+**Constraints:**
+
+* `0 <= startAt <= 9`
+* <code>1 <= moveCost, pushCost <= 10<sup>5</sup></code>
+* `1 <= targetSeconds <= 6039`

src/test/java/g2101_2200/s2161_partition_array_according_to_given_pivot/SolutionTest.java

@@ -0,0 +1,22 @@
+package g2101_2200.s2161_partition_array_according_to_given_pivot;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+ @Test
+ void pivotArray() {
+ assertThat(
+ new Solution().pivotArray(new int[] {9, 12, 5, 10, 14, 3, 10}, 10),
+ equalTo(new int[] {9, 5, 3, 10, 10, 12, 14}));
+ }
+
+ @Test
+ void pivotArray2() {
+ assertThat(
+ new Solution().pivotArray(new int[] {-3, 4, 3, 2}, 2),
+ equalTo(new int[] {-3, 2, 4, 3}));
+ }
+}

src/test/java/g2101_2200/s2162_minimum_cost_to_set_cooking_time/SolutionTest.java

@@ -0,0 +1,18 @@
+package g2101_2200.s2162_minimum_cost_to_set_cooking_time;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+ @Test
+ void minCostSetTime() {
+ assertThat(new Solution().minCostSetTime(1, 2, 1, 600), equalTo(6));
+ }
+
+ @Test
+ void minCostSetTime2() {
+ assertThat(new Solution().minCostSetTime(0, 1, 2, 76), equalTo(6));
+ }
+}