From 82b0ba1d6eec8ad20819682d251b460a3dceb8ec Mon Sep 17 00:00:00 2001 From: alxkm <> Date: Wed, 22 May 2024 23:13:50 +0300 Subject: [PATCH 01/13] Adding class for generating all subsequences from a given List --- .../backtracking/Subsequence.java | 50 +++++++++++++++ .../backtracking/SubsequenceTest.java | 62 +++++++++++++++++++ 2 files changed, 112 insertions(+) create mode 100644 src/main/java/com/thealgorithms/backtracking/Subsequence.java create mode 100644 src/test/java/com/thealgorithms/backtracking/SubsequenceTest.java diff --git a/src/main/java/com/thealgorithms/backtracking/Subsequence.java b/src/main/java/com/thealgorithms/backtracking/Subsequence.java new file mode 100644 index 000000000000..12d359840785 --- /dev/null +++ b/src/main/java/com/thealgorithms/backtracking/Subsequence.java @@ -0,0 +1,50 @@ +package com.thealgorithms.backtracking; + +import java.util.ArrayList; +import java.util.List; + +/** + * Class generates all subsequences for a given list of elements using backtracking + */ +public class Subsequence { + /** + * Find all subsequences of given list using backtracking + * + * @param sequence a list of items on the basis of which we need to generate all subsequences + * @param the type of elements in the array + * @return a list of all subsequences + */ + public static List> generateAllSubsequences(List sequence) { + List> allSubSequences = new ArrayList<>(); + if (sequence.isEmpty()) { + allSubSequences.add(new ArrayList<>()); + return allSubSequences; + } + List currentSubsequence = new ArrayList<>(); + backtrack(sequence, currentSubsequence, 0, allSubSequences); + return allSubSequences; + } + + /** + * Iterate through each branch of states + * We know that each state has exactly two branching + * It terminates when it reaches the end of the given sequence + * + * @param sequence all elements + * @param currentSubsequence current subsequence + * @param index current index + * @param allSubSequences contains all sequences + * @param the type of elements which we generate + */ + private static void backtrack(List sequence, List currentSubsequence, int index, List> allSubSequences) { + if (index == sequence.size()) { + allSubSequences.add(new ArrayList<>(currentSubsequence)); + return; + } + + backtrack(sequence, currentSubsequence, index + 1, allSubSequences); + currentSubsequence.add(sequence.get(index)); + backtrack(sequence, currentSubsequence, index + 1, allSubSequences); + currentSubsequence.removeLast(); + } +} diff --git a/src/test/java/com/thealgorithms/backtracking/SubsequenceTest.java b/src/test/java/com/thealgorithms/backtracking/SubsequenceTest.java new file mode 100644 index 000000000000..919c460f89ad --- /dev/null +++ b/src/test/java/com/thealgorithms/backtracking/SubsequenceTest.java @@ -0,0 +1,62 @@ +package com.thealgorithms.backtracking; + +import org.junit.jupiter.api.Test; + +import java.util.ArrayList; +import java.util.List; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertIterableEquals; + +public class SubsequenceTest { + + @Test + void testNoElement() { + List> emptyResult = Subsequence.generateAllSubsequences(new ArrayList<>()); + assertEquals(1, emptyResult.size()); + assertEquals(0, emptyResult.get(0).size()); + } + + @Test + void testLengthOfTwo() { + List> expected = List.of( + List.of(), + List.of(2), + List.of(1), + List.of(1, 2) + ); + List> actual = Subsequence.generateAllSubsequences(List.of(1, 2)); + assertIterableEquals(expected, actual); + } + + @Test + void testLengthOfThree() { + List> expected = List.of( + List.of(), + List.of("C"), + List.of("B"), + List.of("B", "C"), + List.of("A"), + List.of("A", "C"), + List.of("A", "B"), + List.of("A", "B", "C") + ); + List> actual = Subsequence.generateAllSubsequences(List.of("A", "B", "C")); + assertIterableEquals(expected, actual); + } + + @Test + void testLengthOfThreeInteger() { + List> expected = List.of( + List.of(), + List.of(3), + List.of(2), + List.of(2, 3), + List.of(1), + List.of(1, 3), + List.of(1, 2), + List.of(1, 2, 3) + ); + List> actual = Subsequence.generateAllSubsequences(List.of(1, 2, 3)); + assertIterableEquals(expected, actual); + } +} From 822a69489c164786fe7dbac5d5b9dcb4a70c3f09 Mon Sep 17 00:00:00 2001 From: alxkm <> Date: Wed, 29 May 2024 20:06:48 +0300 Subject: [PATCH 02/13] Fix test data format --- .../backtracking/SubsequenceTest.java | 33 ++++--------------- 1 file changed, 6 insertions(+), 27 deletions(-) diff --git a/src/test/java/com/thealgorithms/backtracking/SubsequenceTest.java b/src/test/java/com/thealgorithms/backtracking/SubsequenceTest.java index 919c460f89ad..dd730c94da3c 100644 --- a/src/test/java/com/thealgorithms/backtracking/SubsequenceTest.java +++ b/src/test/java/com/thealgorithms/backtracking/SubsequenceTest.java @@ -1,11 +1,11 @@ package com.thealgorithms.backtracking; -import org.junit.jupiter.api.Test; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertIterableEquals; import java.util.ArrayList; import java.util.List; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertIterableEquals; +import org.junit.jupiter.api.Test; public class SubsequenceTest { @@ -18,27 +18,14 @@ void testNoElement() { @Test void testLengthOfTwo() { - List> expected = List.of( - List.of(), - List.of(2), - List.of(1), - List.of(1, 2) - ); + List> expected = List.of(List.of(), List.of(2), List.of(1), List.of(1, 2)); List> actual = Subsequence.generateAllSubsequences(List.of(1, 2)); assertIterableEquals(expected, actual); } @Test void testLengthOfThree() { - List> expected = List.of( - List.of(), - List.of("C"), - List.of("B"), - List.of("B", "C"), - List.of("A"), - List.of("A", "C"), - List.of("A", "B"), - List.of("A", "B", "C") + List> expected = List.of(List.of(), List.of("C"), List.of("B"), List.of("B", "C"), List.of("A"), List.of("A", "C"), List.of("A", "B"), List.of("A", "B", "C") ); List> actual = Subsequence.generateAllSubsequences(List.of("A", "B", "C")); assertIterableEquals(expected, actual); @@ -46,15 +33,7 @@ void testLengthOfThree() { @Test void testLengthOfThreeInteger() { - List> expected = List.of( - List.of(), - List.of(3), - List.of(2), - List.of(2, 3), - List.of(1), - List.of(1, 3), - List.of(1, 2), - List.of(1, 2, 3) + List> expected = List.of(List.of(), List.of(3), List.of(2), List.of(2, 3), List.of(1), List.of(1, 3), List.of(1, 2), List.of(1, 2, 3) ); List> actual = Subsequence.generateAllSubsequences(List.of(1, 2, 3)); assertIterableEquals(expected, actual); From c27bd88d8cb826856712c3a118dfb3e606e0424c Mon Sep 17 00:00:00 2001 From: alxkm <> Date: Wed, 29 May 2024 20:08:07 +0300 Subject: [PATCH 03/13] Fix braces wrong placement --- .../com/thealgorithms/backtracking/SubsequenceTest.java | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/src/test/java/com/thealgorithms/backtracking/SubsequenceTest.java b/src/test/java/com/thealgorithms/backtracking/SubsequenceTest.java index dd730c94da3c..1936dd2d6656 100644 --- a/src/test/java/com/thealgorithms/backtracking/SubsequenceTest.java +++ b/src/test/java/com/thealgorithms/backtracking/SubsequenceTest.java @@ -25,16 +25,14 @@ void testLengthOfTwo() { @Test void testLengthOfThree() { - List> expected = List.of(List.of(), List.of("C"), List.of("B"), List.of("B", "C"), List.of("A"), List.of("A", "C"), List.of("A", "B"), List.of("A", "B", "C") - ); + List> expected = List.of(List.of(), List.of("C"), List.of("B"), List.of("B", "C"), List.of("A"), List.of("A", "C"), List.of("A", "B"), List.of("A", "B", "C")); List> actual = Subsequence.generateAllSubsequences(List.of("A", "B", "C")); assertIterableEquals(expected, actual); } @Test void testLengthOfThreeInteger() { - List> expected = List.of(List.of(), List.of(3), List.of(2), List.of(2, 3), List.of(1), List.of(1, 3), List.of(1, 2), List.of(1, 2, 3) - ); + List> expected = List.of(List.of(), List.of(3), List.of(2), List.of(2, 3), List.of(1), List.of(1, 3), List.of(1, 2), List.of(1, 2, 3)); List> actual = Subsequence.generateAllSubsequences(List.of(1, 2, 3)); assertIterableEquals(expected, actual); } From 959a6d1d93f2d9cd9d195b1cd7f3d461fead3d37 Mon Sep 17 00:00:00 2001 From: alxkm <> Date: Wed, 29 May 2024 22:41:19 +0300 Subject: [PATCH 04/13] Fix "Utility classes should not have a public or default constructor." --- src/main/java/com/thealgorithms/backtracking/Subsequence.java | 3 +++ 1 file changed, 3 insertions(+) diff --git a/src/main/java/com/thealgorithms/backtracking/Subsequence.java b/src/main/java/com/thealgorithms/backtracking/Subsequence.java index 12d359840785..6be5c7adf292 100644 --- a/src/main/java/com/thealgorithms/backtracking/Subsequence.java +++ b/src/main/java/com/thealgorithms/backtracking/Subsequence.java @@ -7,6 +7,9 @@ * Class generates all subsequences for a given list of elements using backtracking */ public class Subsequence { + private Subsequence() { + } + /** * Find all subsequences of given list using backtracking * From 82084d81aaf1edd0ab53145655057be045216038 Mon Sep 17 00:00:00 2001 From: alxkm <> Date: Wed, 29 May 2024 23:00:51 +0300 Subject: [PATCH 05/13] Fix checkstyle " Class Subsequence should be declared as final." --- src/main/java/com/thealgorithms/backtracking/Subsequence.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/com/thealgorithms/backtracking/Subsequence.java b/src/main/java/com/thealgorithms/backtracking/Subsequence.java index 6be5c7adf292..3429fe640c3a 100644 --- a/src/main/java/com/thealgorithms/backtracking/Subsequence.java +++ b/src/main/java/com/thealgorithms/backtracking/Subsequence.java @@ -6,7 +6,7 @@ /** * Class generates all subsequences for a given list of elements using backtracking */ -public class Subsequence { +public final class Subsequence { private Subsequence() { } From 839c589479a68a9824d056eb3dddb22bb3ddb1d2 Mon Sep 17 00:00:00 2001 From: alxkm <> Date: Thu, 30 May 2024 12:06:35 +0300 Subject: [PATCH 06/13] Renaming class Subsequence to SubsequenceFinder. Refactored test to Parametrized test. Fixed input parameter as final. --- ...ubsequence.java => SubsequenceFinder.java} | 6 +-- .../backtracking/SubsequenceTest.java | 41 ++++++++----------- 2 files changed, 20 insertions(+), 27 deletions(-) rename src/main/java/com/thealgorithms/backtracking/{Subsequence.java => SubsequenceFinder.java} (92%) diff --git a/src/main/java/com/thealgorithms/backtracking/Subsequence.java b/src/main/java/com/thealgorithms/backtracking/SubsequenceFinder.java similarity index 92% rename from src/main/java/com/thealgorithms/backtracking/Subsequence.java rename to src/main/java/com/thealgorithms/backtracking/SubsequenceFinder.java index 3429fe640c3a..b48600b37f41 100644 --- a/src/main/java/com/thealgorithms/backtracking/Subsequence.java +++ b/src/main/java/com/thealgorithms/backtracking/SubsequenceFinder.java @@ -6,8 +6,8 @@ /** * Class generates all subsequences for a given list of elements using backtracking */ -public final class Subsequence { - private Subsequence() { +public final class SubsequenceFinder { + private SubsequenceFinder() { } /** @@ -39,7 +39,7 @@ public static List> generateAllSubsequences(List sequence) { * @param allSubSequences contains all sequences * @param the type of elements which we generate */ - private static void backtrack(List sequence, List currentSubsequence, int index, List> allSubSequences) { + private static void backtrack(List sequence, List currentSubsequence, final int index, List> allSubSequences) { if (index == sequence.size()) { allSubSequences.add(new ArrayList<>(currentSubsequence)); return; diff --git a/src/test/java/com/thealgorithms/backtracking/SubsequenceTest.java b/src/test/java/com/thealgorithms/backtracking/SubsequenceTest.java index 1936dd2d6656..1143622baeb2 100644 --- a/src/test/java/com/thealgorithms/backtracking/SubsequenceTest.java +++ b/src/test/java/com/thealgorithms/backtracking/SubsequenceTest.java @@ -1,39 +1,32 @@ package com.thealgorithms.backtracking; -import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertIterableEquals; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; + import java.util.ArrayList; import java.util.List; -import org.junit.jupiter.api.Test; +import java.util.stream.Stream; public class SubsequenceTest { - @Test - void testNoElement() { - List> emptyResult = Subsequence.generateAllSubsequences(new ArrayList<>()); - assertEquals(1, emptyResult.size()); - assertEquals(0, emptyResult.get(0).size()); - } - - @Test - void testLengthOfTwo() { - List> expected = List.of(List.of(), List.of(2), List.of(1), List.of(1, 2)); - List> actual = Subsequence.generateAllSubsequences(List.of(1, 2)); - assertIterableEquals(expected, actual); + @ParameterizedTest + @MethodSource("getSubsequenceTestData") + void testSubsequences(SubsequenceTestData testData) { + List> actual = SubsequenceFinder.generateAllSubsequences(testData.input()); + assertIterableEquals(testData.expected(), actual); } - @Test - void testLengthOfThree() { - List> expected = List.of(List.of(), List.of("C"), List.of("B"), List.of("B", "C"), List.of("A"), List.of("A", "C"), List.of("A", "B"), List.of("A", "B", "C")); - List> actual = Subsequence.generateAllSubsequences(List.of("A", "B", "C")); - assertIterableEquals(expected, actual); + static Stream getSubsequenceTestData() { + return Stream.of( + new SubsequenceTestData(new ArrayList<>(), List.of(List.of())), + new SubsequenceTestData(List.of(1, 2), List.of(List.of(), List.of(2), List.of(1), List.of(1, 2))), + new SubsequenceTestData(List.of("A", "B", "C"), List.of(List.of(), List.of("C"), List.of("B"), List.of("B", "C"), List.of("A"), List.of("A", "C"), List.of("A", "B"), List.of("A", "B", "C"))), + new SubsequenceTestData(List.of(1, 2, 3), List.of(List.of(), List.of(3), List.of(2), List.of(2, 3), List.of(1), List.of(1, 3), List.of(1, 2), List.of(1, 2, 3))) + ); } - @Test - void testLengthOfThreeInteger() { - List> expected = List.of(List.of(), List.of(3), List.of(2), List.of(2, 3), List.of(1), List.of(1, 3), List.of(1, 2), List.of(1, 2, 3)); - List> actual = Subsequence.generateAllSubsequences(List.of(1, 2, 3)); - assertIterableEquals(expected, actual); + record SubsequenceTestData(List input, List> expected) { } } From 2b6f77edfb1dd161007e9a8b8535c5d670b24052 Mon Sep 17 00:00:00 2001 From: alxkm <> Date: Thu, 30 May 2024 12:16:36 +0300 Subject: [PATCH 07/13] Fix formatting --- .../java/com/thealgorithms/backtracking/SubsequenceTest.java | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/test/java/com/thealgorithms/backtracking/SubsequenceTest.java b/src/test/java/com/thealgorithms/backtracking/SubsequenceTest.java index 1143622baeb2..2cc767be9eb2 100644 --- a/src/test/java/com/thealgorithms/backtracking/SubsequenceTest.java +++ b/src/test/java/com/thealgorithms/backtracking/SubsequenceTest.java @@ -19,8 +19,7 @@ void testSubsequences(SubsequenceTestData testData) { } static Stream getSubsequenceTestData() { - return Stream.of( - new SubsequenceTestData(new ArrayList<>(), List.of(List.of())), + return Stream.of(new SubsequenceTestData(new ArrayList<>(), List.of(List.of())), new SubsequenceTestData(List.of(1, 2), List.of(List.of(), List.of(2), List.of(1), List.of(1, 2))), new SubsequenceTestData(List.of("A", "B", "C"), List.of(List.of(), List.of("C"), List.of("B"), List.of("B", "C"), List.of("A"), List.of("A", "C"), List.of("A", "B"), List.of("A", "B", "C"))), new SubsequenceTestData(List.of(1, 2, 3), List.of(List.of(), List.of(3), List.of(2), List.of(2, 3), List.of(1), List.of(1, 3), List.of(1, 2), List.of(1, 2, 3))) From a55f65673727be0f60805291395cda567459e847 Mon Sep 17 00:00:00 2001 From: alxkm <> Date: Thu, 30 May 2024 12:26:40 +0300 Subject: [PATCH 08/13] Fix formatting --- .../com/thealgorithms/backtracking/SubsequenceTest.java | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/src/test/java/com/thealgorithms/backtracking/SubsequenceTest.java b/src/test/java/com/thealgorithms/backtracking/SubsequenceTest.java index 2cc767be9eb2..2816bbd9c6c3 100644 --- a/src/test/java/com/thealgorithms/backtracking/SubsequenceTest.java +++ b/src/test/java/com/thealgorithms/backtracking/SubsequenceTest.java @@ -19,11 +19,9 @@ void testSubsequences(SubsequenceTestData testData) { } static Stream getSubsequenceTestData() { - return Stream.of(new SubsequenceTestData(new ArrayList<>(), List.of(List.of())), - new SubsequenceTestData(List.of(1, 2), List.of(List.of(), List.of(2), List.of(1), List.of(1, 2))), + return Stream.of(new SubsequenceTestData(new ArrayList<>(), List.of(List.of())), new SubsequenceTestData(List.of(1, 2), List.of(List.of(), List.of(2), List.of(1), List.of(1, 2))), new SubsequenceTestData(List.of("A", "B", "C"), List.of(List.of(), List.of("C"), List.of("B"), List.of("B", "C"), List.of("A"), List.of("A", "C"), List.of("A", "B"), List.of("A", "B", "C"))), - new SubsequenceTestData(List.of(1, 2, 3), List.of(List.of(), List.of(3), List.of(2), List.of(2, 3), List.of(1), List.of(1, 3), List.of(1, 2), List.of(1, 2, 3))) - ); + new SubsequenceTestData(List.of(1, 2, 3), List.of(List.of(), List.of(3), List.of(2), List.of(2, 3), List.of(1), List.of(1, 3), List.of(1, 2), List.of(1, 2, 3)))); } record SubsequenceTestData(List input, List> expected) { From 6ffdc6b2bbfc22fc4a5cad19ef9d601ca7ef8041 Mon Sep 17 00:00:00 2001 From: alxkm <> Date: Thu, 30 May 2024 12:48:39 +0300 Subject: [PATCH 09/13] Fix formatting --- .../java/com/thealgorithms/backtracking/SubsequenceTest.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/test/java/com/thealgorithms/backtracking/SubsequenceTest.java b/src/test/java/com/thealgorithms/backtracking/SubsequenceTest.java index 2816bbd9c6c3..e49cb2fcb6f8 100644 --- a/src/test/java/com/thealgorithms/backtracking/SubsequenceTest.java +++ b/src/test/java/com/thealgorithms/backtracking/SubsequenceTest.java @@ -20,8 +20,8 @@ void testSubsequences(SubsequenceTestData testData) { static Stream getSubsequenceTestData() { return Stream.of(new SubsequenceTestData(new ArrayList<>(), List.of(List.of())), new SubsequenceTestData(List.of(1, 2), List.of(List.of(), List.of(2), List.of(1), List.of(1, 2))), - new SubsequenceTestData(List.of("A", "B", "C"), List.of(List.of(), List.of("C"), List.of("B"), List.of("B", "C"), List.of("A"), List.of("A", "C"), List.of("A", "B"), List.of("A", "B", "C"))), - new SubsequenceTestData(List.of(1, 2, 3), List.of(List.of(), List.of(3), List.of(2), List.of(2, 3), List.of(1), List.of(1, 3), List.of(1, 2), List.of(1, 2, 3)))); + new SubsequenceTestData(List.of("A", "B", "C"), List.of(List.of(), List.of("C"), List.of("B"), List.of("B", "C"), List.of("A"), List.of("A", "C"), List.of("A", "B"), List.of("A", "B", "C"))), + new SubsequenceTestData(List.of(1, 2, 3), List.of(List.of(), List.of(3), List.of(2), List.of(2, 3), List.of(1), List.of(1, 3), List.of(1, 2), List.of(1, 2, 3)))); } record SubsequenceTestData(List input, List> expected) { From 927b362cebf0e7fdf01f1b35750e46027ebbfe6b Mon Sep 17 00:00:00 2001 From: alxkm <> Date: Thu, 30 May 2024 13:35:11 +0300 Subject: [PATCH 10/13] Fix import ordering --- .../java/com/thealgorithms/backtracking/SubsequenceTest.java | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/src/test/java/com/thealgorithms/backtracking/SubsequenceTest.java b/src/test/java/com/thealgorithms/backtracking/SubsequenceTest.java index e49cb2fcb6f8..09024135cf7d 100644 --- a/src/test/java/com/thealgorithms/backtracking/SubsequenceTest.java +++ b/src/test/java/com/thealgorithms/backtracking/SubsequenceTest.java @@ -2,12 +2,11 @@ import static org.junit.jupiter.api.Assertions.assertIterableEquals; -import org.junit.jupiter.params.ParameterizedTest; -import org.junit.jupiter.params.provider.MethodSource; - import java.util.ArrayList; import java.util.List; import java.util.stream.Stream; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; public class SubsequenceTest { From 3c0e12e60fe7134b994de0d121dc0730efef609e Mon Sep 17 00:00:00 2001 From: alxkm <> Date: Thu, 30 May 2024 16:14:46 +0300 Subject: [PATCH 11/13] Renaming method generate all. Renaming test method. Adding duplication test. Renaming TestData to TestCase. --- .../backtracking/SubsequenceFinder.java | 2 +- .../backtracking/SubsequenceFinderTest.java | 29 +++++++++++++++++++ .../backtracking/SubsequenceTest.java | 28 ------------------ 3 files changed, 30 insertions(+), 29 deletions(-) create mode 100644 src/test/java/com/thealgorithms/backtracking/SubsequenceFinderTest.java delete mode 100644 src/test/java/com/thealgorithms/backtracking/SubsequenceTest.java diff --git a/src/main/java/com/thealgorithms/backtracking/SubsequenceFinder.java b/src/main/java/com/thealgorithms/backtracking/SubsequenceFinder.java index b48600b37f41..2de540ca728c 100644 --- a/src/main/java/com/thealgorithms/backtracking/SubsequenceFinder.java +++ b/src/main/java/com/thealgorithms/backtracking/SubsequenceFinder.java @@ -17,7 +17,7 @@ private SubsequenceFinder() { * @param the type of elements in the array * @return a list of all subsequences */ - public static List> generateAllSubsequences(List sequence) { + public static List> generateAll(List sequence) { List> allSubSequences = new ArrayList<>(); if (sequence.isEmpty()) { allSubSequences.add(new ArrayList<>()); diff --git a/src/test/java/com/thealgorithms/backtracking/SubsequenceFinderTest.java b/src/test/java/com/thealgorithms/backtracking/SubsequenceFinderTest.java new file mode 100644 index 000000000000..a753343c3eba --- /dev/null +++ b/src/test/java/com/thealgorithms/backtracking/SubsequenceFinderTest.java @@ -0,0 +1,29 @@ +package com.thealgorithms.backtracking; + +import static org.junit.jupiter.api.Assertions.assertIterableEquals; + +import java.util.ArrayList; +import java.util.List; +import java.util.stream.Stream; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; + +public class SubsequenceFinderTest { + + @ParameterizedTest + @MethodSource("getTestCases") + void testGenerateAll(TestCase testData) { + final var actual = SubsequenceFinder.generateAll(testData.input()); + assertIterableEquals(testData.expected(), actual); + } + + static Stream getTestCases() { + return Stream.of(new TestCase(new ArrayList<>(), List.of(List.of())), new TestCase(List.of(1, 2), List.of(List.of(), List.of(2), List.of(1), List.of(1, 2))), + new TestCase(List.of("A", "B", "C"), List.of(List.of(), List.of("C"), List.of("B"), List.of("B", "C"), List.of("A"), List.of("A", "C"), List.of("A", "B"), List.of("A", "B", "C"))), + new TestCase(List.of(1, 2, 3), List.of(List.of(), List.of(3), List.of(2), List.of(2, 3), List.of(1), List.of(1, 3), List.of(1, 2), List.of(1, 2, 3))), + new TestCase(List.of(2, 2), List.of(List.of(), List.of(2), List.of(2), List.of(2, 2)))); + } + + record TestCase(List input, List> expected) { + } +} diff --git a/src/test/java/com/thealgorithms/backtracking/SubsequenceTest.java b/src/test/java/com/thealgorithms/backtracking/SubsequenceTest.java deleted file mode 100644 index 09024135cf7d..000000000000 --- a/src/test/java/com/thealgorithms/backtracking/SubsequenceTest.java +++ /dev/null @@ -1,28 +0,0 @@ -package com.thealgorithms.backtracking; - -import static org.junit.jupiter.api.Assertions.assertIterableEquals; - -import java.util.ArrayList; -import java.util.List; -import java.util.stream.Stream; -import org.junit.jupiter.params.ParameterizedTest; -import org.junit.jupiter.params.provider.MethodSource; - -public class SubsequenceTest { - - @ParameterizedTest - @MethodSource("getSubsequenceTestData") - void testSubsequences(SubsequenceTestData testData) { - List> actual = SubsequenceFinder.generateAllSubsequences(testData.input()); - assertIterableEquals(testData.expected(), actual); - } - - static Stream getSubsequenceTestData() { - return Stream.of(new SubsequenceTestData(new ArrayList<>(), List.of(List.of())), new SubsequenceTestData(List.of(1, 2), List.of(List.of(), List.of(2), List.of(1), List.of(1, 2))), - new SubsequenceTestData(List.of("A", "B", "C"), List.of(List.of(), List.of("C"), List.of("B"), List.of("B", "C"), List.of("A"), List.of("A", "C"), List.of("A", "B"), List.of("A", "B", "C"))), - new SubsequenceTestData(List.of(1, 2, 3), List.of(List.of(), List.of(3), List.of(2), List.of(2, 3), List.of(1), List.of(1, 3), List.of(1, 2), List.of(1, 2, 3)))); - } - - record SubsequenceTestData(List input, List> expected) { - } -} From d4b69df5b3be839a9c3dcb768e27f70f1b788100 Mon Sep 17 00:00:00 2001 From: alxkm <> Date: Thu, 30 May 2024 16:45:53 +0300 Subject: [PATCH 12/13] Fix formatting --- .../com/thealgorithms/backtracking/SubsequenceFinderTest.java | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/test/java/com/thealgorithms/backtracking/SubsequenceFinderTest.java b/src/test/java/com/thealgorithms/backtracking/SubsequenceFinderTest.java index a753343c3eba..dac2e2675674 100644 --- a/src/test/java/com/thealgorithms/backtracking/SubsequenceFinderTest.java +++ b/src/test/java/com/thealgorithms/backtracking/SubsequenceFinderTest.java @@ -20,8 +20,7 @@ void testGenerateAll(TestCase testData) { static Stream getTestCases() { return Stream.of(new TestCase(new ArrayList<>(), List.of(List.of())), new TestCase(List.of(1, 2), List.of(List.of(), List.of(2), List.of(1), List.of(1, 2))), new TestCase(List.of("A", "B", "C"), List.of(List.of(), List.of("C"), List.of("B"), List.of("B", "C"), List.of("A"), List.of("A", "C"), List.of("A", "B"), List.of("A", "B", "C"))), - new TestCase(List.of(1, 2, 3), List.of(List.of(), List.of(3), List.of(2), List.of(2, 3), List.of(1), List.of(1, 3), List.of(1, 2), List.of(1, 2, 3))), - new TestCase(List.of(2, 2), List.of(List.of(), List.of(2), List.of(2), List.of(2, 2)))); + new TestCase(List.of(1, 2, 3), List.of(List.of(), List.of(3), List.of(2), List.of(2, 3), List.of(1), List.of(1, 3), List.of(1, 2), List.of(1, 2, 3))), new TestCase(List.of(2, 2), List.of(List.of(), List.of(2), List.of(2), List.of(2, 2)))); } record TestCase(List input, List> expected) { From 3d0d76b464aceeb564577f2544accf2ebedc5a5a Mon Sep 17 00:00:00 2001 From: Piotr Idzik <65706193+vil02@users.noreply.github.com> Date: Thu, 30 May 2024 20:41:14 +0200 Subject: [PATCH 13/13] style: add assertion to avoid potential infinite loop --- .../java/com/thealgorithms/backtracking/SubsequenceFinder.java | 1 + 1 file changed, 1 insertion(+) diff --git a/src/main/java/com/thealgorithms/backtracking/SubsequenceFinder.java b/src/main/java/com/thealgorithms/backtracking/SubsequenceFinder.java index 2de540ca728c..4a159dbfe0b1 100644 --- a/src/main/java/com/thealgorithms/backtracking/SubsequenceFinder.java +++ b/src/main/java/com/thealgorithms/backtracking/SubsequenceFinder.java @@ -40,6 +40,7 @@ public static List> generateAll(List sequence) { * @param the type of elements which we generate */ private static void backtrack(List sequence, List currentSubsequence, final int index, List> allSubSequences) { + assert index <= sequence.size(); if (index == sequence.size()) { allSubSequences.add(new ArrayList<>(currentSubsequence)); return;