From 48ca70b2882ceb516bd6b1aa4957592c7010d5f2 Mon Sep 17 00:00:00 2001 From: Valentyn Kolesnikov Date: Tue, 13 Aug 2024 07:11:48 +0300 Subject: [PATCH 1/6] Added tasks 3248-3251 --- .../s3248_snake_in_matrix/Solution.java | 29 +++++++ .../s3248_snake_in_matrix/image01.png | Bin 0 -> 3609 bytes .../s3248_snake_in_matrix/image02.png | Bin 0 -> 7586 bytes .../s3248_snake_in_matrix/readme.md | 38 +++++++++ .../Solution.java | 74 ++++++++++++++++++ .../readme.md | 55 +++++++++++++ .../Solution.java | 41 ++++++++++ .../readme.md | 42 ++++++++++ .../Solution.java | 34 ++++++++ .../readme.md | 42 ++++++++++ .../s3248_snake_in_matrix/SolutionTest.java | 20 +++++ .../SolutionTest.java | 28 +++++++ .../SolutionTest.java | 18 +++++ .../SolutionTest.java | 18 +++++ 14 files changed, 439 insertions(+) create mode 100644 src/main/java/g3201_3300/s3248_snake_in_matrix/Solution.java create mode 100644 src/main/java/g3201_3300/s3248_snake_in_matrix/image01.png create mode 100644 src/main/java/g3201_3300/s3248_snake_in_matrix/image02.png create mode 100644 src/main/java/g3201_3300/s3248_snake_in_matrix/readme.md create mode 100644 src/main/java/g3201_3300/s3249_count_the_number_of_good_nodes/Solution.java create mode 100644 src/main/java/g3201_3300/s3249_count_the_number_of_good_nodes/readme.md create mode 100644 src/main/java/g3201_3300/s3250_find_the_count_of_monotonic_pairs_i/Solution.java create mode 100644 src/main/java/g3201_3300/s3250_find_the_count_of_monotonic_pairs_i/readme.md create mode 100644 src/main/java/g3201_3300/s3251_find_the_count_of_monotonic_pairs_ii/Solution.java create mode 100644 src/main/java/g3201_3300/s3251_find_the_count_of_monotonic_pairs_ii/readme.md create mode 100644 src/test/java/g3201_3300/s3248_snake_in_matrix/SolutionTest.java create mode 100644 src/test/java/g3201_3300/s3249_count_the_number_of_good_nodes/SolutionTest.java create mode 100644 src/test/java/g3201_3300/s3250_find_the_count_of_monotonic_pairs_i/SolutionTest.java create mode 100644 src/test/java/g3201_3300/s3251_find_the_count_of_monotonic_pairs_ii/SolutionTest.java diff --git a/src/main/java/g3201_3300/s3248_snake_in_matrix/Solution.java b/src/main/java/g3201_3300/s3248_snake_in_matrix/Solution.java new file mode 100644 index 000000000..ccf9cbfe1 --- /dev/null +++ b/src/main/java/g3201_3300/s3248_snake_in_matrix/Solution.java @@ -0,0 +1,29 @@ +package g3201_3300.s3248_snake_in_matrix; + +// #Easy #Array #String #Simulation #2024_08_13_Time_2_ms_(98.05%)_Space_44.4_MB_(66.96%) + +import java.util.List; + +public class Solution { + public int finalPositionOfSnake(int n, List commands) { + int x = 0; + int y = 0; + for (String command : commands) { + switch (command) { + case "UP": + if (x > 0) x--; + break; + case "DOWN": + if (x < n - 1) x++; + break; + case "LEFT": + if (y > 0) y--; + break; + case "RIGHT": + if (y < n - 1) y++; + break; + } + } + return (x * n) + y; + } +} diff --git a/src/main/java/g3201_3300/s3248_snake_in_matrix/image01.png b/src/main/java/g3201_3300/s3248_snake_in_matrix/image01.png new file mode 100644 index 0000000000000000000000000000000000000000..d32550a7821d484c9940ef913bd1cc28e8b64f99 GIT binary patch literal 3609 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 literal 0 HcmV?d00001 diff --git a/src/main/java/g3201_3300/s3248_snake_in_matrix/image02.png b/src/main/java/g3201_3300/s3248_snake_in_matrix/image02.png new file mode 100644 index 0000000000000000000000000000000000000000..00305b02682e7176ef3e0538b531ed0ed685ed46 GIT binary patch literal 7586 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 N>)M7|I8BGB{{VF*1poj5 literal 0 HcmV?d00001 diff --git a/src/main/java/g3201_3300/s3248_snake_in_matrix/readme.md b/src/main/java/g3201_3300/s3248_snake_in_matrix/readme.md new file mode 100644 index 000000000..71498b4af --- /dev/null +++ b/src/main/java/g3201_3300/s3248_snake_in_matrix/readme.md @@ -0,0 +1,38 @@ +3248\. Snake in Matrix + +Easy + +There is a snake in an `n x n` matrix `grid` and can move in **four possible directions**. Each cell in the `grid` is identified by the position: `grid[i][j] = (i * n) + j`. + +The snake starts at cell 0 and follows a sequence of commands. + +You are given an integer `n` representing the size of the `grid` and an array of strings `commands` where each `command[i]` is either `"UP"`, `"RIGHT"`, `"DOWN"`, and `"LEFT"`. It's guaranteed that the snake will remain within the `grid` boundaries throughout its movement. + +Return the position of the final cell where the snake ends up after executing `commands`. + +**Example 1:** + +**Input:** n = 2, commands = ["RIGHT","DOWN"] + +**Output:** 3 + +**Explanation:** + +![image](image01.png) + +**Example 2:** + +**Input:** n = 3, commands = ["DOWN","RIGHT","UP"] + +**Output:** 1 + +**Explanation:** + +![image](image02.png) + +**Constraints:** + +* `2 <= n <= 10` +* `1 <= commands.length <= 100` +* `commands` consists only of `"UP"`, `"RIGHT"`, `"DOWN"`, and `"LEFT"`. +* The input is generated such the snake will not move outside of the boundaries. \ No newline at end of file diff --git a/src/main/java/g3201_3300/s3249_count_the_number_of_good_nodes/Solution.java b/src/main/java/g3201_3300/s3249_count_the_number_of_good_nodes/Solution.java new file mode 100644 index 000000000..6b2d546f8 --- /dev/null +++ b/src/main/java/g3201_3300/s3249_count_the_number_of_good_nodes/Solution.java @@ -0,0 +1,74 @@ +package g3201_3300.s3249_count_the_number_of_good_nodes; + +// #Medium #Tree #Depth_First_Search #2024_08_13_Time_34_ms_(100.00%)_Space_113.9_MB_(90.70%) + +import java.util.ArrayList; +import java.util.List; + +public class Solution { + private int count = 0; + + public int countGoodNodes(int[][] edges) { + int n = edges.length + 1; + TNode[] nodes = new TNode[n]; + nodes[0] = new TNode(0); + for (int[] edge : edges) { + int a = edge[0]; + int b = edge[1]; + if (nodes[b] != null && nodes[a] == null) { + nodes[a] = new TNode(a); + nodes[b].children.add(nodes[a]); + } else { + if (nodes[a] == null) { + nodes[a] = new TNode(a); + } + if (nodes[b] == null) { + nodes[b] = new TNode(b); + } + nodes[a].children.add(nodes[b]); + } + } + sizeOfTree(nodes[0]); + return count; + } + + private int sizeOfTree(TNode node) { + if (node.size > 0) { + return node.size; + } + List children = node.children; + if (children.isEmpty()) { + count++; + node.size = 1; + return 1; + } + int size = sizeOfTree(children.get(0)); + int sum = size; + boolean goodNode = true; + for (int i = 1; i < children.size(); ++i) { + TNode child = children.get(i); + if (size != sizeOfTree(child)) { + goodNode = false; + } + sum += sizeOfTree(child); + } + if (goodNode) { + count++; + } + sum++; + node.size = sum; + return sum; + } + + private static class TNode { + int val; + int size; + List children; + + TNode(int val) { + this.val = val; + this.size = -1; + this.children = new ArrayList<>(); + } + } +} diff --git a/src/main/java/g3201_3300/s3249_count_the_number_of_good_nodes/readme.md b/src/main/java/g3201_3300/s3249_count_the_number_of_good_nodes/readme.md new file mode 100644 index 000000000..f406a5b7f --- /dev/null +++ b/src/main/java/g3201_3300/s3249_count_the_number_of_good_nodes/readme.md @@ -0,0 +1,55 @@ +3249\. Count the Number of Good Nodes + +Medium + +There is an **undirected** tree with `n` nodes labeled from `0` to `n - 1`, and rooted at node `0`. You are given a 2D integer array `edges` of length `n - 1`, where edges[i] = [ai, bi] indicates that there is an edge between nodes ai and bi in the tree. + +A node is **good** if all the subtrees rooted at its children have the same size. + +Return the number of **good** nodes in the given tree. + +A **subtree** of `treeName` is a tree consisting of a node in `treeName` and all of its descendants. + +**Example 1:** + +**Input:** edges = [[0,1],[0,2],[1,3],[1,4],[2,5],[2,6]] + +**Output:** 7 + +**Explanation:** + +![](https://assets.leetcode.com/uploads/2024/05/26/tree1.png) + +All of the nodes of the given tree are good. + +**Example 2:** + +**Input:** edges = [[0,1],[1,2],[2,3],[3,4],[0,5],[1,6],[2,7],[3,8]] + +**Output:** 6 + +**Explanation:** + +![](https://assets.leetcode.com/uploads/2024/06/03/screenshot-2024-06-03-193552.png) + +There are 6 good nodes in the given tree. They are colored in the image above. + +**Example 3:** + +**Input:** edges = [[0,1],[1,2],[1,3],[1,4],[0,5],[5,6],[6,7],[7,8],[0,9],[9,10],[9,12],[10,11]] + +**Output:** 12 + +**Explanation:** + +![](https://assets.leetcode.com/uploads/2024/08/08/rob.jpg) + +All nodes except node 9 are good. + +**Constraints:** + +* 2 <= n <= 105 +* `edges.length == n - 1` +* `edges[i].length == 2` +* 0 <= ai, bi < n +* The input is generated such that `edges` represents a valid tree. \ No newline at end of file diff --git a/src/main/java/g3201_3300/s3250_find_the_count_of_monotonic_pairs_i/Solution.java b/src/main/java/g3201_3300/s3250_find_the_count_of_monotonic_pairs_i/Solution.java new file mode 100644 index 000000000..d12b68c57 --- /dev/null +++ b/src/main/java/g3201_3300/s3250_find_the_count_of_monotonic_pairs_i/Solution.java @@ -0,0 +1,41 @@ +package g3201_3300.s3250_find_the_count_of_monotonic_pairs_i; + +// #Hard #Array #Dynamic_Programming #Math #Prefix_Sum #Combinatorics +// #2024_08_13_Time_3_ms_(100.00%)_Space_44.7_MB_(99.34%) + +public class Solution { + public int countOfPairs(int[] nums) { + int[] maxShift = new int[nums.length]; + maxShift[0] = nums[0]; + int currShift = 0; + for (int i = 1; i < nums.length; i++) { + currShift = Math.max(currShift, nums[i] - maxShift[i - 1]); + maxShift[i] = Math.min(maxShift[i - 1], nums[i] - currShift); + if (maxShift[i] < 0) return 0; + } + int[][] cases = getAllCases(nums, maxShift); + return cases[nums.length - 1][maxShift[nums.length - 1]]; + } + + private int[][] getAllCases(int[] nums, int[] maxShift) { + int[] currCases; + int[][] cases = new int[nums.length][]; + cases[0] = new int[maxShift[0] + 1]; + for (int i = 0; i < cases[0].length; i++) { + cases[0][i] = i + 1; + } + for (int i = 1; i < nums.length; i++) { + currCases = new int[maxShift[i] + 1]; + currCases[0] = 1; + for (int j = 1; j < currCases.length; j++) { + int prevCases = + j < cases[i - 1].length + ? cases[i - 1][j] + : cases[i - 1][cases[i - 1].length - 1]; + currCases[j] = (currCases[j - 1] + prevCases) % (1_000_000_000 + 7); + } + cases[i] = currCases; + } + return cases; + } +} diff --git a/src/main/java/g3201_3300/s3250_find_the_count_of_monotonic_pairs_i/readme.md b/src/main/java/g3201_3300/s3250_find_the_count_of_monotonic_pairs_i/readme.md new file mode 100644 index 000000000..bab38cc45 --- /dev/null +++ b/src/main/java/g3201_3300/s3250_find_the_count_of_monotonic_pairs_i/readme.md @@ -0,0 +1,42 @@ +3250\. Find the Count of Monotonic Pairs I + +Hard + +You are given an array of **positive** integers `nums` of length `n`. + +We call a pair of **non-negative** integer arrays `(arr1, arr2)` **monotonic** if: + +* The lengths of both arrays are `n`. +* `arr1` is monotonically **non-decreasing**, in other words, `arr1[0] <= arr1[1] <= ... <= arr1[n - 1]`. +* `arr2` is monotonically **non-increasing**, in other words, `arr2[0] >= arr2[1] >= ... >= arr2[n - 1]`. +* `arr1[i] + arr2[i] == nums[i]` for all `0 <= i <= n - 1`. + +Return the count of **monotonic** pairs. + +Since the answer may be very large, return it **modulo** 109 + 7. + +**Example 1:** + +**Input:** nums = [2,3,2] + +**Output:** 4 + +**Explanation:** + +The good pairs are: + +1. `([0, 1, 1], [2, 2, 1])` +2. `([0, 1, 2], [2, 2, 0])` +3. `([0, 2, 2], [2, 1, 0])` +4. `([1, 2, 2], [1, 1, 0])` + +**Example 2:** + +**Input:** nums = [5,5,5,5] + +**Output:** 126 + +**Constraints:** + +* `1 <= n == nums.length <= 2000` +* `1 <= nums[i] <= 50` \ No newline at end of file diff --git a/src/main/java/g3201_3300/s3251_find_the_count_of_monotonic_pairs_ii/Solution.java b/src/main/java/g3201_3300/s3251_find_the_count_of_monotonic_pairs_ii/Solution.java new file mode 100644 index 000000000..01c90a936 --- /dev/null +++ b/src/main/java/g3201_3300/s3251_find_the_count_of_monotonic_pairs_ii/Solution.java @@ -0,0 +1,34 @@ +package g3201_3300.s3251_find_the_count_of_monotonic_pairs_ii; + +// #Hard #Array #Dynamic_Programming #Math #Prefix_Sum #Combinatorics +// #2024_08_13_Time_24_ms_(100.00%)_Space_44.7_MB_(97.70%) + +import java.util.Arrays; + +public class Solution { + private static final int MOD = 1000000007; + + public int countOfPairs(int[] nums) { + int prefixZeros = 0; + int n = nums.length; + // Calculate prefix zeros + for (int i = 1; i < n; i++) { + prefixZeros += Math.max(nums[i] - nums[i - 1], 0); + } + int row = n + 1; + int col = nums[n - 1] + 1 - prefixZeros; + if (col <= 0) { + return 0; + } + // Initialize dp array + int[] dp = new int[col]; + Arrays.fill(dp, 1); + // Fill dp array + for (int r = 1; r < row; r++) { + for (int c = 1; c < col; c++) { + dp[c] = (dp[c] + dp[c - 1]) % MOD; + } + } + return dp[col - 1]; + } +} diff --git a/src/main/java/g3201_3300/s3251_find_the_count_of_monotonic_pairs_ii/readme.md b/src/main/java/g3201_3300/s3251_find_the_count_of_monotonic_pairs_ii/readme.md new file mode 100644 index 000000000..171b2dfbf --- /dev/null +++ b/src/main/java/g3201_3300/s3251_find_the_count_of_monotonic_pairs_ii/readme.md @@ -0,0 +1,42 @@ +3251\. Find the Count of Monotonic Pairs II + +Hard + +You are given an array of **positive** integers `nums` of length `n`. + +We call a pair of **non-negative** integer arrays `(arr1, arr2)` **monotonic** if: + +* The lengths of both arrays are `n`. +* `arr1` is monotonically **non-decreasing**, in other words, `arr1[0] <= arr1[1] <= ... <= arr1[n - 1]`. +* `arr2` is monotonically **non-increasing**, in other words, `arr2[0] >= arr2[1] >= ... >= arr2[n - 1]`. +* `arr1[i] + arr2[i] == nums[i]` for all `0 <= i <= n - 1`. + +Return the count of **monotonic** pairs. + +Since the answer may be very large, return it **modulo** 109 + 7. + +**Example 1:** + +**Input:** nums = [2,3,2] + +**Output:** 4 + +**Explanation:** + +The good pairs are: + +1. `([0, 1, 1], [2, 2, 1])` +2. `([0, 1, 2], [2, 2, 0])` +3. `([0, 2, 2], [2, 1, 0])` +4. `([1, 2, 2], [1, 1, 0])` + +**Example 2:** + +**Input:** nums = [5,5,5,5] + +**Output:** 126 + +**Constraints:** + +* `1 <= n == nums.length <= 2000` +* `1 <= nums[i] <= 1000` \ No newline at end of file diff --git a/src/test/java/g3201_3300/s3248_snake_in_matrix/SolutionTest.java b/src/test/java/g3201_3300/s3248_snake_in_matrix/SolutionTest.java new file mode 100644 index 000000000..5c80547dc --- /dev/null +++ b/src/test/java/g3201_3300/s3248_snake_in_matrix/SolutionTest.java @@ -0,0 +1,20 @@ +package g3201_3300.s3248_snake_in_matrix; + +import static org.hamcrest.CoreMatchers.equalTo; +import static org.hamcrest.MatcherAssert.assertThat; + +import java.util.List; +import org.junit.jupiter.api.Test; + +class SolutionTest { + @Test + void finalPositionOfSnake() { + assertThat(new Solution().finalPositionOfSnake(2, List.of("RIGHT", "DOWN")), equalTo(3)); + } + + @Test + void finalPositionOfSnake2() { + assertThat( + new Solution().finalPositionOfSnake(3, List.of("DOWN", "RIGHT", "UP")), equalTo(1)); + } +} diff --git a/src/test/java/g3201_3300/s3249_count_the_number_of_good_nodes/SolutionTest.java b/src/test/java/g3201_3300/s3249_count_the_number_of_good_nodes/SolutionTest.java new file mode 100644 index 000000000..c10eb7e4a --- /dev/null +++ b/src/test/java/g3201_3300/s3249_count_the_number_of_good_nodes/SolutionTest.java @@ -0,0 +1,28 @@ +package g3201_3300.s3249_count_the_number_of_good_nodes; + +import static org.hamcrest.CoreMatchers.equalTo; +import static org.hamcrest.MatcherAssert.assertThat; + +import org.junit.jupiter.api.Test; + +class SolutionTest { + @Test + void countGoodNodes() { + assertThat( + new Solution() + .countGoodNodes( + new int[][] {{0, 1}, {0, 2}, {1, 3}, {1, 4}, {2, 5}, {2, 6}}), + equalTo(7)); + } + + @Test + void countGoodNodes2() { + assertThat( + new Solution() + .countGoodNodes( + new int[][] { + {0, 1}, {1, 2}, {2, 3}, {3, 4}, {0, 5}, {1, 6}, {2, 7}, {3, 8} + }), + equalTo(6)); + } +} diff --git a/src/test/java/g3201_3300/s3250_find_the_count_of_monotonic_pairs_i/SolutionTest.java b/src/test/java/g3201_3300/s3250_find_the_count_of_monotonic_pairs_i/SolutionTest.java new file mode 100644 index 000000000..7d5556091 --- /dev/null +++ b/src/test/java/g3201_3300/s3250_find_the_count_of_monotonic_pairs_i/SolutionTest.java @@ -0,0 +1,18 @@ +package g3201_3300.s3250_find_the_count_of_monotonic_pairs_i; + +import static org.hamcrest.CoreMatchers.equalTo; +import static org.hamcrest.MatcherAssert.assertThat; + +import org.junit.jupiter.api.Test; + +class SolutionTest { + @Test + void countOfPairs() { + assertThat(new Solution().countOfPairs(new int[] {2, 3, 2}), equalTo(4)); + } + + @Test + void countOfPairs2() { + assertThat(new Solution().countOfPairs(new int[] {5, 5, 5, 5}), equalTo(126)); + } +} diff --git a/src/test/java/g3201_3300/s3251_find_the_count_of_monotonic_pairs_ii/SolutionTest.java b/src/test/java/g3201_3300/s3251_find_the_count_of_monotonic_pairs_ii/SolutionTest.java new file mode 100644 index 000000000..1235688cb --- /dev/null +++ b/src/test/java/g3201_3300/s3251_find_the_count_of_monotonic_pairs_ii/SolutionTest.java @@ -0,0 +1,18 @@ +package g3201_3300.s3251_find_the_count_of_monotonic_pairs_ii; + +import static org.hamcrest.CoreMatchers.equalTo; +import static org.hamcrest.MatcherAssert.assertThat; + +import org.junit.jupiter.api.Test; + +class SolutionTest { + @Test + void countOfPairs() { + assertThat(new Solution().countOfPairs(new int[] {2, 3, 2}), equalTo(4)); + } + + @Test + void countOfPairs2() { + assertThat(new Solution().countOfPairs(new int[] {5, 5, 5, 5}), equalTo(126)); + } +} From f3548a8aec914ccd6a8acf487e480d57acfb94db Mon Sep 17 00:00:00 2001 From: Valentyn Kolesnikov Date: Tue, 13 Aug 2024 07:14:32 +0300 Subject: [PATCH 2/6] Fixed style --- .../s3248_snake_in_matrix/Solution.java | 16 ++++++++++++---- .../Solution.java | 4 +++- 2 files changed, 15 insertions(+), 5 deletions(-) diff --git a/src/main/java/g3201_3300/s3248_snake_in_matrix/Solution.java b/src/main/java/g3201_3300/s3248_snake_in_matrix/Solution.java index ccf9cbfe1..b1c591f91 100644 --- a/src/main/java/g3201_3300/s3248_snake_in_matrix/Solution.java +++ b/src/main/java/g3201_3300/s3248_snake_in_matrix/Solution.java @@ -11,16 +11,24 @@ public int finalPositionOfSnake(int n, List commands) { for (String command : commands) { switch (command) { case "UP": - if (x > 0) x--; + if (x > 0) { + x--; + } break; case "DOWN": - if (x < n - 1) x++; + if (x < n - 1) { + x++; + } break; case "LEFT": - if (y > 0) y--; + if (y > 0) { + y--; + } break; case "RIGHT": - if (y < n - 1) y++; + if (y < n - 1) { + y++; + } break; } } diff --git a/src/main/java/g3201_3300/s3250_find_the_count_of_monotonic_pairs_i/Solution.java b/src/main/java/g3201_3300/s3250_find_the_count_of_monotonic_pairs_i/Solution.java index d12b68c57..93292712a 100644 --- a/src/main/java/g3201_3300/s3250_find_the_count_of_monotonic_pairs_i/Solution.java +++ b/src/main/java/g3201_3300/s3250_find_the_count_of_monotonic_pairs_i/Solution.java @@ -11,7 +11,9 @@ public int countOfPairs(int[] nums) { for (int i = 1; i < nums.length; i++) { currShift = Math.max(currShift, nums[i] - maxShift[i - 1]); maxShift[i] = Math.min(maxShift[i - 1], nums[i] - currShift); - if (maxShift[i] < 0) return 0; + if (maxShift[i] < 0) { + return 0; + } } int[][] cases = getAllCases(nums, maxShift); return cases[nums.length - 1][maxShift[nums.length - 1]]; From 818985e9dd1c3ed2557a29e9adc59be9854f8b69 Mon Sep 17 00:00:00 2001 From: Valentyn Kolesnikov Date: Tue, 13 Aug 2024 07:16:47 +0300 Subject: [PATCH 3/6] Fixed sonar --- src/main/java/g3201_3300/s3248_snake_in_matrix/Solution.java | 1 + 1 file changed, 1 insertion(+) diff --git a/src/main/java/g3201_3300/s3248_snake_in_matrix/Solution.java b/src/main/java/g3201_3300/s3248_snake_in_matrix/Solution.java index b1c591f91..b0ee31b7a 100644 --- a/src/main/java/g3201_3300/s3248_snake_in_matrix/Solution.java +++ b/src/main/java/g3201_3300/s3248_snake_in_matrix/Solution.java @@ -29,6 +29,7 @@ public int finalPositionOfSnake(int n, List commands) { if (y < n - 1) { y++; } + default: break; } } From 4febd8eeb9a39bdeaf443a7cf8069332577c199e Mon Sep 17 00:00:00 2001 From: Valentyn Kolesnikov Date: Tue, 13 Aug 2024 07:22:54 +0300 Subject: [PATCH 4/6] Added tests --- .../s3248_snake_in_matrix/SolutionTest.java | 57 +++++++++++++++++++ 1 file changed, 57 insertions(+) diff --git a/src/test/java/g3201_3300/s3248_snake_in_matrix/SolutionTest.java b/src/test/java/g3201_3300/s3248_snake_in_matrix/SolutionTest.java index 5c80547dc..91a662e1b 100644 --- a/src/test/java/g3201_3300/s3248_snake_in_matrix/SolutionTest.java +++ b/src/test/java/g3201_3300/s3248_snake_in_matrix/SolutionTest.java @@ -2,6 +2,7 @@ import static org.hamcrest.CoreMatchers.equalTo; import static org.hamcrest.MatcherAssert.assertThat; +import static org.junit.jupiter.api.Assertions.assertEquals; import java.util.List; import org.junit.jupiter.api.Test; @@ -17,4 +18,60 @@ void finalPositionOfSnake2() { assertThat( new Solution().finalPositionOfSnake(3, List.of("DOWN", "RIGHT", "UP")), equalTo(1)); } + + @Test + void testFinalPositionOfSnake_AllCommands() { + List commands = List.of("UP", "DOWN", "LEFT", "RIGHT"); + int result = new Solution().finalPositionOfSnake(3, commands); + assertEquals(4, result); + } + + @Test + void testFinalPositionOfSnake_OnlyUp() { + List commands = List.of("UP", "UP"); + int result = new Solution().finalPositionOfSnake(3, commands); + assertEquals(0, result); + } + + @Test + void testFinalPositionOfSnake_OnlyDown() { + List commands = List.of("DOWN", "DOWN"); + int result = new Solution().finalPositionOfSnake(3, commands); + assertEquals(6, result); + } + + @Test + void testFinalPositionOfSnake_OnlyLeft() { + List commands = List.of("LEFT", "LEFT"); + int result = new Solution().finalPositionOfSnake(3, commands); + assertEquals(0, result); + } + + @Test + void testFinalPositionOfSnake_OnlyRight() { + List commands = List.of("RIGHT", "RIGHT"); + int result = new Solution().finalPositionOfSnake(3, commands); + assertEquals(2, result); + } + + @Test + void testFinalPositionOfSnake_EmptyCommands() { + List commands = List.of(); + int result = new Solution().finalPositionOfSnake(3, commands); + assertEquals(0, result); + } + + @Test + void testFinalPositionOfSnake_MixedCommands() { + List commands = List.of("DOWN", "RIGHT", "UP", "LEFT", "UP", "DOWN", "RIGHT"); + int result = new Solution().finalPositionOfSnake(3, commands); + assertEquals(4, result); + } + + @Test + void testFinalPositionOfSnake_InvalidCommands() { + List commands = List.of("DOWN", "RIGHT", "JUMP", "LEFT", "UP", "DOWN", "RIGHT"); + int result = new Solution().finalPositionOfSnake(3, commands); + assertEquals(4, result); + } } From de64e9f050101838a78a8d6ac5832a2836565f22 Mon Sep 17 00:00:00 2001 From: Valentyn Kolesnikov Date: Tue, 13 Aug 2024 07:24:12 +0300 Subject: [PATCH 5/6] Fixed sonar --- src/main/java/g3201_3300/s3248_snake_in_matrix/Solution.java | 1 + 1 file changed, 1 insertion(+) diff --git a/src/main/java/g3201_3300/s3248_snake_in_matrix/Solution.java b/src/main/java/g3201_3300/s3248_snake_in_matrix/Solution.java index b0ee31b7a..9fc56a2f2 100644 --- a/src/main/java/g3201_3300/s3248_snake_in_matrix/Solution.java +++ b/src/main/java/g3201_3300/s3248_snake_in_matrix/Solution.java @@ -29,6 +29,7 @@ public int finalPositionOfSnake(int n, List commands) { if (y < n - 1) { y++; } + break; default: break; } From 27246a2832eaae725eb857822c558d8980c16c2b Mon Sep 17 00:00:00 2001 From: Valentyn Kolesnikov Date: Tue, 13 Aug 2024 07:26:00 +0300 Subject: [PATCH 6/6] Fixed style --- .../s3248_snake_in_matrix/SolutionTest.java | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/src/test/java/g3201_3300/s3248_snake_in_matrix/SolutionTest.java b/src/test/java/g3201_3300/s3248_snake_in_matrix/SolutionTest.java index 91a662e1b..2e69699c8 100644 --- a/src/test/java/g3201_3300/s3248_snake_in_matrix/SolutionTest.java +++ b/src/test/java/g3201_3300/s3248_snake_in_matrix/SolutionTest.java @@ -20,56 +20,56 @@ void finalPositionOfSnake2() { } @Test - void testFinalPositionOfSnake_AllCommands() { + void testFinalPositionOfSnakeAllCommands() { List commands = List.of("UP", "DOWN", "LEFT", "RIGHT"); int result = new Solution().finalPositionOfSnake(3, commands); assertEquals(4, result); } @Test - void testFinalPositionOfSnake_OnlyUp() { + void testFinalPositionOfSnakeOnlyUp() { List commands = List.of("UP", "UP"); int result = new Solution().finalPositionOfSnake(3, commands); assertEquals(0, result); } @Test - void testFinalPositionOfSnake_OnlyDown() { + void testFinalPositionOfSnakeOnlyDown() { List commands = List.of("DOWN", "DOWN"); int result = new Solution().finalPositionOfSnake(3, commands); assertEquals(6, result); } @Test - void testFinalPositionOfSnake_OnlyLeft() { + void testFinalPositionOfSnakeOnlyLeft() { List commands = List.of("LEFT", "LEFT"); int result = new Solution().finalPositionOfSnake(3, commands); assertEquals(0, result); } @Test - void testFinalPositionOfSnake_OnlyRight() { + void testFinalPositionOfSnakeOnlyRight() { List commands = List.of("RIGHT", "RIGHT"); int result = new Solution().finalPositionOfSnake(3, commands); assertEquals(2, result); } @Test - void testFinalPositionOfSnake_EmptyCommands() { + void testFinalPositionOfSnakeEmptyCommands() { List commands = List.of(); int result = new Solution().finalPositionOfSnake(3, commands); assertEquals(0, result); } @Test - void testFinalPositionOfSnake_MixedCommands() { + void testFinalPositionOfSnakeMixedCommands() { List commands = List.of("DOWN", "RIGHT", "UP", "LEFT", "UP", "DOWN", "RIGHT"); int result = new Solution().finalPositionOfSnake(3, commands); assertEquals(4, result); } @Test - void testFinalPositionOfSnake_InvalidCommands() { + void testFinalPositionOfSnakeInvalidCommands() { List commands = List.of("DOWN", "RIGHT", "JUMP", "LEFT", "UP", "DOWN", "RIGHT"); int result = new Solution().finalPositionOfSnake(3, commands); assertEquals(4, result);