diff --git a/DIRECTORY.md b/DIRECTORY.md index 19f15a90..dc067c80 100644 --- a/DIRECTORY.md +++ b/DIRECTORY.md @@ -118,6 +118,8 @@ * [AmicableNumber](https://github.com/TheAlgorithms/Java/blob/master/Maths/AmicableNumber.java) * [Area](https://github.com/TheAlgorithms/Java/blob/master/Maths/Area.java) * [Average](https://github.com/TheAlgorithms/Java/blob/master/Maths/Average.java) + * [Ceil](https://github.com/TheAlgorithms/Java/blob/master/Maths/Ceil.java) + * [Combinations](https://github.com/TheAlgorithms/Java/blob/master/Maths/Combinations.java) * [Factorial](https://github.com/TheAlgorithms/Java/blob/master/Maths/Factorial.java) * [FactorialRecursion](https://github.com/TheAlgorithms/Java/blob/master/Maths/FactorialRecursion.java) * [FibonacciNumber](https://github.com/TheAlgorithms/Java/blob/master/Maths/FibonacciNumber.java) @@ -125,14 +127,18 @@ * [FindMaxRecursion](https://github.com/TheAlgorithms/Java/blob/master/Maths/FindMaxRecursion.java) * [FindMin](https://github.com/TheAlgorithms/Java/blob/master/Maths/FindMin.java) * [FindMinRecursion](https://github.com/TheAlgorithms/Java/blob/master/Maths/FindMinRecursion.java) + * [Floor](https://github.com/TheAlgorithms/Java/blob/master/Maths/Floor.java) * [GCD](https://github.com/TheAlgorithms/Java/blob/master/Maths/GCD.java) * [GCDRecursion](https://github.com/TheAlgorithms/Java/blob/master/Maths/GCDRecursion.java) + * [LucasSeries](https://github.com/TheAlgorithms/Java/blob/master/Maths/LucasSeries.java) * [MaxValue](https://github.com/TheAlgorithms/Java/blob/master/Maths/MaxValue.java) * [MinValue](https://github.com/TheAlgorithms/Java/blob/master/Maths/MinValue.java) * [NumberOfDigits](https://github.com/TheAlgorithms/Java/blob/master/Maths/NumberOfDigits.java) * [PalindromeNumber](https://github.com/TheAlgorithms/Java/blob/master/Maths/PalindromeNumber.java) * [ParseInteger](https://github.com/TheAlgorithms/Java/blob/master/Maths/ParseInteger.java) + * [PerfectCube](https://github.com/TheAlgorithms/Java/blob/master/Maths/PerfectCube.java) * [PerfectNumber](https://github.com/TheAlgorithms/Java/blob/master/Maths/PerfectNumber.java) + * [PerfectSquare](https://github.com/TheAlgorithms/Java/blob/master/Maths/PerfectSquare.java) * [Pow](https://github.com/TheAlgorithms/Java/blob/master/Maths/Pow.java) * [PowRecursion](https://github.com/TheAlgorithms/Java/blob/master/Maths/PowRecursion.java) * [PrimeCheck](https://github.com/TheAlgorithms/Java/blob/master/Maths/PrimeCheck.java) diff --git a/Maths/Ceil.java b/Maths/Ceil.java new file mode 100644 index 00000000..d84ab825 --- /dev/null +++ b/Maths/Ceil.java @@ -0,0 +1,32 @@ +package Maths; + +public class Ceil { + public static void main(String[] args) { + assert ceil(10) == Math.ceil(10); + assert ceil(-10) == Math.ceil(-10); + assert ceil(10.0) == Math.ceil(10.0); + assert ceil(-10.0) == Math.ceil(-10.0); + assert ceil(10.1) == Math.ceil(10.1); + assert ceil(-10.1) == Math.ceil(-10.1); + assert ceil(0) == Math.ceil(0); + assert ceil(-0) == Math.ceil(-0); + assert ceil(0.0) == Math.ceil(0.0); + assert ceil(-0.0) == Math.ceil(-0.0); + } + + /** + * Returns the smallest (closest to negative infinity) + * + * @param number the number + * @return the smallest (closest to negative infinity) of given {@code number} + */ + public static double ceil(double number) { + if (number - (int) number == 0) { + return number; + } else if (number - (int) number > 0) { + return (int) (number + 1); + } else { + return (int) number; + } + } +} \ No newline at end of file diff --git a/Maths/Combinations.java b/Maths/Combinations.java new file mode 100644 index 00000000..4ff237bb --- /dev/null +++ b/Maths/Combinations.java @@ -0,0 +1,37 @@ +package Maths; + +/** + * @see Combination + */ +public class Combinations { + public static void main(String[] args) { + assert combinations(1, 1) == 1; + assert combinations(10, 5) == 252; + assert combinations(6, 3) == 20; + assert combinations(20, 5) == 15504; + } + + /** + * Calculate of factorial + * + * @param n the number + * @return factorial of given number + */ + public static long factorial(int n) { + if (n < 0) { + throw new IllegalArgumentException("number is negative"); + } + return n == 0 || n == 1 ? 1 : n * factorial(n - 1); + } + + /** + * Calculate combinations + * + * @param n first number + * @param k second number + * @return combinations of given {@code n} and {@code k} + */ + public static long combinations(int n, int k) { + return factorial(n) / (factorial(k) * factorial(n - k)); + } +} diff --git a/Maths/Factorial.java b/Maths/Factorial.java index e792cf68..e1ce91f6 100644 --- a/Maths/Factorial.java +++ b/Maths/Factorial.java @@ -1,34 +1,27 @@ package Maths; -import java.util.*; //for importing scanner public class Factorial { - public static void main(String[] args) { //main method - int n = 1; - Scanner sc= new Scanner(System.in); - System.out.println("Enter Number"); - n=sc.nextInt(); - System.out.println(n + "! = " + factorial(n)); + + /* Driver Code */ + public static void main(String[] args) { + assert factorial(0) == 1; + assert factorial(1) == 1; + assert factorial(5) == 120; + assert factorial(10) == 3628800; } - //Factorial = n! = n1 * (n-1) * (n-2)*...1 - /** - * Calculate factorial N + * Calculate factorial N using iteration * * @param n the number * @return the factorial of {@code n} */ public static long factorial(int n) { - // Using recursion - try { - if (n == 0) { - return 1; // if n = 0, return factorial of n; - }else { - return n*factorial(n-1); // While N is greater than 0, call the function again, passing n-1 (Principle of factoring); - } - }catch (ArithmeticException e) { - System.out.println("Dont work with less than 0"); - } - return n; + if (n < 0) { + throw new IllegalArgumentException("number is negative"); + } + long factorial = 1; + for (int i = 1; i <= n; factorial *= i, ++i) ; + return factorial; } } diff --git a/Maths/Floor.java b/Maths/Floor.java new file mode 100644 index 00000000..e8a43da4 --- /dev/null +++ b/Maths/Floor.java @@ -0,0 +1,32 @@ +package Maths; + +public class Floor { + public static void main(String[] args) { + assert floor(10) == Math.floor(10); + assert floor(-10) == Math.floor(-10); + assert floor(10.0) == Math.floor(10.0); + assert floor(-10.0) == Math.floor(-10.0); + assert floor(10.1) == Math.floor(10.1); + assert floor(-10.1) == Math.floor(-10.1); + assert floor(0) == Math.floor(0); + assert floor(-0) == Math.floor(-0); + assert floor(0.0) == Math.floor(0.0); + assert floor(-0.0) == Math.floor(-0.0); + } + + /** + * Returns the largest (closest to positive infinity) + * + * @param number the number + * @return the largest (closest to positive infinity) of given {@code number} + */ + public static double floor(double number) { + if (number - (int) number == 0) { + return number; + } else if (number - (int) number > 0) { + return (int) number; + } else { + return (int) number - 1; + } + } +} \ No newline at end of file diff --git a/Maths/LucasSeries.java b/Maths/LucasSeries.java new file mode 100644 index 00000000..8fa7097b --- /dev/null +++ b/Maths/LucasSeries.java @@ -0,0 +1,44 @@ +package Maths; + +/** + * https://en.wikipedia.org/wiki/Lucas_number + */ +public class LucasSeries { + public static void main(String[] args) { + assert lucasSeries(1) == 2 && lucasSeriesIteration(1) == 2; + assert lucasSeries(2) == 1 && lucasSeriesIteration(2) == 1; + assert lucasSeries(3) == 3 && lucasSeriesIteration(3) == 3; + assert lucasSeries(4) == 4 && lucasSeriesIteration(4) == 4; + assert lucasSeries(5) == 7 && lucasSeriesIteration(5) == 7; + assert lucasSeries(6) == 11 && lucasSeriesIteration(6) == 11; + assert lucasSeries(11) == 123 && lucasSeriesIteration(11) == 123; + + } + + /** + * Calculate nth number of lucas series(2, 1, 3, 4, 7, 11, 18, 29, 47, 76, 123, ....) using recursion + * + * @param n nth + * @return nth number of lucas series + */ + public static int lucasSeries(int n) { + return n == 1 ? 2 : n == 2 ? 1 : lucasSeries(n - 1) + lucasSeries(n - 2); + } + + /** + * Calculate nth number of lucas series(2, 1, 3, 4, 7, 11, 18, 29, 47, 76, 123, ....) using iteration + * + * @param n nth + * @return nth number of lucas series + */ + public static int lucasSeriesIteration(int n) { + int previous = 2; + int current = 1; + for (int i = 1; i < n; i++) { + int next = previous + current; + previous = current; + current = next; + } + return previous; + } +} diff --git a/Maths/PerfectCube.java b/Maths/PerfectCube.java new file mode 100644 index 00000000..1db0dc3e --- /dev/null +++ b/Maths/PerfectCube.java @@ -0,0 +1,27 @@ +package Maths; + +/** + * https://en.wikipedia.org/wiki/Cube_(algebra) + */ +public class PerfectCube { + public static void main(String[] args) { + assert !isPerfectCube(-1); + assert isPerfectCube(0); + assert isPerfectCube(1); + assert !isPerfectCube(4); + assert isPerfectCube(8); + assert isPerfectCube(27); + + } + + /** + * Check if a number is perfect cube or not + * + * @param number number to check + * @return {@code true} if {@code number} is perfect cube, otherwise {@code false} + */ + public static boolean isPerfectCube(int number) { + int a = (int) Math.pow(number, 1.0 / 3); + return a * a * a == number; + } +} diff --git a/Maths/PerfectSquare.java b/Maths/PerfectSquare.java new file mode 100644 index 00000000..7484b2fd --- /dev/null +++ b/Maths/PerfectSquare.java @@ -0,0 +1,25 @@ +package Maths; + +/** + * https://en.wikipedia.org/wiki/Perfect_square + */ +public class PerfectSquare { + public static void main(String[] args) { + assert !isPerfectSquare(-1); + assert !isPerfectSquare(3); + assert !isPerfectSquare(5); + assert isPerfectSquare(9); + assert isPerfectSquare(100); + } + + /** + * Check if a number is perfect square number + * + * @param number the number to be checked + * @return true if {@code number} is perfect square, otherwise false + */ + public static boolean isPerfectSquare(int number) { + int sqrt = (int) Math.sqrt(number); + return sqrt * sqrt == number; + } +} \ No newline at end of file