Fixes(#2877)

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

@@ -1,54 +1,45 @@
-package com.thealgorithms.dynamicprogramming;
+/** Author : Siddhant Swarup Mallick
+ * Github : https://github.com/siddhant2002
+ */
 
-import java.util.Scanner;
+/** Program description - To find the maximum subarray sum */
+ package com.thealgorithms.dynamicprogramming;
 
-/**
- * Program to implement Kadane’s Algorithm to calculate maximum contiguous
- * subarray sum of an array Time Complexity: O(n)
- *
- * @author Nishita Aggarwal
- */
 public class KadaneAlgorithm {
-
-    /**
-     * This method implements Kadane's Algorithm
-     *
-     * @param arr The input array
-     * @return The maximum contiguous subarray sum of the array
-     */
-    static int largestContiguousSum(int arr[]) {
-        int i, len = arr.length, cursum = 0, maxsum = Integer.MIN_VALUE;
-        if (len == 0) // empty array
+    public static boolean max_Sum(int a[])
+    {
+        int sum=a[0],running_sum=0;
+        for(int k:a)
         {
-            return 0;
-        }
-        for (i = 0; i < len; i++) {
-            cursum += arr[i];
-            if (cursum > maxsum) {
-                maxsum = cursum;
-            }
-            if (cursum <= 0) {
-                cursum = 0;
-            }
+            running_sum=running_sum+k;
+            // running sum of all the indexs are stored
+            sum=Math.max(sum,running_sum);
+            // the max is stored inorder to the get the maximum sum
+            if(running_sum<0)
+            running_sum=0;
+            // if running sum is negative then it is initialized to zero
         }
-        return maxsum;
+        // for-each loop is used to iterate over the array and find the maximum subarray sum
+        return task(a,sum);
+        // the max_Sum method returns true if the "sub array sum" matches with the "sum of all the elements present in the array" else it returns false
     }
-
     /**
-     * Main method
-     *
-     * @param args Command line arguments
+     * OUTPUT :
+     * Input - {89,56,98,123,26,75,12,40,39,68,91}
+     * Output: it returns either true or false
+     * 1st approach Time Complexity : O(n)
+     * Auxiliary Space Complexity : O(1)
      */
-    public static void main(String[] args) {
-        Scanner sc = new Scanner(System.in);
-        int n, arr[], i;
-        n = sc.nextInt();
-        arr = new int[n];
-        for (i = 0; i < n; i++) {
-            arr[i] = sc.nextInt();
+    static boolean task(int a[] , int s)
+    {
+        int p=0;
+        // p is created inorder to store the sum of the elements present in the array
+        for(int i:a)
+        {
+            p=p+i;
         }
-        int maxContSum = largestContiguousSum(arr);
-        System.out.println(maxContSum);
-        sc.close();
+        // for-each loop is initialized inorder to get the sum of all the elements of the array
+        return p==s;
+        // the task method adds all the elements of the array and checks it with the "maximum subarray sum". If the sum is equal then it returns true else it returns false
     }
 }

src/test/java/com/thealgorithms/others/KadaneAlogrithmTest.java

@@ -0,0 +1,63 @@
+package com.thealgorithms.others;
+import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.*;
+
+import com.thealgorithms.dynamicprogramming.KadaneAlgorithm;
+public class KadaneAlogrithmTest {
+    @Test
+	void testForOneElement() 
+	{
+        int a[]={-1};
+		assertTrue(KadaneAlgorithm.max_Sum(a));
+	}
+
+	@Test
+	void testForTwoElements() 
+	{
+        int a[]={-2,1};
+		assertFalse(KadaneAlgorithm.max_Sum(a));
+	}
+
+	@Test
+	void testForThreeElements() 
+	{
+		int a[]={5,3,12};
+		assertTrue(KadaneAlgorithm.max_Sum(a));
+	}
+
+	@Test
+	void testForFourElements() 
+	{
+		int a[]={-1,-3,-7,-4};
+		assertFalse(KadaneAlgorithm.max_Sum(a));
+	}
+
+	@Test
+	void testForFiveElements() 
+	{
+		int a[]={4,5,3,0,2};
+		assertTrue(KadaneAlgorithm.max_Sum(a));
+	}
+
+
+	@Test
+	void testForSixElements() 
+	{
+		int a[]={-43,-45,47,12,87,-13};
+		assertFalse(KadaneAlgorithm.max_Sum(a));
+	}
+
+	@Test
+	void testForSevenElements() 
+	{
+		int a[]={9,8,2,23,13,6,7};
+		assertTrue(KadaneAlgorithm.max_Sum(a));
+    }
+
+	@Test
+	void testForEightElements() 
+	{
+		int a[]={9,-5,-5,-2,4,5,0,1};
+		assertFalse(KadaneAlgorithm.max_Sum(a));
+	}
+}