Strong Number Using Indirect recursion

Java/README.md

@@ -100,6 +100,7 @@ _add list here_
 - [Sieve of Eratosthenes](math/SieveOfEratosthenes.java)
 - [Catalan Number](math/CatalanNumber.java)
 - [Palindrome Number Using Recursion](math/PalindromeRecursion.java)
+- [Strong Number Using Recursion](math/check_strong_number.java)
 
 ## Dynamic Programming
 
@@ -140,6 +141,7 @@ _add list here_
 - [Quick Sort](sort/QuickSort.java)
 - [Selection Sort](sort/SelectionSort.java)
 - [Merge Sort Using Recursion](sort/MergeSortRecursion.java)
+- [Bucket Sort Using Hash](sort/Bucket_Sort.java)
 
 ## Machine Learning
 

Java/math/check_strong_number.java

@@ -0,0 +1,50 @@
+
+/*
+Checking for a strong number using indirect recursion
+Strong Number = 145
+1! + 4! + 5! =145
+sumOfFactorialOfDigit(int n) - extracts digit of n and calls factorial(n). Returns sum of factorial of digits
+factorial(n)- returns factorial of extracted digits passed in the argument
+*/
+
+import java.util.*;
+class check_strong_number {
+    /*recursive function for sum of factorial of digits*/
+    public static int sumOfFactorialOfDigit(int n)
+
+    {
+        if (n == 0)
+            return n;
+        else
+            return (factorial(n % 10) + sumOfFactorialOfDigit(n / 10));
+
+    }
+    /*recursive function to find the factorial of n */
+    public static int factorial(int n) {
+        if (n == 0)
+            return 1;
+        else
+            return (n * factorial(n - 1));
+    }
+
+    public static void main() {
+        Scanner sc = new Scanner(System.in);
+        System.out.print(" Enter Number. N = ");
+        int num = sc.nextInt();
+        if (num == sumOfFactorialOfDigit(num))
+            System.out.println(" It is a Strong Number");
+        else
+            System.out.println(" It is not a Strong Number");
+    }
+}
+
+/*
+Sample Input And Output :
+N = 145
+It is a Strong Number
+N = 534
+It is not a Strong Number
+
+Time Complexity : O(n)
+Space Complexity : 1
+*/

Java/sort/Bucket_Sort.java

@@ -0,0 +1,55 @@
+/* Sorting floating point numbers in ascending order betweent the range of 0.0 to 0.1 by bucket sort
+   hash(float value) : Returns the value of key multiplied with 10
+   bucket_sorting(float[] list) : Creates 10 bucktes and sorts them */
+import java.util.*;
+class Bucket_Sort {
+    /* Multiplying each value of the array with 10*/
+    public static float hash(float value) {
+        return value * 10;
+    }
+    public static List < Float > bucket_sorting(float[] list) {
+        /* The bucket sorted array*/
+        List < Float > sorted = new ArrayList < > ();
+        //Creates 10 bucktes
+        List < List < Float >> buckets = new ArrayList < > (10);
+        for (int i = 0; i < 10; i++)
+            buckets.add(new ArrayList < > ());
+        // inputting values in buckets depending on values from list
+        for (float values: list) {
+            float key = hash(values);
+            buckets.get((int) key).add(values);
+
+        }
+        //sorting individual buckets and adding them 
+        for (int i = 0; i < buckets.size(); i++) {
+            if (buckets.get(i) != null) {
+                Collections.sort(buckets.get(i));
+                sorted.addAll(buckets.get(i));
+            }
+        }
+        return sorted;
+    }
+    public static void main(String args[]) {
+        Scanner sc = new Scanner(System.in);
+        System.out.print(" Enter size of array. N = ");
+        int n = sc.nextInt();
+        float arr[] = new float[n];
+        System.out.println(" Enter the elements of the array");
+        for (int i = 0; i < n; i++)
+            arr[i] = sc.nextFloat();
+        System.out.println("Sorted array : " + "\n" + bucket_sorting(arr));
+    }
+}
+
+/* Sample Input and Output :
+ * Enter size of array. N = 5
+ Enter the elements of the array
+0.5 0.4 0.3 0.2 0.6
+Sorted array : 
+[0.2, 0.3, 0.4, 0.5, 0.6]
+
+Worst Time Complexity : O(n^2)
+Average Time Complexity : O(n)
+
+Space Complexity : O(1)
+ */