From 0c8593383c05ff7f99e27c811fcdab52f8a22f74 Mon Sep 17 00:00:00 2001 From: iamcodinghere22 Date: Mon, 22 Jun 2026 09:11:23 +0000 Subject: [PATCH 1/7] Add SquareFreeInteger to maths --- .../maths/SquareFreeInteger.java | 38 +++++++++++++++++++ .../maths/SquareFreeIntegerTest.java | 34 +++++++++++++++++ 2 files changed, 72 insertions(+) create mode 100644 src/main/java/com/thealgorithms/maths/SquareFreeInteger.java create mode 100644 src/main/java/com/thealgorithms/maths/SquareFreeIntegerTest.java diff --git a/src/main/java/com/thealgorithms/maths/SquareFreeInteger.java b/src/main/java/com/thealgorithms/maths/SquareFreeInteger.java new file mode 100644 index 000000000000..0e501e3baa77 --- /dev/null +++ b/src/main/java/com/thealgorithms/maths/SquareFreeInteger.java @@ -0,0 +1,38 @@ +public final class SquareFreeInteger{ + +/** + * A square-free integer is an integer divisible by no perfect square other than 1 + * In other words, its prime factorization has no repeated factors. + * Examples: 1, 2, 3, 5, 6, 7, 10, 11, 13, 14, 15... + * Non-examples: 4, 8, 9, 12, 16, 18 (all divisible by 4 or 9) + * + * @see Square-free integer (Wikipedia) + */ + + private SquareFreeInteger(){ + + } + + /** + * Checks if a given number is square-free. + * + * @param num the number to check(this must be positive) + * @return true if num is square-free , false otherwise + * @throws IllegalArgumentException if num is not positive + * + */ + public static boolean isSquareFree(int num){ + if(num<=0){ + throw new IllegalArgumentException("Input must be a positive integer."); + } + + for(int i=2; (long)i*i<=num ;i++){ + if(num%(i*i)==0){ + return false; + } + } + return true; + + + } +} \ No newline at end of file diff --git a/src/main/java/com/thealgorithms/maths/SquareFreeIntegerTest.java b/src/main/java/com/thealgorithms/maths/SquareFreeIntegerTest.java new file mode 100644 index 000000000000..da30659f35fb --- /dev/null +++ b/src/main/java/com/thealgorithms/maths/SquareFreeIntegerTest.java @@ -0,0 +1,34 @@ +package com.thealgorithms.maths; + +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import org.junit.jupiter.api.Test; + +class SquareFreeIntegerTest { + + @Test + void testSquareFreeNumbers() { + assertTrue(SquareFreeInteger.isSquareFree(1)); + assertTrue(SquareFreeInteger.isSquareFree(2)); + assertTrue(SquareFreeInteger.isSquareFree(3)); + assertTrue(SquareFreeInteger.isSquareFree(6)); + assertTrue(SquareFreeInteger.isSquareFree(15)); + } + + @Test + void testNonSquareFreeNumbers() { + assertFalse(SquareFreeInteger.isSquareFree(4)); + assertFalse(SquareFreeInteger.isSquareFree(8)); + assertFalse(SquareFreeInteger.isSquareFree(9)); + assertFalse(SquareFreeInteger.isSquareFree(12)); + assertFalse(SquareFreeInteger.isSquareFree(18)); + } + + @Test + void testInvalidInput() { + assertThrows(IllegalArgumentException.class, () -> SquareFreeInteger.isSquareFree(0)); + assertThrows(IllegalArgumentException.class, () -> SquareFreeInteger.isSquareFree(-5)); + } +} \ No newline at end of file From 488fa213b2b6bf9e96212719ad3ced6ef8e7d5a5 Mon Sep 17 00:00:00 2001 From: iamcodinghere22 Date: Mon, 22 Jun 2026 09:33:02 +0000 Subject: [PATCH 2/7] fix clang-format issues --- .../maths/SquareFreeInteger.java | 28 ++++++++----------- 1 file changed, 12 insertions(+), 16 deletions(-) diff --git a/src/main/java/com/thealgorithms/maths/SquareFreeInteger.java b/src/main/java/com/thealgorithms/maths/SquareFreeInteger.java index 0e501e3baa77..d5e5ffe8603e 100644 --- a/src/main/java/com/thealgorithms/maths/SquareFreeInteger.java +++ b/src/main/java/com/thealgorithms/maths/SquareFreeInteger.java @@ -1,38 +1,34 @@ -public final class SquareFreeInteger{ +package com.thealgorithms.maths; /** - * A square-free integer is an integer divisible by no perfect square other than 1 + * A square-free integer is an integer divisible by no perfect square other than 1 * In other words, its prime factorization has no repeated factors. * Examples: 1, 2, 3, 5, 6, 7, 10, 11, 13, 14, 15... * Non-examples: 4, 8, 9, 12, 16, 18 (all divisible by 4 or 9) - * + * * @see Square-free integer (Wikipedia) */ +public final class SquareFreeInteger { - private SquareFreeInteger(){ - + private SquareFreeInteger() { } /** * Checks if a given number is square-free. - * - * @param num the number to check(this must be positive) - * @return true if num is square-free , false otherwise + * + * @param num the number to check (this must be positive) + * @return true if num is square-free, false otherwise * @throws IllegalArgumentException if num is not positive - * */ - public static boolean isSquareFree(int num){ - if(num<=0){ + public static boolean isSquareFree(int num) { + if (num <= 0) { throw new IllegalArgumentException("Input must be a positive integer."); } - - for(int i=2; (long)i*i<=num ;i++){ - if(num%(i*i)==0){ + for (int i = 2; (long) i * i <= num; i++) { + if (num % (i * i) == 0) { return false; } } return true; - - } } \ No newline at end of file From c83cd4fcf861c1cb31d8277eded1b2b1403cc278 Mon Sep 17 00:00:00 2001 From: iamcodinghere22 Date: Mon, 22 Jun 2026 09:42:39 +0000 Subject: [PATCH 3/7] add newline --- src/main/java/com/thealgorithms/maths/SquareFreeInteger.java | 2 +- .../java/com/thealgorithms/maths/SquareFreeIntegerTest.java | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/main/java/com/thealgorithms/maths/SquareFreeInteger.java b/src/main/java/com/thealgorithms/maths/SquareFreeInteger.java index d5e5ffe8603e..25687cb1ab38 100644 --- a/src/main/java/com/thealgorithms/maths/SquareFreeInteger.java +++ b/src/main/java/com/thealgorithms/maths/SquareFreeInteger.java @@ -31,4 +31,4 @@ public static boolean isSquareFree(int num) { } return true; } -} \ No newline at end of file +} diff --git a/src/main/java/com/thealgorithms/maths/SquareFreeIntegerTest.java b/src/main/java/com/thealgorithms/maths/SquareFreeIntegerTest.java index da30659f35fb..64bb4d0a5370 100644 --- a/src/main/java/com/thealgorithms/maths/SquareFreeIntegerTest.java +++ b/src/main/java/com/thealgorithms/maths/SquareFreeIntegerTest.java @@ -31,4 +31,4 @@ void testInvalidInput() { assertThrows(IllegalArgumentException.class, () -> SquareFreeInteger.isSquareFree(0)); assertThrows(IllegalArgumentException.class, () -> SquareFreeInteger.isSquareFree(-5)); } -} \ No newline at end of file +} From 2156b671422ad07750ebc3c2ea807fb191b622da Mon Sep 17 00:00:00 2001 From: iamcodinghere22 Date: Mon, 22 Jun 2026 10:40:37 +0000 Subject: [PATCH 4/7] Add new test file in test --- .../java/com/thealgorithms/maths/SquareFreeIntegerNew.java} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename src/{main/java/com/thealgorithms/maths/SquareFreeIntegerTest.java => test/java/com/thealgorithms/maths/SquareFreeIntegerNew.java} (100%) diff --git a/src/main/java/com/thealgorithms/maths/SquareFreeIntegerTest.java b/src/test/java/com/thealgorithms/maths/SquareFreeIntegerNew.java similarity index 100% rename from src/main/java/com/thealgorithms/maths/SquareFreeIntegerTest.java rename to src/test/java/com/thealgorithms/maths/SquareFreeIntegerNew.java From 3e5e1abb80d7b4d72caeefd2116dbda116b431c1 Mon Sep 17 00:00:00 2001 From: iamcodinghere22 Date: Mon, 22 Jun 2026 10:51:18 +0000 Subject: [PATCH 5/7] modified --- .../maths/SquareFreeInteger.java | 22 ++++++------ .../maths/SquareFreeIntegerNew.java | 34 ------------------- 2 files changed, 11 insertions(+), 45 deletions(-) delete mode 100644 src/test/java/com/thealgorithms/maths/SquareFreeIntegerNew.java diff --git a/src/main/java/com/thealgorithms/maths/SquareFreeInteger.java b/src/main/java/com/thealgorithms/maths/SquareFreeInteger.java index 25687cb1ab38..d06d8194cc91 100644 --- a/src/main/java/com/thealgorithms/maths/SquareFreeInteger.java +++ b/src/main/java/com/thealgorithms/maths/SquareFreeInteger.java @@ -1,7 +1,7 @@ -package com.thealgorithms.maths; +package com.thealgorithms.maths.Prime; /** - * A square-free integer is an integer divisible by no perfect square other than 1 + * A square-free integer is an integer divisible by no perfect square other than 1. * In other words, its prime factorization has no repeated factors. * Examples: 1, 2, 3, 5, 6, 7, 10, 11, 13, 14, 15... * Non-examples: 4, 8, 9, 12, 16, 18 (all divisible by 4 or 9) @@ -14,18 +14,18 @@ private SquareFreeInteger() { } /** - * Checks if a given number is square-free. + * Checks if a given number is a square-free integer. * - * @param num the number to check (this must be positive) - * @return true if num is square-free, false otherwise - * @throws IllegalArgumentException if num is not positive + * @param number the number to check (must be greater than zero) + * @return true if number is square-free, false otherwise + * @throws IllegalArgumentException if number is not greater than zero */ - public static boolean isSquareFree(int num) { - if (num <= 0) { - throw new IllegalArgumentException("Input must be a positive integer."); + public static boolean isSquareFreeInteger(int number) { + if (number <= 0) { + throw new IllegalArgumentException("Number must be greater than zero."); } - for (int i = 2; (long) i * i <= num; i++) { - if (num % (i * i) == 0) { + for (int i = 2; (long) i * i <= number; i++) { + if (number % (i * i) == 0) { return false; } } diff --git a/src/test/java/com/thealgorithms/maths/SquareFreeIntegerNew.java b/src/test/java/com/thealgorithms/maths/SquareFreeIntegerNew.java deleted file mode 100644 index 64bb4d0a5370..000000000000 --- a/src/test/java/com/thealgorithms/maths/SquareFreeIntegerNew.java +++ /dev/null @@ -1,34 +0,0 @@ -package com.thealgorithms.maths; - -import static org.junit.jupiter.api.Assertions.assertFalse; -import static org.junit.jupiter.api.Assertions.assertThrows; -import static org.junit.jupiter.api.Assertions.assertTrue; - -import org.junit.jupiter.api.Test; - -class SquareFreeIntegerTest { - - @Test - void testSquareFreeNumbers() { - assertTrue(SquareFreeInteger.isSquareFree(1)); - assertTrue(SquareFreeInteger.isSquareFree(2)); - assertTrue(SquareFreeInteger.isSquareFree(3)); - assertTrue(SquareFreeInteger.isSquareFree(6)); - assertTrue(SquareFreeInteger.isSquareFree(15)); - } - - @Test - void testNonSquareFreeNumbers() { - assertFalse(SquareFreeInteger.isSquareFree(4)); - assertFalse(SquareFreeInteger.isSquareFree(8)); - assertFalse(SquareFreeInteger.isSquareFree(9)); - assertFalse(SquareFreeInteger.isSquareFree(12)); - assertFalse(SquareFreeInteger.isSquareFree(18)); - } - - @Test - void testInvalidInput() { - assertThrows(IllegalArgumentException.class, () -> SquareFreeInteger.isSquareFree(0)); - assertThrows(IllegalArgumentException.class, () -> SquareFreeInteger.isSquareFree(-5)); - } -} From d3c13608650d38ec6b99ceb0d9d7fccbda6c2319 Mon Sep 17 00:00:00 2001 From: iamcodinghere22 Date: Mon, 22 Jun 2026 10:57:32 +0000 Subject: [PATCH 6/7] delete --- .../maths/SquareFreeInteger.java | 34 ------------------- 1 file changed, 34 deletions(-) delete mode 100644 src/main/java/com/thealgorithms/maths/SquareFreeInteger.java diff --git a/src/main/java/com/thealgorithms/maths/SquareFreeInteger.java b/src/main/java/com/thealgorithms/maths/SquareFreeInteger.java deleted file mode 100644 index d06d8194cc91..000000000000 --- a/src/main/java/com/thealgorithms/maths/SquareFreeInteger.java +++ /dev/null @@ -1,34 +0,0 @@ -package com.thealgorithms.maths.Prime; - -/** - * A square-free integer is an integer divisible by no perfect square other than 1. - * In other words, its prime factorization has no repeated factors. - * Examples: 1, 2, 3, 5, 6, 7, 10, 11, 13, 14, 15... - * Non-examples: 4, 8, 9, 12, 16, 18 (all divisible by 4 or 9) - * - * @see Square-free integer (Wikipedia) - */ -public final class SquareFreeInteger { - - private SquareFreeInteger() { - } - - /** - * Checks if a given number is a square-free integer. - * - * @param number the number to check (must be greater than zero) - * @return true if number is square-free, false otherwise - * @throws IllegalArgumentException if number is not greater than zero - */ - public static boolean isSquareFreeInteger(int number) { - if (number <= 0) { - throw new IllegalArgumentException("Number must be greater than zero."); - } - for (int i = 2; (long) i * i <= number; i++) { - if (number % (i * i) == 0) { - return false; - } - } - return true; - } -} From 28bfe860ca0e4da7b39b72c5b4364f68434aba41 Mon Sep 17 00:00:00 2001 From: iamcodinghere22 Date: Mon, 22 Jun 2026 11:00:50 +0000 Subject: [PATCH 7/7] Add DisariumNumbers with test --- .../thealgorithms/maths/DisariumNumber.java | 37 +++++++++++++++++++ .../maths/DisariumNumberTest.java | 32 ++++++++++++++++ 2 files changed, 69 insertions(+) create mode 100644 src/main/java/com/thealgorithms/maths/DisariumNumber.java create mode 100644 src/test/java/com/thealgorithms/maths/DisariumNumberTest.java diff --git a/src/main/java/com/thealgorithms/maths/DisariumNumber.java b/src/main/java/com/thealgorithms/maths/DisariumNumber.java new file mode 100644 index 000000000000..0196d0797bcc --- /dev/null +++ b/src/main/java/com/thealgorithms/maths/DisariumNumber.java @@ -0,0 +1,37 @@ +package com.thealgorithms.maths; + +/** + * Disarium number is a number where the sum of its digits powered + * with their respective positions is equal to the number itself. + * Example: 135 = 1^1 + 3^2 + 5^3 = 1 + 9 + 125 = 135 + * + * @see Disarium Number + */ +public final class DisariumNumber { + + private DisariumNumber() { + } + + /** + * Checks if a number is a Disarium number. + * + * @param number the number to check (must be positive) + * @return true if number is Disarium, false otherwise + * @throws IllegalArgumentException if number is not positive + */ + public static boolean isDisarium(int number) { + if (number <= 0) { + throw new IllegalArgumentException("Input must be a positive integer."); + } + int digits = String.valueOf(number).length(); + int temp = number; + int sum = 0; + while (temp > 0) { + int lastDigit = temp % 10; + sum += (int) Math.pow(lastDigit, digits); + digits--; + temp /= 10; + } + return sum == number; + } +} diff --git a/src/test/java/com/thealgorithms/maths/DisariumNumberTest.java b/src/test/java/com/thealgorithms/maths/DisariumNumberTest.java new file mode 100644 index 000000000000..54e9e861ad44 --- /dev/null +++ b/src/test/java/com/thealgorithms/maths/DisariumNumberTest.java @@ -0,0 +1,32 @@ +package com.thealgorithms.maths; + +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import org.junit.jupiter.api.Test; + +class DisariumNumberTest { + + @Test + void testDisariumNumbers() { + assertTrue(DisariumNumber.isDisarium(1)); + assertTrue(DisariumNumber.isDisarium(89)); + assertTrue(DisariumNumber.isDisarium(135)); + assertTrue(DisariumNumber.isDisarium(175)); + assertTrue(DisariumNumber.isDisarium(518)); + } + + @Test + void testNonDisariumNumbers() { + assertFalse(DisariumNumber.isDisarium(10)); + assertFalse(DisariumNumber.isDisarium(100)); + assertFalse(DisariumNumber.isDisarium(200)); + } + + @Test + void testInvalidInput() { + assertThrows(IllegalArgumentException.class, () -> DisariumNumber.isDisarium(0)); + assertThrows(IllegalArgumentException.class, () -> DisariumNumber.isDisarium(-5)); + } +}