Added tasks 2164, 2165.

Author: AryamanMishra

src/main/java/g2101_2200/s2164_sort_even_and_odd_indices_independently/Solution.java

@@ -0,0 +1,37 @@
+package g2101_2200.s2164_sort_even_and_odd_indices_independently;
+
+// #Easy #Array #Sorting #2022_06_05_Time_2_ms_(97.22%)_Space_42.7_MB_(82.78%)
+
+import java.util.Arrays;
+
+public class Solution {
+ public int[] sortEvenOdd(int[] nums) {
+ int[] odd = new int[nums.length / 2];
+ int[] even = new int[(nums.length + 1) / 2];
+ int o = 0;
+ int e = 0;
+ for (int i = 0; i < nums.length; i++) {
+ if (i % 2 == 0) {
+ even[e] = nums[i];
+ ++e;
+ } else {
+ odd[o] = nums[i];
+ ++o;
+ }
+ }
+ Arrays.sort(odd);
+ Arrays.sort(even);
+ e = 0;
+ o = odd.length - 1;
+ for (int i = 0; i < nums.length; i++) {
+ if (i % 2 == 0) {
+ nums[i] = even[e];
+ ++e;
+ } else {
+ nums[i] = odd[o];
+ --o;
+ }
+ }
+ return nums;
+ }
+}

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

@@ -0,0 +1,43 @@
+2164\. Sort Even and Odd Indices Independently
+
+Easy
+
+You are given a **0-indexed** integer array `nums`. Rearrange the values of `nums` according to the following rules:
+
+1. Sort the values at **odd indices** of `nums` in **non-increasing** order.
+ * For example, if <code>nums = [4,**1**,2,**3**]</code> before this step, it becomes <code>[4,**3**,2,**1**]</code> after. The values at odd indices `1` and `3` are sorted in non-increasing order.
+2. Sort the values at **even indices** of `nums` in **non-decreasing** order.
+ * For example, if <code>nums = [**4**,1,**2**,3]</code> before this step, it becomes <code>[**2**,1,**4**,3]</code> after. The values at even indices `0` and `2` are sorted in non-decreasing order.
+
+Return _the array formed after rearranging the values of_ `nums`.
+
+**Example 1:**
+
+**Input:** nums = [4,1,2,3]
+
+**Output:** [2,3,4,1]
+
+**Explanation:** 
+
+First, we sort the values present at odd indices (1 and 3) in non-increasing order. 
+
+So, nums changes from [4,**1**,2,**3**] to [4,**3**,2,**1**]. 
+
+Next, we sort the values present at even indices (0 and 2) in non-decreasing order. So, nums changes from [**4**,1,**2**,3] to [**2**,3,**4**,1]. 
+
+Thus, the array formed after rearranging the values is [2,3,4,1]. 
+
+**Example 2:**
+
+**Input:** nums = [2,1]
+
+**Output:** [2,1]
+
+**Explanation:** Since there is exactly one odd index and one even index, no rearrangement of values takes place. 
+
+The resultant array formed is [2,1], which is the same as the initial array. 
+
+**Constraints:**
+
+* `1 <= nums.length <= 100`
+* `1 <= nums[i] <= 100`

src/main/java/g2101_2200/s2165_smallest_value_of_the_rearranged_number/Solution.java

@@ -0,0 +1,42 @@
+package g2101_2200.s2165_smallest_value_of_the_rearranged_number;
+
+// #Medium #Math #Sorting #2022_06_05_Time_1_ms_(100.00%)_Space_41.6_MB_(33.45%)
+
+public class Solution {
+ public long smallestNumber(long num) {
+ int[] count = new int[10];
+ long tempNum = 0;
+ if (num > 0) {
+ tempNum = num;
+ } else {
+ tempNum = num * -1;
+ }
+ int min = 10;
+ while (tempNum > 0) {
+ int rem = (int) (tempNum % 10);
+ if (rem != 0) {
+ min = Math.min(min, rem);
+ }
+ count[rem]++;
+ tempNum = tempNum / 10;
+ }
+ long output = 0;
+ if (num > 0) {
+ output = output * 10 + min;
+ count[min]--;
+ for (int i = 0; i < 10; i++) {
+ for (int j = 0; j < count[i]; j++) {
+ output = output * 10 + i;
+ }
+ }
+ } else {
+ for (int i = 9; i >= 0; i--) {
+ for (int j = 0; j < count[i]; j++) {
+ output = output * 10 + i;
+ }
+ }
+ output = output * -1;
+ }
+ return output;
+ }
+}

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

@@ -0,0 +1,33 @@
+2165\. Smallest Value of the Rearranged Number
+
+Medium
+
+You are given an integer `num.` **Rearrange** the digits of `num` such that its value is **minimized** and it does not contain **any** leading zeros.
+
+Return _the rearranged number with minimal value_.
+
+Note that the sign of the number does not change after rearranging the digits.
+
+**Example 1:**
+
+**Input:** num = 310
+
+**Output:** 103
+
+**Explanation:** The possible arrangements for the digits of 310 are 013, 031, 103, 130, 301, 310. 
+
+The arrangement with the smallest value that does not contain any leading zeros is 103. 
+
+**Example 2:**
+
+**Input:** num = -7605
+
+**Output:** -7650
+
+**Explanation:** Some possible arrangements for the digits of -7605 are -7650, -6705, -5076, -0567. 
+
+The arrangement with the smallest value that does not contain any leading zeros is -7650. 
+
+**Constraints:**
+
+* <code>-10<sup>15</sup> <= num <= 10<sup>15</sup></code>

src/test/java/g2101_2200/s2164_sort_even_and_odd_indices_independently/SolutionTest.java

@@ -0,0 +1,20 @@
+package g2101_2200.s2164_sort_even_and_odd_indices_independently;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+ @Test
+ void sortEvenOdd() {
+ assertThat(
+ new Solution().sortEvenOdd(new int[] {4, 1, 2, 3}),
+ equalTo(new int[] {2, 3, 4, 1}));
+ }
+
+ @Test
+ void sortEvenOdd2() {
+ assertThat(new Solution().sortEvenOdd(new int[] {2, 1}), equalTo(new int[] {2, 1}));
+ }
+}

src/test/java/g2101_2200/s2165_smallest_value_of_the_rearranged_number/SolutionTest.java

@@ -0,0 +1,18 @@
+package g2101_2200.s2165_smallest_value_of_the_rearranged_number;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+ @Test
+ void smallestNumber() {
+ assertThat(new Solution().smallestNumber(310L), equalTo(103L));
+ }
+
+ @Test
+ void smallestNumber2() {
+ assertThat(new Solution().smallestNumber(-7605L), equalTo(-7650L));
+ }
+}