Merge pull request #1301 from BenSchokoRiegel/master

Implementing AmicableNumber and VampireNumbers in the Math class

Maths/AmicableNumber.java

@@ -0,0 +1,87 @@
+package Maths;
+
+/**
+ * Amicable numbers are two different numbers so related
+ * that the sum of the proper divisors of each is equal to the other number.
+ * (A proper divisor of a number is a positive factor of that number other than the number itself.
+ * For example, the proper divisors of 6 are 1, 2, and 3.)
+ * A pair of amicable numbers constitutes an aliquot sequence of period 2.
+ * It is unknown if there are infinitely many pairs of amicable numbers.
+ * *
+ * <p>
+ * * link: https://en.wikipedia.org/wiki/Amicable_numbers
+ * * </p>
+ * <p>
+ * Simple Example : (220,284) 220 is divisible by {1,2,4,5,10,11,20,22,44,55,110 } <- Sum = 284
+ * 284 is divisible by -> 1,2,4,71,142 and the Sum of that is. Yes right you probably expected it 220
+ */
+
+public class AmicableNumber {
+
+    public static void main(String[] args) {
+
+              AmicableNumber.findAllInRange(1,3000);
+        /* Res -> Int Range of 1 till 3000there are 3Amicable_numbers These are  1: = ( 220,284)	2: = ( 1184,1210)
+        3: = ( 2620,2924) So it worked	*/
+
+    }
+
+    /**
+     * @param startValue
+     * @param stopValue
+     * @return
+     */
+    static void findAllInRange(int startValue, int stopValue) {
+
+        /* the 2 for loops are to avoid to double check tuple. For example (200,100) and (100,200) is the same calculation
+         * also to avoid is to check the number with it self. a number with itself is always a AmicableNumber
+         * */
+        StringBuilder res = new StringBuilder();
+        int countofRes = 0;
+
+        for (int i = startValue; i < stopValue; i++) {
+            for (int j = i + 1; j <= stopValue; j++) {
+                if (isAmicableNumber(i, j)) {
+                    countofRes++;
+                    res.append("" + countofRes + ": = ( " + i + "," + j + ")" + "\t");
+                }
+            }
+        }
+        res.insert(0, "Int Range of " + startValue + " till " + stopValue + " there are " + countofRes + " Amicable_numbers.These are \n ");
+        System.out.println(res.toString());
+    }
+
+    /**
+     * Check if {@code numberOne and numberTwo } are AmicableNumbers or not
+     *
+     * @param numberOne numberTwo
+     * @return {@code true} if {@code numberOne numberTwo} isAmicableNumbers  otherwise false
+     */
+    static boolean isAmicableNumber(int numberOne, int numberTwo) {
+
+        return ((recursiveCalcOfDividerSum(numberOne, numberOne) == numberTwo && numberOne == recursiveCalcOfDividerSum(numberTwo, numberTwo)));
+    }
+
+    /**
+     * calculated in recursive calls the Sum of all the Dividers beside it self
+     *
+     * @param number div = the next to test dividely by using the modulo operator
+     * @return sum of all the dividers
+     */
+    static int recursiveCalcOfDividerSum(int number, int div) {
+
+        if (div == 1) {
+            return 0;
+        } else if (number % --div == 0) {
+            return recursiveCalcOfDividerSum(number, div) + div;
+        } else {
+            return recursiveCalcOfDividerSum(number, div);
+        }
+    }
+
+
+
+
+
+
+}

Maths/VampireNumber.java

@@ -0,0 +1,94 @@
+package Maths;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ n number theory, a vampire number (or true vampire number) is a composite natural number with an even number of digits,
+ that can be factored into two natural numbers each with half as many digits as the original number
+ and not both with trailing zeroes, where the two factors contain precisely
+ all the digits of the original number, in any order, counting multiplicity.
+ The first vampire number is 1260 = 21 × 60.
+ * *
+ * <p>
+ * * link: https://en.wikipedia.org/wiki/Vampire_number
+ * * </p>
+ * <p>
+ *
+ */
+
+
+
+
+
+
+
+public class VampireNumber {
+
+    public static void main(String[] args) {
+
+      test(10,1000);
+    }
+
+     static void  test(int  startValue,  int  stopValue) {
+         int countofRes = 1;
+         StringBuilder res = new StringBuilder();
+
+
+         for (int i = startValue; i <= stopValue; i++) {
+             for (int j = i; j <= stopValue; j++) {
+                 // System.out.println(i+ " "+ j);
+                 if (isVampireNumber(i, j,true)) {
+                     countofRes++;
+                     res.append("" + countofRes + ": = ( " + i + "," + j + " = " + i*j + ")" + "\n");
+                 }
+             }
+         }
+         System.out.println(res);
+     }
+
+
+
+
+        static boolean isVampireNumber(int a, int b, boolean noPseudoVamireNumbers ) {
+
+        // this is for pseudoVampireNumbers  pseudovampire number need not be of length n/2 digits for example
+            // 126 = 6 x 21
+            if (noPseudoVamireNumbers) {
+                if (a * 10 <= b || b * 10 <= a) {
+                    return false;
+                }
+            }
+
+            String mulDigits = splitIntoDigits(a*b,0);
+             String faktorDigits = splitIntoDigits(a,b);
+
+            return mulDigits.equals(faktorDigits);
+            }
+
+
+
+// methode to Split the numbers to Digits
+        static String splitIntoDigits(int num, int num2) {
+
+        StringBuilder res = new StringBuilder();
+
+            ArrayList<Integer> digits = new ArrayList<>();
+            while (num > 0) {
+                digits.add(num%10);
+                num /= 10;
+            }
+            while (num2 > 0) {
+                digits.add(num2%10);
+                num2/= 10;
+            }
+            Collections.sort(digits);
+            for (int i : digits) {
+                res.append(i);
+            }
+
+
+            return res.toString();
+        }
+}