Added tasks 2544, 2545

Author: javadev

README.md

@@ -1848,6 +1848,8 @@ implementation 'com.github.javadev:leetcode-in-java:1.21'
 
 | #    |      Title     | Difficulty  | Tag         | Time, ms | Time, %
 |------|----------------|-------------|-------------|----------|---------
+| 2545 |[Sort the Students by Their Kth Score](src/main/java/g2501_2600/s2545_sort_the_students_by_their_kth_score/Solution.java)| Medium | Array, Sorting, Matrix | 1 | 99.50
+| 2544 |[Alternating Digit Sum](src/main/java/g2501_2600/s2544_alternating_digit_sum/Solution.java)| Easy | Math | 0 | 100.00
 | 2543 |[Check if Point Is Reachable](src/main/java/g2501_2600/s2543_check_if_point_is_reachable/Solution.java)| Hard | Math, Number_Theory | 0 | 100.00
 | 2542 |[Maximum Subsequence Score](src/main/java/g2501_2600/s2542_maximum_subsequence_score/Solution.java)| Medium | Array, Sorting, Greedy, Heap_(Priority_Queue) | 94 | 84.75
 | 2541 |[Minimum Operations to Make Array Equal II](src/main/java/g2501_2600/s2541_minimum_operations_to_make_array_equal_ii/Solution.java)| Medium | Array, Math, Greedy | 3 | 100.00

src/main/java/g2501_2600/s2544_alternating_digit_sum/Solution.java

@@ -0,0 +1,15 @@
+package g2501_2600.s2544_alternating_digit_sum;
+
+// #Easy #Math #2023_05_11_Time_0_ms_(100.00%)_Space_39.4_MB_(79.49%)
+
+public class Solution {
+    public int alternateDigitSum(int n) {
+        String s = Integer.toString(n);
+        char[] arr = s.toCharArray();
+        int res = 0;
+        for (int i = 0; i < arr.length; i++) {
+            res += (int) Math.pow(-1, i) * (arr[i] - '0');
+        }
+        return res;
+    }
+}

src/main/java/g2501_2600/s2544_alternating_digit_sum/readme.md

@@ -0,0 +1,38 @@
+2544\. Alternating Digit Sum
+
+Easy
+
+You are given a positive integer `n`. Each digit of `n` has a sign according to the following rules:
+
+*   The **most significant digit** is assigned a **positive** sign.
+*   Each other digit has an opposite sign to its adjacent digits.
+
+Return _the sum of all digits with their corresponding sign_.
+
+**Example 1:**
+
+**Input:** n = 521
+
+**Output:** 4
+
+**Explanation:** (+5) + (-2) + (+1) = 4. 
+
+**Example 2:**
+
+**Input:** n = 111
+
+**Output:** 1
+
+**Explanation:** (+1) + (-1) + (+1) = 1. 
+
+**Example 3:**
+
+**Input:** n = 886996
+
+**Output:** 0
+
+**Explanation:** (+8) + (-8) + (+6) + (-9) + (+9) + (-6) = 0. 
+
+**Constraints:**
+
+*   <code>1 <= n <= 10<sup>9</sup></code>

src/main/java/g2501_2600/s2545_sort_the_students_by_their_kth_score/Solution.java

@@ -0,0 +1,12 @@
+package g2501_2600.s2545_sort_the_students_by_their_kth_score;
+
+// #Medium #Array #Sorting #Matrix #2023_05_11_Time_1_ms_(99.50%)_Space_53.2_MB_(6.86%)
+
+import java.util.Arrays;
+
+public class Solution {
+    public int[][] sortTheStudents(int[][] score, int k) {
+        Arrays.sort(score, (o1, o2) -> o2[k] - o1[k]);
+        return score;
+    }
+}

src/main/java/g2501_2600/s2545_sort_the_students_by_their_kth_score/readme.md

@@ -0,0 +1,48 @@
+2545\. Sort the Students by Their Kth Score
+
+Medium
+
+There is a class with `m` students and `n` exams. You are given a **0-indexed** `m x n` integer matrix `score`, where each row represents one student and `score[i][j]` denotes the score the <code>i<sup>th</sup></code> student got in the <code>j<sup>th</sup></code> exam. The matrix `score` contains **distinct** integers only.
+
+You are also given an integer `k`. Sort the students (i.e., the rows of the matrix) by their scores in the <code>k<sup>th</sup></code> (**0-indexed**) exam from the highest to the lowest.
+
+Return _the matrix after sorting it._
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2022/11/30/example1.png)
+
+**Input:** score = [[10,6,9,1],[7,5,11,2],[4,8,3,15]], k = 2
+
+**Output:** [[7,5,11,2],[10,6,9,1],[4,8,3,15]]
+
+**Explanation:** In the above diagram, S denotes the student, while E denotes the exam.
+
+- The student with index 1 scored 11 in exam 2, which is the highest score, so they got first place.
+
+- The student with index 0 scored 9 in exam 2, which is the second highest score, so they got second place.
+
+- The student with index 2 scored 3 in exam 2, which is the lowest score, so they got third place. 
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2022/11/30/example2.png)
+
+**Input:** score = [[3,4],[5,6]], k = 0
+
+**Output:** [[5,6],[3,4]]
+
+**Explanation:** In the above diagram, S denotes the student, while E denotes the exam.
+
+- The student with index 1 scored 5 in exam 0, which is the highest score, so they got first place.
+
+- The student with index 0 scored 3 in exam 0, which is the lowest score, so they got second place. 
+
+**Constraints:**
+
+*   `m == score.length`
+*   `n == score[i].length`
+*   `1 <= m, n <= 250`
+*   <code>1 <= score[i][j] <= 10<sup>5</sup></code>
+*   `score` consists of **distinct** integers.
+*   `0 <= k < n`

src/test/java/g2501_2600/s2544_alternating_digit_sum/SolutionTest.java

@@ -0,0 +1,23 @@
+package g2501_2600.s2544_alternating_digit_sum;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void alternateDigitSum() {
+        assertThat(new Solution().alternateDigitSum(521), equalTo(4));
+    }
+
+    @Test
+    void alternateDigitSum2() {
+        assertThat(new Solution().alternateDigitSum(111), equalTo(1));
+    }
+
+    @Test
+    void alternateDigitSum3() {
+        assertThat(new Solution().alternateDigitSum(886996), equalTo(0));
+    }
+}

src/test/java/g2501_2600/s2545_sort_the_students_by_their_kth_score/SolutionTest.java

@@ -0,0 +1,24 @@
+package g2501_2600.s2545_sort_the_students_by_their_kth_score;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void sortTheStudents() {
+        assertThat(
+                new Solution()
+                        .sortTheStudents(
+                                new int[][] {{10, 6, 9, 1}, {7, 5, 11, 2}, {4, 8, 3, 15}}, 2),
+                equalTo(new int[][] {{7, 5, 11, 2}, {10, 6, 9, 1}, {4, 8, 3, 15}}));
+    }
+
+    @Test
+    void sortTheStudents2() {
+        assertThat(
+                new Solution().sortTheStudents(new int[][] {{3, 4}, {5, 6}}, 0),
+                equalTo(new int[][] {{5, 6}, {3, 4}}));
+    }
+}