Update the formatting SherLockAndCost.java & SherLockAndCostTest.java

Author: GouthamGuna

src/main/java/com/thealgorithms/dynamicprogramming/SherLockAndCost.java

@@ -11,40 +11,46 @@
 
 public final class SherLockAndCost {
 
-    /**
-     * This method takes a list of integers as input and returns the maximum possible sum of absolute differences between adjacent elements in the array.
-     *
-     * @param list the input list of integers
-     * @return the maximum possible sum of absolute differences between adjacent elements in the array
-     * <p></p>
-     * Approach:
-     * I can use dynamic programming to solve this problem efficiently. Let’s break down the approach:
-     * <p>
-     * 1.) Initialize two arrays: dp[i][0] and dp[i][1]. These arrays will store the maximum sum of absolute differences for the first i elements of the input array.
-     * 2.) Iterate through the input array from left to right:
-     * Update dp[i][0] and dp[i][1] based on the previous values and the current element.
-     * 3.) The final answer is the maximum value between dp[N-1][0] and dp[N-1][1].
-     * 4.) The time complexity of this method is O(N), where N is the length of the input list.
-     */
-    public static int sherlockAndCostProblem(List<Integer> list) {
-
-        if (list == null || list.isEmpty()) {
-            return 0;
-        }
-
-        int N = list.size();
-        int[][] dp = new int[N][2];
-        dp[0][0] = 0;
-        dp[0][1] = 0;
-
-        for (int i = 1; i < N; i++) {
-            int curr = list.get(i);
-            int prev = list.get(i - 1);
-
-            dp[i][0] = Math.max(dp[i - 1][0], dp[i - 1][1] + prev - 1);
-            dp[i][1] = Math.max(dp[i - 1][1], dp[i - 1][0] + curr - 1);
-        }
-
-        return Math.max(dp[N - 1][0], dp[N - 1][1]);
-    }
+	/**
+	 * This method takes a list of integers as input and returns the maximum
+	 * possible sum of absolute differences between adjacent elements in the array.
+	 *
+	 * @param list
+	 *            the input list of integers
+	 * @return the maximum possible sum of absolute differences between adjacent
+	 *         elements in the array
+	 *         <p>
+	 *         </p>
+	 *         Approach: I can use dynamic programming to solve this problem
+	 *         efficiently. Let’s break down the approach:
+	 *         <p>
+	 *         1.) Initialize two arrays: dp[i][0] and dp[i][1]. These arrays will
+	 *         store the maximum sum of absolute differences for the first i
+	 *         elements of the input array. 2.) Iterate through the input array from
+	 *         left to right: Update dp[i][0] and dp[i][1] based on the previous
+	 *         values and the current element. 3.) The final answer is the maximum
+	 *         value between dp[N-1][0] and dp[N-1][1]. 4.) The time complexity of
+	 *         this method is O(N), where N is the length of the input list.
+	 */
+	public static int sherlockAndCostProblem(List<Integer> list) {
+
+		if (list == null || list.isEmpty()) {
+			return 0;
+		}
+
+		int N = list.size();
+		int[][] dp = new int[N][2];
+		dp[0][0] = 0;
+		dp[0][1] = 0;
+
+		for (int i = 1; i < N; i++) {
+			int curr = list.get(i);
+			int prev = list.get(i - 1);
+
+			dp[i][0] = Math.max(dp[i - 1][0], dp[i - 1][1] + prev - 1);
+			dp[i][1] = Math.max(dp[i - 1][1], dp[i - 1][0] + curr - 1);
+		}
+
+		return Math.max(dp[N - 1][0], dp[N - 1][1]);
+	}
 }

src/test/java/com/thealgorithms/dynamicprogramming/SherLockAndCostTest.java

@@ -10,51 +10,51 @@
 
 public class SherLockAndCostTest {
 
-    @Test
-    public void testPositiveIntegers() {
-        List<Integer> inputList = Arrays.asList(1, 2, 3, 4, 5);
-        int result = SherLockAndCost.sherlockAndCostProblem(inputList);
-        assertEquals(8, result);
-    }
-
-    @Test
-    public void testNegativeInteger() {
-        List<Integer> list = Arrays.asList(-1, -2, -3, -4, -5);
-        int result = SherLockAndCost.sherlockAndCostProblem(list);
-        assertEquals(0, result);
-    }
-
-    @Test
-    public void testMixedElements() {
-        List<Integer> list = Arrays.asList(-1, 1);
-        int result = SherLockAndCost.sherlockAndCostProblem(list);
-        assertEquals(0, result);
-    }
-
-    @Test
-    public void testEdge() {
-        List<Integer> list = Arrays.asList(-1, 2, 3, 4, 5);
-        int result = SherLockAndCost.sherlockAndCostProblem(list);
-        assertEquals(8, result);
-    }
-
-    @Test
-    public void testNullElements() {
-        List<Integer> list = Arrays.asList(null, null, null, null);
-        assertThrows(NullPointerException.class, () -> SherLockAndCost.sherlockAndCostProblem(list));
-    }
-
-    @Test
-    public void testEmptyList() {
-        List<Integer> list = Arrays.asList();
-        int result = SherLockAndCost.sherlockAndCostProblem(list);
-        assertEquals(0, result);
-    }
-
-    @Test
-    public void testSingleFList() {
-        List<Integer> list = Arrays.asList(500);
-        int result = SherLockAndCost.sherlockAndCostProblem(list);
-        assertEquals(0, result);
-    }
+	@Test
+	public void testPositiveIntegers() {
+		List<Integer> inputList = Arrays.asList(1, 2, 3, 4, 5);
+		int result = SherLockAndCost.sherlockAndCostProblem(inputList);
+		assertEquals(8, result);
+	}
+
+	@Test
+	public void testNegativeInteger() {
+		List<Integer> list = Arrays.asList(-1, -2, -3, -4, -5);
+		int result = SherLockAndCost.sherlockAndCostProblem(list);
+		assertEquals(0, result);
+	}
+
+	@Test
+	public void testMixedElements() {
+		List<Integer> list = Arrays.asList(-1, 1);
+		int result = SherLockAndCost.sherlockAndCostProblem(list);
+		assertEquals(0, result);
+	}
+
+	@Test
+	public void testEdge() {
+		List<Integer> list = Arrays.asList(-1, 2, 3, 4, 5);
+		int result = SherLockAndCost.sherlockAndCostProblem(list);
+		assertEquals(8, result);
+	}
+
+	@Test
+	public void testNullElements() {
+		List<Integer> list = Arrays.asList(null, null, null, null);
+		assertThrows(NullPointerException.class, () -> SherLockAndCost.sherlockAndCostProblem(list));
+	}
+
+	@Test
+	public void testEmptyList() {
+		List<Integer> list = Arrays.asList();
+		int result = SherLockAndCost.sherlockAndCostProblem(list);
+		assertEquals(0, result);
+	}
+
+	@Test
+	public void testSingleFList() {
+		List<Integer> list = Arrays.asList(500);
+		int result = SherLockAndCost.sherlockAndCostProblem(list);
+		assertEquals(0, result);
+	}
 }