Added task 2293.

Author: javadev

README.md

@@ -1365,6 +1365,7 @@ implementation 'com.github.javadev:leetcode-in-java:1.10'
 | # | Title | Difficulty | Tag | Time, ms | Time, %
 |------|----------------|-------------|-------------|----------|---------
 | 2300 |[Successful Pairs of Spells and Potions](src/main/java/g2201_2300/s2300_successful_pairs_of_spells_and_potions/Solution.java)| Medium | Array, Two_Pointers, Binary_Search, Sorting | 85 | 71.70
+| 2293 |[Min Max Game](src/main/java/g2201_2300/s2293_min_max_game/Solution.java)| Easy | Array, Simulation | 1 | 90.39
 | 2260 |[Minimum Consecutive Cards to Pick Up](src/main/java/g2201_2300/s2260_minimum_consecutive_cards_to_pick_up/Solution.java)| Medium | Array, Hash_Table, Sliding_Window | 50 | 97.04
 | 2259 |[Remove Digit From Number to Maximize Result](src/main/java/g2201_2300/s2259_remove_digit_from_number_to_maximize_result/Solution.java)| Easy | String, Greedy, Enumeration | 1 | 97.73
 | 2257 |[Count Unguarded Cells in the Grid](src/main/java/g2201_2300/s2257_count_unguarded_cells_in_the_grid/Solution.java)| Medium | Array, Matrix, Simulation | 32 | 70.28

src/main/java/g2201_2300/s2293_min_max_game/Solution.java

@@ -0,0 +1,21 @@
+package g2201_2300.s2293_min_max_game;
+
+// #Easy #Array #Simulation #2022_06_14_Time_1_ms_(90.39%)_Space_44_MB_(50.37%)
+
+public class Solution {
+ public int minMaxGame(int[] nums) {
+ int n = nums.length;
+ if (n == 1) {
+ return nums[0];
+ }
+ int[] newNums = new int[n / 2];
+ for (int i = 0; i < n / 2; i++) {
+ if (i % 2 == 0) {
+ newNums[i] = Math.min(nums[2 * i], nums[2 * i + 1]);
+ } else {
+ newNums[i] = Math.max(nums[2 * i], nums[2 * i + 1]);
+ }
+ }
+ return minMaxGame(newNums);
+ }
+}

src/main/java/g2201_2300/s2293_min_max_game/readme.md

@@ -0,0 +1,47 @@
+2293\. Min Max Game
+
+Easy
+
+You are given a **0-indexed** integer array `nums` whose length is a power of `2`.
+
+Apply the following algorithm on `nums`:
+
+1. Let `n` be the length of `nums`. If `n == 1`, **end** the process. Otherwise, **create** a new **0-indexed** integer array `newNums` of length `n / 2`.
+2. For every **even** index `i` where `0 <= i < n / 2`, **assign** the value of `newNums[i]` as `min(nums[2 * i], nums[2 * i + 1])`.
+3. For every **odd** index `i` where `0 <= i < n / 2`, **assign** the value of `newNums[i]` as `max(nums[2 * i], nums[2 * i + 1])`.
+4. **Replace** the array `nums` with `newNums`.
+5. **Repeat** the entire process starting from step 1.
+
+Return _the last number that remains in_ `nums` _after applying the algorithm._
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2022/04/13/example1drawio-1.png)
+
+**Input:** nums = [1,3,5,2,4,8,2,2]
+
+**Output:** 1
+
+**Explanation:** The following arrays are the results of applying the algorithm repeatedly.
+
+First: nums = [1,5,4,2]
+
+Second: nums = [1,4]
+
+Third: nums = [1]
+
+1 is the last remaining number, so we return 1. 
+
+**Example 2:**
+
+**Input:** nums = [3]
+
+**Output:** 3
+
+**Explanation:** 3 is already the last remaining number, so we return 3. 
+
+**Constraints:**
+
+* `1 <= nums.length <= 1024`
+* <code>1 <= nums[i] <= 10<sup>9</sup></code>
+* `nums.length` is a power of `2`.

src/test/java/g2201_2300/s2293_min_max_game/SolutionTest.java

@@ -0,0 +1,18 @@
+package g2201_2300.s2293_min_max_game;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+ @Test
+ void minMaxGame() {
+ assertThat(new Solution().minMaxGame(new int[] {1, 3, 5, 2, 4, 8, 2, 2}), equalTo(1));
+ }
+
+ @Test
+ void minMaxGame2() {
+ assertThat(new Solution().minMaxGame(new int[] {3}), equalTo(3));
+ }
+}