From c7c3d8be6cf70eb5cc0a71d23a7cbc927465e01a Mon Sep 17 00:00:00 2001 From: tuhin Date: Sat, 5 Oct 2024 21:46:21 +0530 Subject: [PATCH 01/21] feat : new algo uniquesubseqcount --- .../UniqueSubsequencesCount.java | 53 +++++++++++++++++++ .../UniqueSubsequencesCountTest.java | 29 ++++++++++ 2 files changed, 82 insertions(+) create mode 100755 src/main/java/com/thealgorithms/dynamicprogramming/UniqueSubsequencesCount.java create mode 100755 src/test/java/com/thealgorithms/dynamicprogramming/UniqueSubsequencesCountTest.java diff --git a/src/main/java/com/thealgorithms/dynamicprogramming/UniqueSubsequencesCount.java b/src/main/java/com/thealgorithms/dynamicprogramming/UniqueSubsequencesCount.java new file mode 100755 index 000000000000..80e175148bec --- /dev/null +++ b/src/main/java/com/thealgorithms/dynamicprogramming/UniqueSubsequencesCount.java @@ -0,0 +1,53 @@ +package com.thealgorithms.dynamicprogramming; + +// Program to find the number of Subsequences can be produced from a string + +import java.util.Arrays; +import java.util.HashSet; +import java.util.Set; + +// Author -> https://github.com/Tuhinm2002 + +public class UniqueSubsequencesCount { + + private UniqueSubsequencesCount() { + throw new UnsupportedOperationException("Utility class"); + } + + public static int subseqCount(String str) { + int[] dp = new int[str.length() + 1]; + for (int i : dp) { + Arrays.fill(dp, -1); + } + int ans = recursiveCall(str, 0, dp); + return ans; + } + + public static int recursiveCall(String st, int idx, int[] dp) { + + if (idx >= st.length()) { + return 0; + } + + if (dp[idx] != -1) { + return dp[idx]; + } + + Set set = new HashSet<>(); + + int res = 0; + + for (int j = idx; j < st.length(); j++) { + + if (set.contains(st.charAt(j))) { + continue; + } + + set.add(st.charAt(j)); + + res = 1 + recursiveCall(st, j + 1, dp) + res; + } + + return dp[idx] = res; + } +} diff --git a/src/test/java/com/thealgorithms/dynamicprogramming/UniqueSubsequencesCountTest.java b/src/test/java/com/thealgorithms/dynamicprogramming/UniqueSubsequencesCountTest.java new file mode 100755 index 000000000000..b1d822af5f3f --- /dev/null +++ b/src/test/java/com/thealgorithms/dynamicprogramming/UniqueSubsequencesCountTest.java @@ -0,0 +1,29 @@ +package com.thealgorithms.dynamicprogramming; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +import org.junit.jupiter.api.Test; + +public class UniqueSubsequencesCountTest { + + @Test + void subseqCountTestOne() { + String s = "abc"; + + assertEquals(7, UniqueSubsequencesCount.subseqCount(s)); + } + + @Test + void subseqCountTestTwo() { + String s = "abcdashgdhas"; + + assertEquals(3592, UniqueSubsequencesCount.subseqCount(s)); + } + + @Test + void subseqCountTestThree() { + String s = "aaaaa"; + + assertEquals(5, UniqueSubsequencesCount.subseqCount(s)); + } +} From d12468003e4ac50a2bbf4886a67cf71a9bb4f2f1 Mon Sep 17 00:00:00 2001 From: Tuhinm2002 <75078694+Tuhinm2002@users.noreply.github.com> Date: Sat, 5 Oct 2024 21:50:22 +0530 Subject: [PATCH 02/21] Update UniqueSubsequencesCount.java --- .../dynamicprogramming/UniqueSubsequencesCount.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/com/thealgorithms/dynamicprogramming/UniqueSubsequencesCount.java b/src/main/java/com/thealgorithms/dynamicprogramming/UniqueSubsequencesCount.java index 80e175148bec..099fbfae1e87 100755 --- a/src/main/java/com/thealgorithms/dynamicprogramming/UniqueSubsequencesCount.java +++ b/src/main/java/com/thealgorithms/dynamicprogramming/UniqueSubsequencesCount.java @@ -8,7 +8,7 @@ // Author -> https://github.com/Tuhinm2002 -public class UniqueSubsequencesCount { +public final class UniqueSubsequencesCount { private UniqueSubsequencesCount() { throw new UnsupportedOperationException("Utility class"); From d99c476099152028cd682efe755194ec6ddab0fc Mon Sep 17 00:00:00 2001 From: Tuhinm2002 <75078694+Tuhinm2002@users.noreply.github.com> Date: Sat, 5 Oct 2024 21:50:34 +0530 Subject: [PATCH 03/21] Update UniqueSubsequencesCountTest.java --- .../dynamicprogramming/UniqueSubsequencesCountTest.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/test/java/com/thealgorithms/dynamicprogramming/UniqueSubsequencesCountTest.java b/src/test/java/com/thealgorithms/dynamicprogramming/UniqueSubsequencesCountTest.java index b1d822af5f3f..171f2d28db8a 100755 --- a/src/test/java/com/thealgorithms/dynamicprogramming/UniqueSubsequencesCountTest.java +++ b/src/test/java/com/thealgorithms/dynamicprogramming/UniqueSubsequencesCountTest.java @@ -4,7 +4,7 @@ import org.junit.jupiter.api.Test; -public class UniqueSubsequencesCountTest { +public final class UniqueSubsequencesCountTest { @Test void subseqCountTestOne() { From 33f06a876ec9533f11e4a57658c549b07baa53ca Mon Sep 17 00:00:00 2001 From: Tuhinm2002 <75078694+Tuhinm2002@users.noreply.github.com> Date: Sat, 5 Oct 2024 21:55:32 +0530 Subject: [PATCH 04/21] Update UniqueSubsequencesCount.java --- .../dynamicprogramming/UniqueSubsequencesCount.java | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-) diff --git a/src/main/java/com/thealgorithms/dynamicprogramming/UniqueSubsequencesCount.java b/src/main/java/com/thealgorithms/dynamicprogramming/UniqueSubsequencesCount.java index 099fbfae1e87..b3de7e17e7e4 100755 --- a/src/main/java/com/thealgorithms/dynamicprogramming/UniqueSubsequencesCount.java +++ b/src/main/java/com/thealgorithms/dynamicprogramming/UniqueSubsequencesCount.java @@ -14,13 +14,17 @@ private UniqueSubsequencesCount() { throw new UnsupportedOperationException("Utility class"); } + private static int[] dp; + public static int subseqCount(String str) { - int[] dp = new int[str.length() + 1]; + + dp = new int[str.length() + 1]; + for (int i : dp) { Arrays.fill(dp, -1); } - int ans = recursiveCall(str, 0, dp); - return ans; + + return recursiveCall(str, 0, dp); } public static int recursiveCall(String st, int idx, int[] dp) { From 892e365fd8568b93a4669b3643a6086a8ead4b41 Mon Sep 17 00:00:00 2001 From: Tuhinm2002 <75078694+Tuhinm2002@users.noreply.github.com> Date: Sat, 5 Oct 2024 22:06:11 +0530 Subject: [PATCH 05/21] Update UniqueSubsequencesCount.java --- .../dynamicprogramming/UniqueSubsequencesCount.java | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/src/main/java/com/thealgorithms/dynamicprogramming/UniqueSubsequencesCount.java b/src/main/java/com/thealgorithms/dynamicprogramming/UniqueSubsequencesCount.java index b3de7e17e7e4..d1b239d219cb 100755 --- a/src/main/java/com/thealgorithms/dynamicprogramming/UniqueSubsequencesCount.java +++ b/src/main/java/com/thealgorithms/dynamicprogramming/UniqueSubsequencesCount.java @@ -19,10 +19,7 @@ private UniqueSubsequencesCount() { public static int subseqCount(String str) { dp = new int[str.length() + 1]; - - for (int i : dp) { - Arrays.fill(dp, -1); - } + Arrays.fill(dp, -1); return recursiveCall(str, 0, dp); } From 78584432643405c12529163ddd5521d6c39cee55 Mon Sep 17 00:00:00 2001 From: Tuhinm2002 <75078694+Tuhinm2002@users.noreply.github.com> Date: Sat, 5 Oct 2024 22:13:10 +0530 Subject: [PATCH 06/21] Update UniqueSubsequencesCount.java --- .../dynamicprogramming/UniqueSubsequencesCount.java | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/main/java/com/thealgorithms/dynamicprogramming/UniqueSubsequencesCount.java b/src/main/java/com/thealgorithms/dynamicprogramming/UniqueSubsequencesCount.java index d1b239d219cb..8ec4af937370 100755 --- a/src/main/java/com/thealgorithms/dynamicprogramming/UniqueSubsequencesCount.java +++ b/src/main/java/com/thealgorithms/dynamicprogramming/UniqueSubsequencesCount.java @@ -14,11 +14,11 @@ private UniqueSubsequencesCount() { throw new UnsupportedOperationException("Utility class"); } - private static int[] dp; + private static Set set = new HashSet<>(); public static int subseqCount(String str) { - dp = new int[str.length() + 1]; + int[] dp = new int[str.length() + 1]; Arrays.fill(dp, -1); return recursiveCall(str, 0, dp); @@ -34,7 +34,7 @@ public static int recursiveCall(String st, int idx, int[] dp) { return dp[idx]; } - Set set = new HashSet<>(); + set = new HashSet<>(); int res = 0; From 569cc1c83fbeacdabbd7ca0e075957bb03bc1aa2 Mon Sep 17 00:00:00 2001 From: Tuhinm2002 <75078694+Tuhinm2002@users.noreply.github.com> Date: Sat, 5 Oct 2024 22:17:19 +0530 Subject: [PATCH 07/21] Update UniqueSubsequencesCount.java --- .../dynamicprogramming/UniqueSubsequencesCount.java | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/src/main/java/com/thealgorithms/dynamicprogramming/UniqueSubsequencesCount.java b/src/main/java/com/thealgorithms/dynamicprogramming/UniqueSubsequencesCount.java index 8ec4af937370..13967972ba15 100755 --- a/src/main/java/com/thealgorithms/dynamicprogramming/UniqueSubsequencesCount.java +++ b/src/main/java/com/thealgorithms/dynamicprogramming/UniqueSubsequencesCount.java @@ -14,8 +14,6 @@ private UniqueSubsequencesCount() { throw new UnsupportedOperationException("Utility class"); } - private static Set set = new HashSet<>(); - public static int subseqCount(String str) { int[] dp = new int[str.length() + 1]; @@ -34,7 +32,7 @@ public static int recursiveCall(String st, int idx, int[] dp) { return dp[idx]; } - set = new HashSet<>(); + Set set = new HashSet<>(); int res = 0; @@ -49,6 +47,7 @@ public static int recursiveCall(String st, int idx, int[] dp) { res = 1 + recursiveCall(st, j + 1, dp) + res; } - return dp[idx] = res; + dp[idx] = res; + return dp[idx]; } } From 3b8d047bca62da2877b24477af64155bdc681e4a Mon Sep 17 00:00:00 2001 From: Tuhinm2002 <75078694+Tuhinm2002@users.noreply.github.com> Date: Mon, 7 Oct 2024 22:01:11 +0530 Subject: [PATCH 08/21] Update UniqueSubsequencesCount.java --- .../UniqueSubsequencesCount.java | 53 +++++++++++++++++-- 1 file changed, 49 insertions(+), 4 deletions(-) diff --git a/src/main/java/com/thealgorithms/dynamicprogramming/UniqueSubsequencesCount.java b/src/main/java/com/thealgorithms/dynamicprogramming/UniqueSubsequencesCount.java index 13967972ba15..948454c9eb7b 100755 --- a/src/main/java/com/thealgorithms/dynamicprogramming/UniqueSubsequencesCount.java +++ b/src/main/java/com/thealgorithms/dynamicprogramming/UniqueSubsequencesCount.java @@ -1,52 +1,97 @@ package com.thealgorithms.dynamicprogramming; -// Program to find the number of Subsequences can be produced from a string - import java.util.Arrays; import java.util.HashSet; import java.util.Set; -// Author -> https://github.com/Tuhinm2002 - +/** + * Utility class to find the number of unique subsequences that can be + * produced from a given string. + * + *

This class contains static methods to compute the unique subsequence count + * using dynamic programming and recursion. It ensures that duplicate characters + * are not counted multiple times in the subsequences.

+ * + *

@author Author: https://github.com/Tuhinm2002

+ */ public final class UniqueSubsequencesCount { + /** + * Private constructor to prevent instantiation of this utility class. + * This class should only be used in a static context. + * + * @throws UnsupportedOperationException if attempted to instantiate. + */ private UniqueSubsequencesCount() { throw new UnsupportedOperationException("Utility class"); } + /** + * Finds the number of unique subsequences that can be generated from + * the given string. + * + *

This method initializes a dynamic programming (DP) array and invokes + * the recursive helper function to compute the subsequence count.

+ * + * @param str the input string from which subsequences are generated + * @return the total count of unique subsequences + */ public static int subseqCount(String str) { + // DP array initialized to store intermediate results int[] dp = new int[str.length() + 1]; Arrays.fill(dp, -1); + // Calls the recursive function to compute the result return recursiveCall(str, 0, dp); } + /** + * Recursive helper function to count the number of unique subsequences + * starting from the given index. + * + *

Uses a HashSet to avoid counting duplicate characters within + * a single subsequence.

+ * + * @param st the input string + * @param idx the current index from which to calculate subsequences + * @param dp dynamic programming array used to memoize results + * @return the total number of unique subsequences starting from the + * current index + */ public static int recursiveCall(String st, int idx, int[] dp) { + // Base case: when index exceeds the string length if (idx >= st.length()) { return 0; } + // If result is already calculated, return the memoized value if (dp[idx] != -1) { return dp[idx]; } + // Set to store characters to avoid duplicates Set set = new HashSet<>(); int res = 0; + // Iterate over the string starting from current index for (int j = idx; j < st.length(); j++) { + // If character is already in the set, skip it if (set.contains(st.charAt(j))) { continue; } + // Add character to set and recursively calculate subsequences set.add(st.charAt(j)); + // 1 for the current subsequence + recursive call for the rest of the string res = 1 + recursiveCall(st, j + 1, dp) + res; } + // Memoize the result dp[idx] = res; return dp[idx]; } From 735077dbfbac5e1dc369e2f04c989e83df6dd13f Mon Sep 17 00:00:00 2001 From: Tuhinm2002 <75078694+Tuhinm2002@users.noreply.github.com> Date: Mon, 7 Oct 2024 22:08:07 +0530 Subject: [PATCH 09/21] Update UniqueSubsequencesCount.java --- .../dynamicprogramming/UniqueSubsequencesCount.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/com/thealgorithms/dynamicprogramming/UniqueSubsequencesCount.java b/src/main/java/com/thealgorithms/dynamicprogramming/UniqueSubsequencesCount.java index 948454c9eb7b..2f427a750607 100755 --- a/src/main/java/com/thealgorithms/dynamicprogramming/UniqueSubsequencesCount.java +++ b/src/main/java/com/thealgorithms/dynamicprogramming/UniqueSubsequencesCount.java @@ -36,7 +36,7 @@ private UniqueSubsequencesCount() { * @param str the input string from which subsequences are generated * @return the total count of unique subsequences */ - public static int subseqCount(String str) { + public static int countSubsequences(String str) { // DP array initialized to store intermediate results int[] dp = new int[str.length() + 1]; From 8819fdb87825e4c85cdbb61a7e19f47162609d6e Mon Sep 17 00:00:00 2001 From: Tuhinm2002 <75078694+Tuhinm2002@users.noreply.github.com> Date: Mon, 7 Oct 2024 22:16:50 +0530 Subject: [PATCH 10/21] Update UniqueSubsequencesCountTest.java --- .../UniqueSubsequencesCountTest.java | 36 ++++++++++++++++--- 1 file changed, 31 insertions(+), 5 deletions(-) diff --git a/src/test/java/com/thealgorithms/dynamicprogramming/UniqueSubsequencesCountTest.java b/src/test/java/com/thealgorithms/dynamicprogramming/UniqueSubsequencesCountTest.java index 171f2d28db8a..c10431a0aef9 100755 --- a/src/test/java/com/thealgorithms/dynamicprogramming/UniqueSubsequencesCountTest.java +++ b/src/test/java/com/thealgorithms/dynamicprogramming/UniqueSubsequencesCountTest.java @@ -4,26 +4,52 @@ import org.junit.jupiter.api.Test; -public final class UniqueSubsequencesCountTest { +public class UniqueSubsequencesCountTest { @Test void subseqCountTestOne() { String s = "abc"; - assertEquals(7, UniqueSubsequencesCount.subseqCount(s)); + assertEquals(7, UniqueSubsequencesCount.countSubsequences(s)); } @Test void subseqCountTestTwo() { String s = "abcdashgdhas"; - assertEquals(3592, UniqueSubsequencesCount.subseqCount(s)); + assertEquals(3592, UniqueSubsequencesCount.countSubsequences(s)); } @Test void subseqCountTestThree() { - String s = "aaaaa"; + String s = "a"; - assertEquals(5, UniqueSubsequencesCount.subseqCount(s)); + assertEquals(1, UniqueSubsequencesCount.countSubsequences(s)); + } + + @Test + void subseqCountTestFour() { + String s = "a b"; + + assertEquals(7, UniqueSubsequencesCount.countSubsequences(s)); + } + + @Test + void subseqCountTestFive() { + String s = "a1b2"; + + assertEquals(15, UniqueSubsequencesCount.countSubsequences(s)); + } + + @Test + void subseqCountTesSix() { + String s = "AaBb"; + assertEquals(15, UniqueSubsequencesCount.countSubsequences(s)); + } + + @Test + void subseqCountTesSeven() { + String s = "abab"; + assertEquals(11, UniqueSubsequencesCount.countSubsequences(s)); } } From ed36d8ab80f2f78306f9037e669681c38ee79041 Mon Sep 17 00:00:00 2001 From: Tuhinm2002 <75078694+Tuhinm2002@users.noreply.github.com> Date: Mon, 7 Oct 2024 22:28:28 +0530 Subject: [PATCH 11/21] Update UniqueSubsequencesCount.java --- .../dynamicprogramming/UniqueSubsequencesCount.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/com/thealgorithms/dynamicprogramming/UniqueSubsequencesCount.java b/src/main/java/com/thealgorithms/dynamicprogramming/UniqueSubsequencesCount.java index 2f427a750607..a292f942f3e4 100755 --- a/src/main/java/com/thealgorithms/dynamicprogramming/UniqueSubsequencesCount.java +++ b/src/main/java/com/thealgorithms/dynamicprogramming/UniqueSubsequencesCount.java @@ -12,7 +12,7 @@ * using dynamic programming and recursion. It ensures that duplicate characters * are not counted multiple times in the subsequences.

* - *

@author Author: https://github.com/Tuhinm2002

+ *

Author: https://github.com/Tuhinm2002

*/ public final class UniqueSubsequencesCount { From 697c1086ce133b1ab970872f5d62b699bdd85e03 Mon Sep 17 00:00:00 2001 From: Tuhinm2002 <75078694+Tuhinm2002@users.noreply.github.com> Date: Tue, 8 Oct 2024 01:16:00 +0530 Subject: [PATCH 12/21] Update UniqueSubsequencesCountTest.java --- .../UniqueSubsequencesCountTest.java | 52 +++---------------- 1 file changed, 6 insertions(+), 46 deletions(-) diff --git a/src/test/java/com/thealgorithms/dynamicprogramming/UniqueSubsequencesCountTest.java b/src/test/java/com/thealgorithms/dynamicprogramming/UniqueSubsequencesCountTest.java index c10431a0aef9..76bb061d298b 100755 --- a/src/test/java/com/thealgorithms/dynamicprogramming/UniqueSubsequencesCountTest.java +++ b/src/test/java/com/thealgorithms/dynamicprogramming/UniqueSubsequencesCountTest.java @@ -2,54 +2,14 @@ import static org.junit.jupiter.api.Assertions.assertEquals; -import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.CsvSource; public class UniqueSubsequencesCountTest { - @Test - void subseqCountTestOne() { - String s = "abc"; - - assertEquals(7, UniqueSubsequencesCount.countSubsequences(s)); - } - - @Test - void subseqCountTestTwo() { - String s = "abcdashgdhas"; - - assertEquals(3592, UniqueSubsequencesCount.countSubsequences(s)); - } - - @Test - void subseqCountTestThree() { - String s = "a"; - - assertEquals(1, UniqueSubsequencesCount.countSubsequences(s)); - } - - @Test - void subseqCountTestFour() { - String s = "a b"; - - assertEquals(7, UniqueSubsequencesCount.countSubsequences(s)); - } - - @Test - void subseqCountTestFive() { - String s = "a1b2"; - - assertEquals(15, UniqueSubsequencesCount.countSubsequences(s)); - } - - @Test - void subseqCountTesSix() { - String s = "AaBb"; - assertEquals(15, UniqueSubsequencesCount.countSubsequences(s)); - } - - @Test - void subseqCountTesSeven() { - String s = "abab"; - assertEquals(11, UniqueSubsequencesCount.countSubsequences(s)); + @ParameterizedTest + @CsvSource({"abc, 7", "abcdashgdhas, 3592", "a, 1", "'a b', 7", "a1b2, 15", "AaBb, 15", "abab, 11"}) + private void subseqCountParameterizedTest(String input, int expected) { + assertEquals(expected, UniqueSubsequencesCount.countSubsequences(input)); } } From 002d55f224522abf8f094e8deede21c18f0fd29f Mon Sep 17 00:00:00 2001 From: Tuhinm2002 <75078694+Tuhinm2002@users.noreply.github.com> Date: Tue, 8 Oct 2024 01:17:49 +0530 Subject: [PATCH 13/21] Update UniqueSubsequencesCount.java --- .../dynamicprogramming/UniqueSubsequencesCount.java | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/main/java/com/thealgorithms/dynamicprogramming/UniqueSubsequencesCount.java b/src/main/java/com/thealgorithms/dynamicprogramming/UniqueSubsequencesCount.java index a292f942f3e4..8c7ea6179e3f 100755 --- a/src/main/java/com/thealgorithms/dynamicprogramming/UniqueSubsequencesCount.java +++ b/src/main/java/com/thealgorithms/dynamicprogramming/UniqueSubsequencesCount.java @@ -36,14 +36,14 @@ private UniqueSubsequencesCount() { * @param str the input string from which subsequences are generated * @return the total count of unique subsequences */ - public static int countSubsequences(String str) { + public static int countSubseq(String str) { // DP array initialized to store intermediate results int[] dp = new int[str.length() + 1]; Arrays.fill(dp, -1); // Calls the recursive function to compute the result - return recursiveCall(str, 0, dp); + return countSubsequences(str, 0, dp); } /** @@ -59,7 +59,7 @@ public static int countSubsequences(String str) { * @return the total number of unique subsequences starting from the * current index */ - public static int recursiveCall(String st, int idx, int[] dp) { + public static int countSubsequences(String st, int idx, int[] dp) { // Base case: when index exceeds the string length if (idx >= st.length()) { @@ -88,7 +88,7 @@ public static int recursiveCall(String st, int idx, int[] dp) { set.add(st.charAt(j)); // 1 for the current subsequence + recursive call for the rest of the string - res = 1 + recursiveCall(st, j + 1, dp) + res; + res = 1 + countSubsequences(st, j + 1, dp) + res; } // Memoize the result From 1536eeb29e1c7f210375e8f6d64d4cecf94aed5d Mon Sep 17 00:00:00 2001 From: Tuhinm2002 <75078694+Tuhinm2002@users.noreply.github.com> Date: Tue, 8 Oct 2024 01:18:07 +0530 Subject: [PATCH 14/21] Update UniqueSubsequencesCountTest.java --- .../dynamicprogramming/UniqueSubsequencesCountTest.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/test/java/com/thealgorithms/dynamicprogramming/UniqueSubsequencesCountTest.java b/src/test/java/com/thealgorithms/dynamicprogramming/UniqueSubsequencesCountTest.java index 76bb061d298b..5f78cd8b3008 100755 --- a/src/test/java/com/thealgorithms/dynamicprogramming/UniqueSubsequencesCountTest.java +++ b/src/test/java/com/thealgorithms/dynamicprogramming/UniqueSubsequencesCountTest.java @@ -10,6 +10,6 @@ public class UniqueSubsequencesCountTest { @ParameterizedTest @CsvSource({"abc, 7", "abcdashgdhas, 3592", "a, 1", "'a b', 7", "a1b2, 15", "AaBb, 15", "abab, 11"}) private void subseqCountParameterizedTest(String input, int expected) { - assertEquals(expected, UniqueSubsequencesCount.countSubsequences(input)); + assertEquals(expected, UniqueSubsequencesCount.countSubseq(input)); } } From 5288a5a68dc65a0d17bed4adcb8aee26ade99b56 Mon Sep 17 00:00:00 2001 From: Tuhinm2002 <75078694+Tuhinm2002@users.noreply.github.com> Date: Tue, 8 Oct 2024 01:23:43 +0530 Subject: [PATCH 15/21] Update UniqueSubsequencesCountTest.java From 827b4d2df5daf53b70061a9b37aa28c8c90534f0 Mon Sep 17 00:00:00 2001 From: Tuhinm2002 <75078694+Tuhinm2002@users.noreply.github.com> Date: Tue, 8 Oct 2024 01:26:51 +0530 Subject: [PATCH 16/21] Update UniqueSubsequencesCountTest.java --- .../dynamicprogramming/UniqueSubsequencesCountTest.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/test/java/com/thealgorithms/dynamicprogramming/UniqueSubsequencesCountTest.java b/src/test/java/com/thealgorithms/dynamicprogramming/UniqueSubsequencesCountTest.java index 5f78cd8b3008..049804f58b5a 100755 --- a/src/test/java/com/thealgorithms/dynamicprogramming/UniqueSubsequencesCountTest.java +++ b/src/test/java/com/thealgorithms/dynamicprogramming/UniqueSubsequencesCountTest.java @@ -9,7 +9,7 @@ public class UniqueSubsequencesCountTest { @ParameterizedTest @CsvSource({"abc, 7", "abcdashgdhas, 3592", "a, 1", "'a b', 7", "a1b2, 15", "AaBb, 15", "abab, 11"}) - private void subseqCountParameterizedTest(String input, int expected) { + void subseqCountParameterizedTest(String input, int expected) { assertEquals(expected, UniqueSubsequencesCount.countSubseq(input)); } } From 574fcf4e27c5b4a4597b7fb26b84f59b177e1f10 Mon Sep 17 00:00:00 2001 From: Tuhinm2002 <75078694+Tuhinm2002@users.noreply.github.com> Date: Tue, 8 Oct 2024 10:32:16 +0530 Subject: [PATCH 17/21] Update UniqueSubsequencesCount.java From 2553434dcab1afd195681feb0858719bb189f78c Mon Sep 17 00:00:00 2001 From: tuhin Date: Thu, 10 Oct 2024 02:15:37 +0530 Subject: [PATCH 18/21] feat : new bitmanipulation algo --- .../bitmanipulation/SingleElement.java | 39 +++++++++++++++++++ .../bitmanipulation/SingleElementTest.java | 33 ++++++++++++++++ 2 files changed, 72 insertions(+) create mode 100644 src/main/java/com/thealgorithms/bitmanipulation/SingleElement.java create mode 100644 src/test/java/com/thealgorithms/bitmanipulation/SingleElementTest.java diff --git a/src/main/java/com/thealgorithms/bitmanipulation/SingleElement.java b/src/main/java/com/thealgorithms/bitmanipulation/SingleElement.java new file mode 100644 index 000000000000..85ebdf02db25 --- /dev/null +++ b/src/main/java/com/thealgorithms/bitmanipulation/SingleElement.java @@ -0,0 +1,39 @@ +package com.thealgorithms.bitmanipulation; + +/** + * Utility class to find the single non-duplicate element from an array + * where all other elements appear twice. + *

+ * The algorithm runs in O(n) time complexity and O(1) space complexity + * using bitwise XOR. + *

+ * + * @author Tuhin M + */ +public final class SingleElement { + + /** + * Private constructor to prevent instantiation of this utility class. + * Throws an UnsupportedOperationException if attempted. + */ + private SingleElement() { + throw new UnsupportedOperationException("Utility Class"); + } + + /** + * Finds the single non-duplicate element in an array where every other + * element appears exactly twice. Uses bitwise XOR to achieve O(n) time + * complexity and O(1) space complexity. + * + * @param arr the input array containing integers where every element + * except one appears exactly twice + * @return the single non-duplicate element + */ + public static int findSingleElement(int[] arr) { + int ele = 0; + for (int i = 0; i < arr.length; i++) { + ele ^= arr[i]; + } + return ele; + } +} diff --git a/src/test/java/com/thealgorithms/bitmanipulation/SingleElementTest.java b/src/test/java/com/thealgorithms/bitmanipulation/SingleElementTest.java new file mode 100644 index 000000000000..2e2afe99b0da --- /dev/null +++ b/src/test/java/com/thealgorithms/bitmanipulation/SingleElementTest.java @@ -0,0 +1,33 @@ +package com.thealgorithms.bitmanipulation; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +import java.util.stream.Stream; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; + +public final class SingleElementTest { + + /** + * Parameterized test to find the single non-duplicate element + * in the given arrays. + * + * @param arr the input array where every element appears twice except one + * @param expected the expected single element result + */ + @ParameterizedTest + @MethodSource("provideTestCases") + void testFindSingleElement(int[] arr, int expected) { + assertEquals(expected, SingleElement.findSingleElement(arr)); + } + + /** + * Provides test cases for the parameterized test. + * + * @return Stream of arguments consisting of arrays and expected results + */ + private static Stream provideTestCases() { + return Stream.of(Arguments.of(new int[] {1, 1, 2, 2, 4, 4, 3}, 3), Arguments.of(new int[] {1, 2, 2, 3, 3}, 1), Arguments.of(new int[] {10}, 10)); + } +} From f51b11b024c861f51c8672de802290f9321998d4 Mon Sep 17 00:00:00 2001 From: tuhin Date: Sat, 12 Oct 2024 13:41:15 +0530 Subject: [PATCH 19/21] feat : new bit algo --- .../bitmanipulation/FindNthBit.java | 46 +++++++++++++++++++ .../bitmanipulation/FindNthBitTest.java | 39 ++++++++++++++++ 2 files changed, 85 insertions(+) create mode 100644 src/main/java/com/thealgorithms/bitmanipulation/FindNthBit.java create mode 100644 src/test/java/com/thealgorithms/bitmanipulation/FindNthBitTest.java diff --git a/src/main/java/com/thealgorithms/bitmanipulation/FindNthBit.java b/src/main/java/com/thealgorithms/bitmanipulation/FindNthBit.java new file mode 100644 index 000000000000..cf647267035c --- /dev/null +++ b/src/main/java/com/thealgorithms/bitmanipulation/FindNthBit.java @@ -0,0 +1,46 @@ +package com.thealgorithms.bitmanipulation; + +/** + * A utility class to find the Nth bit of a given number. + * + *

This class provides a method to extract the value of the Nth bit (either 0 or 1) + * from the binary representation of a given integer. + * + *

Example: + * 

{@code
+ * int result = FindNthBit.findNthBit(5, 2); // returns 0 as the 2nd bit of 5 (binary 101) is 0.
+ * }
+ * + *

Author: Tuhinm2002 + */ +public final class FindNthBit { + + /** + * Private constructor to prevent instantiation. + * + *

This is a utility class, and it should not be instantiated. + * Attempting to instantiate this class will throw an UnsupportedOperationException. + */ + private FindNthBit() { + throw new UnsupportedOperationException("Utility class"); + } + + /** + * Finds the value of the Nth bit of the given number. + * + *

This method uses bitwise operations to extract the Nth bit from the + * binary representation of the given integer. + * + * @param num the integer number whose Nth bit is to be found + * @param n the bit position (1-based) to retrieve + * @return the value of the Nth bit (0 or 1) + * @throws IllegalArgumentException if the bit position is less than 1 + */ + public static int findNthBit(int num, int n) { + if (n < 1) { + throw new IllegalArgumentException("Bit position must be greater than or equal to 1."); + } + // Shifting the number to the right by (n - 1) positions and checking the last bit + return ((num & (1 << (n - 1))) >> (n - 1)); + } +} diff --git a/src/test/java/com/thealgorithms/bitmanipulation/FindNthBitTest.java b/src/test/java/com/thealgorithms/bitmanipulation/FindNthBitTest.java new file mode 100644 index 000000000000..2eb9555eb4a8 --- /dev/null +++ b/src/test/java/com/thealgorithms/bitmanipulation/FindNthBitTest.java @@ -0,0 +1,39 @@ +package com.thealgorithms.bitmanipulation; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +import java.util.stream.Stream; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; + +public final class FindNthBitTest { + + /** + * A parameterized test that checks the value of the Nth bit for different inputs. + * + * @param num the number whose Nth bit is being tested + * @param n the bit position + * @param expected the expected value of the Nth bit (0 or 1) + */ + @ParameterizedTest + @MethodSource("provideTestCases") + void findNthBitParameterizedTest(int num, int n, int expected) { + assertEquals(expected, FindNthBit.findNthBit(num, n)); + } + + /** + * Provides the test cases as a stream of arguments for the parameterized test. + * + * @return a stream of test cases where each case consists of a number, the bit position, + * and the expected result. + */ + private static Stream provideTestCases() { + return Stream.of(Arguments.of(13, 2, 0), // binary: 1101, 2nd bit is 0 + Arguments.of(13, 3, 1), // binary: 1101, 3rd bit is 1 + Arguments.of(4, 2, 0), // binary: 100, 2nd bit is 0 + Arguments.of(4, 3, 1), // binary: 100, 3rd bit is 1 + Arguments.of(1, 1, 1) // binary: 1, 1st bit is 1 + ); + } +} From 4242f28f8dfd5159d8eff75e0473ab8a9f70cade Mon Sep 17 00:00:00 2001 From: Tuhinm2002 <75078694+Tuhinm2002@users.noreply.github.com> Date: Sat, 12 Oct 2024 13:46:32 +0530 Subject: [PATCH 20/21] Update FindNthBitTest.java --- .../com/thealgorithms/bitmanipulation/FindNthBitTest.java | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/test/java/com/thealgorithms/bitmanipulation/FindNthBitTest.java b/src/test/java/com/thealgorithms/bitmanipulation/FindNthBitTest.java index 2eb9555eb4a8..978003d21358 100644 --- a/src/test/java/com/thealgorithms/bitmanipulation/FindNthBitTest.java +++ b/src/test/java/com/thealgorithms/bitmanipulation/FindNthBitTest.java @@ -30,10 +30,10 @@ void findNthBitParameterizedTest(int num, int n, int expected) { */ private static Stream provideTestCases() { return Stream.of(Arguments.of(13, 2, 0), // binary: 1101, 2nd bit is 0 - Arguments.of(13, 3, 1), // binary: 1101, 3rd bit is 1 - Arguments.of(4, 2, 0), // binary: 100, 2nd bit is 0 - Arguments.of(4, 3, 1), // binary: 100, 3rd bit is 1 - Arguments.of(1, 1, 1) // binary: 1, 1st bit is 1 + Arguments.of(13, 3, 1), // binary: 1101, 3rd bit is 1 + Arguments.of(4, 2, 0), // binary: 100, 2nd bit is 0 + Arguments.of(4, 3, 1), // binary: 100, 3rd bit is 1 + Arguments.of(1, 1, 1) // binary: 1, 1st bit is 1 ); } } From 05280abb8d03e4808e0b677ed33591461e45b4ad Mon Sep 17 00:00:00 2001 From: Tuhinm2002 <75078694+Tuhinm2002@users.noreply.github.com> Date: Sat, 12 Oct 2024 13:53:41 +0530 Subject: [PATCH 21/21] Update FindNthBit.java --- src/main/java/com/thealgorithms/bitmanipulation/FindNthBit.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/com/thealgorithms/bitmanipulation/FindNthBit.java b/src/main/java/com/thealgorithms/bitmanipulation/FindNthBit.java index cf647267035c..7a35fc3feebf 100644 --- a/src/main/java/com/thealgorithms/bitmanipulation/FindNthBit.java +++ b/src/main/java/com/thealgorithms/bitmanipulation/FindNthBit.java @@ -41,6 +41,6 @@ public static int findNthBit(int num, int n) { throw new IllegalArgumentException("Bit position must be greater than or equal to 1."); } // Shifting the number to the right by (n - 1) positions and checking the last bit - return ((num & (1 << (n - 1))) >> (n - 1)); + return (num & (1 << (n - 1))) >> (n - 1); } }