Updated RadixSort code which will work for negative and positive numbers, also updated few files which failed during build failure

Author: saswata121924

Armstrong.java

@@ -1,26 +1,53 @@
-import java.util.*;
-class Armstrong
-{
-   public static void main(String args[])
-	 {
-	    Scanner sc=new Scanner(System.in);
-		  System.out.println("Enter a no.:");
-		  int a=sc.nextInt();
-		  int r,sum=0,temp;
-		  temp=a;
-		  while(a>0)
-		  {
-		     r=a%10;
-	       sum=(r*r*r)+sum;
-		     a=a/10;
-		  }
-		  if(temp==sum)
-		  {
-		     System.out.println("Armstrong no.");
-		  }
-		  else
-		  {
-		     System.out.println("not an armstrng no.");
-		  }   
-	 }
+// Java program to determine whether 
+// the number is Armstrong number or not
+public class Armstrong {
+	
+	// Function to calculate x raised 
+	// to the power y 
+	int power(int x, long y)
+	{
+		if (y == 0)
+			return 1;
+		if (y % 2 == 0)
+			return power(x, y / 2) * power(x, y / 2);
+		return x * power(x, y / 2) * power(x, y / 2);
+	}
+
+	// Function to calculate order of the number 
+	int order(int x)
+	{
+		int n = 0;
+		while (x != 0) {
+			n++;
+			x = x / 10;
+		}
+		return n;
+	}
+
+	// Function to check whether the given 
+	// number is Armstrong number or not
+	boolean isArmstrong(int x)
+	{
+		// Calling order function
+		int n = order(x);
+		int temp = x, sum = 0;
+		while (temp != 0) {
+			int r = temp % 10;
+			sum = sum + power(r, n);
+			temp = temp / 10;
+		}
+
+		// If satisfies Armstrong condition
+		return (sum == x);
+	}
+
+	// Driver Code
+	public static void main(String[] args)
+	{
+		Armstrong ob = new Armstrong();
+		int x = 153;
+		System.out.println(ob.isArmstrong(x));
+		x = 1253;
+		System.out.println(ob.isArmstrong(x));
+	}
 }

Java-problem-2023.iml

@@ -8,4 +8,7 @@
     <orderEntry type="inheritedJdk" />
     <orderEntry type="sourceFolder" forTests="false" />
   </component>
+  <component name="SonarLintModuleSettings">
+    <option name="uniqueId" value="13b23f24-718d-44ac-bde8-fcc80fed13a1" />
+  </component>
 </module>

RadixSort.java

@@ -1,79 +1,92 @@
-// Radix sort Java implementation
+// Radix Sort implementation
 
 import java.util.Arrays;
 
-class RadixSort {
-
-    // A utility function to get maximum value in arr[]
-    static int getMax(int arr[], int n)
-    {
-        int mx = arr[0];
-        for (int i = 1; i < n; i++)
-            if (arr[i] > mx)
-                mx = arr[i];
-        return mx;
+public class RadixSort {
+    private static final int BASE = 10;
+    public static void main(String[] args) {
+        int[] arr = new int[]{1, -2, -456, 803, 1000, -2033, -9, 0, 10};
+        long startTime = System.currentTimeMillis();
+        System.out.println("Original Array: " + Arrays.toString(arr));
+        radixSort(arr);
+        long endTime = System.currentTimeMillis();
+        System.out.println("Sorted Array: " + Arrays.toString(arr) + "\nTime taken: " +
+                ((endTime-startTime)*0.001)+" seconds");
     }
-
-    // A function to do counting sort of arr[] according to
-    // the digit represented by exp.
-    static void countSort(int arr[], int n, int exp)
-    {
-        int output[] = new int[n]; // output array
-        int i;
-        int count[] = new int[10];
-        Arrays.fill(count, 0);
-
-        // Store count of occurrences in count[]
-        for (i = 0; i < n; i++)
-            count[(arr[i] / exp) % 10]++;
-
-        // Change count[i] so that count[i] now contains
-        // actual position of this digit in output[]
-        for (i = 1; i < 10; i++)
-            count[i] += count[i - 1];
-
-        // Build the output array
-        for (i = n - 1; i >= 0; i--) {
-            output[count[(arr[i] / exp) % 10] - 1] = arr[i];
-            count[(arr[i] / exp) % 10]--;
+    private static void radixSort(int[] arr){
+        if(arr.length==0)
+            return;
+        // Initialising these arrays for sorting the negative and the positive elements separately.
+        int[] positive = Arrays.stream(arr).filter(i -> i>=0).toArray();
+        int[] negative = Arrays.stream(arr).filter(i -> i<0).toArray();
+        if(positive.length>0){
+            int max = positive[0];
+            // Find the maximum value present
+            for (int j : positive) {
+                max = Math.max(max, j);
+            }
+            // Looping through the elements and applying Counting Sort based on the number of digits
+            // present in the maximum element
+            for(int exp=1; max/exp>0; exp*=10){
+                countingSort(positive, positive.length, exp);
+            }
+        }
+        if(negative.length>0){
+            // Converting the negative elements in the array to positive for sorting purpose
+            for(int i=0; i<negative.length; i++){
+                negative[i] *= -1;
+            }
+            // Find the maximum value present
+            int max = negative[0];
+            for (int j : negative) {
+                max = Math.max(max, j);
+            }
+            // Looping through the elements and applying Counting Sort based on the number of digits
+            // present in the maximum element
+            for(int exp=1; max/exp>0; exp*=BASE){
+                countingSort(negative, negative.length, exp);
+            }
+        }
+        int index = 0;
+        // Including the negative elements in the reverse order since (-9 < -1) &
+        // the negative elements were sorted based on the absolute values of the elements in the array
+        for (int i= negative.length-1; i>=0; i--) {
+            arr[index++] = -negative[i];
+        }
+        // Appending the positive elements after the negative elements in the array
+        for (int j : positive) {
+            arr[index++] = j;
         }
-
-        // Copy the output array to arr[], so that arr[] now
-        // contains sorted numbers according to current
-        // digit
-        for (i = 0; i < n; i++)
-            arr[i] = output[i];
-    }
-
-    // The main function to that sorts arr[] of
-    // size n using Radix Sort
-    static void radixsort(int arr[], int n)
-    {
-        // Find the maximum number to know number of digits
-        int m = getMax(arr, n);
-
-        // Do counting sort for every digit. Note that
-        // instead of passing digit number, exp is passed.
-        // exp is 10^i where i is current digit number
-        for (int exp = 1; m / exp > 0; exp *= 10)
-            countSort(arr, n, exp);
-    }
-
-    // A utility function to print an array
-    static void print(int arr[], int n)
-    {
-        for (int i = 0; i < n; i++)
-            System.out.print(arr[i] + " ");
     }
-
-    // Main driver method
-    public static void main(String[] args)
-    {
-        int arr[] = { 170, 45, 75, 90, 802, 24, 2, 66 };
-        int n = arr.length;
-
-        // Function Call
-        radixsort(arr, n);
-        print(arr, n);
+    private static void countingSort(int[] arr, int n, int exp){
+        // Initialising the count array with size = BASE
+        int[] count = new int[BASE];
+        // Initialising the output array with size = number of elements in positive or negative array
+        int[] output = new int[n];
+        // Counting the frequency of the numbers < BASE i.e. from [0..9] in this case
+        for (int j : arr) {
+            count[(j / exp) % BASE]++;
+        }
+        // Calculate cumulative count
+        for(int i=1; i<BASE; i++){
+            count[i] += count[i-1];
+        }
+        // Building the output array
+        for(int i=n-1; i>=0; i--){
+            output[count[(arr[i]/exp)%BASE]-1] = arr[i];
+            count[(arr[i]/exp)%BASE]--;
+        }
+        // Copying the array elements present in output array to the original array
+        System.arraycopy(output, 0, arr, 0, n);
     }
 }
+
+/*
+Time Complexity: O(d*(n+b)), d = number of digits
+                             n = number of elements in the array
+                             b = the base of the number system being used which is 10 here,
+                                 this can be taken as 20, 30 anything based on the range of elements present,
+                                 but the larger the base the more space will be required.
+Auxiliary Space Complexity: O(n+b), n = number of elements
+                                    b = base of the number system being used which is 10 here
+*/

armstrong.java

@@ -63,10 +63,3 @@ public static void main(String[] args) {
 Calls the floydWarshall method to compute and print the shortest distances between all pairs of nodes in the graph.
 The Floyd-Warshall algorithm is used to find the shortest paths between all pairs of vertices in a weighted graph, including both positive and negative edge weights. It is suitable for finding the shortest paths in dense graphs or when the graph's structure changes over time.*/
 
-
-
-
-
-
-Regenerate
-

ComplexNo_add.java renamed to complexNo.java

@@ -1,3 +1,7 @@
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
 class concatinate_word_problem {
     class Trie{
         Trie[] children;
@@ -34,7 +38,7 @@ private boolean searchWord(String words, int count){
         return (count >1 && node.isWord) ? true : false;
     }
     public List<String> findAllConcatenatedWordsInADict(String[] words) {
-        Arrays.sort(words, (a,b)-> a.length()-b.length());
+        Arrays.sort(words, (a, b)-> a.length()-b.length());
         ArrayList<String> result = new ArrayList<>();
 
         for(String word : words){

graph/algorithms/FloydWarshallAlgorithm.java

@@ -1,8 +1,8 @@
-//Problem Statement: https://leetcode.com/problems/find-first-and-last-position-of-element-in-sorted-array/?envType=daily-question&envId=2023-10-09
+package java.solution;//Problem Statement: https://leetcode.com/problems/find-first-and-last-position-of-element-in-sorted-array/?envType=daily-question&envId=2023-10-09
 // Topic: Binary Search 
 
 class Solution {
-    //flag == true      ====>   we are searching first occourance else otherwise
+    //flag == true      ====>   we are searching first occurrence else otherwise
     public int[] searchRange(int[] nums, int target) {
         return new int[] {helper(nums, target, true), helper(nums, target, false)};       
     }