From 9be8b790dd9efadd465010dae569703b8980f46e Mon Sep 17 00:00:00 2001 From: CuTyche Date: Thu, 2 Oct 2025 16:52:57 +0530 Subject: [PATCH 1/4] Added doctests --- backtracking/all_permutations.py | 112 ++++++++++++++----------------- 1 file changed, 50 insertions(+), 62 deletions(-) diff --git a/backtracking/all_permutations.py b/backtracking/all_permutations.py index f376e6fa0945..f9701e1411c7 100644 --- a/backtracking/all_permutations.py +++ b/backtracking/all_permutations.py @@ -1,88 +1,76 @@ """ -In this problem, we want to determine all possible permutations -of the given sequence. We use backtracking to solve this problem. +Backtracking: generate all permutations of a sequence. -Time complexity: O(n! * n), -where n denotes the length of the given sequence. +Time complexity: O(n! * n), where n is length of sequence. """ from __future__ import annotations +from typing import List, Union +Element = Union[int, str] -def generate_all_permutations(sequence: list[int | str]) -> None: - create_state_space_tree(sequence, [], 0, [0 for i in range(len(sequence))]) + +def generate_all_permutations(sequence: List[Element]) -> List[List[Element]]: + """ + Generate and return all permutations of the given sequence. + + :param sequence: The input sequence. + :return: A list of permutations (each permutation is a list). + + Example 1 (integers): + >>> generate_all_permutations([1, 2, 3]) + [[1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1]] + + Example 2 (strings): + >>> generate_all_permutations(["A", "B", "C"]) + [['A', 'B', 'C'], ['A', 'C', 'B'], ['B', 'A', 'C'], ['B', 'C', 'A'], ['C', 'A', 'B'], ['C', 'B', 'A']] + + Example 3 (single element): + >>> generate_all_permutations([1]) + [[1]] + + Example 4 (empty sequence): + >>> generate_all_permutations([]) + [[]] + """ + result: List[List[Element]] = [] + index_used = [False] * len(sequence) + create_state_space_tree(sequence, [], 0, index_used, result) + return result def create_state_space_tree( - sequence: list[int | str], - current_sequence: list[int | str], + sequence: List[Element], + current_sequence: List[Element], index: int, - index_used: list[int], + index_used: List[bool], + result: List[List[Element]], ) -> None: """ - Creates a state space tree to iterate through each branch using DFS. - We know that each state has exactly len(sequence) - index children. - It terminates when it reaches the end of the given sequence. - - :param sequence: The input sequence for which permutations are generated. - :param current_sequence: The current permutation being built. - :param index: The current index in the sequence. - :param index_used: list to track which elements are used in permutation. - - Example 1: - >>> sequence = [1, 2, 3] - >>> current_sequence = [] - >>> index_used = [False, False, False] - >>> create_state_space_tree(sequence, current_sequence, 0, index_used) - [1, 2, 3] - [1, 3, 2] - [2, 1, 3] - [2, 3, 1] - [3, 1, 2] - [3, 2, 1] - - Example 2: - >>> sequence = ["A", "B", "C"] - >>> current_sequence = [] - >>> index_used = [False, False, False] - >>> create_state_space_tree(sequence, current_sequence, 0, index_used) - ['A', 'B', 'C'] - ['A', 'C', 'B'] - ['B', 'A', 'C'] - ['B', 'C', 'A'] - ['C', 'A', 'B'] - ['C', 'B', 'A'] - - Example 3: - >>> sequence = [1] - >>> current_sequence = [] - >>> index_used = [False] - >>> create_state_space_tree(sequence, current_sequence, 0, index_used) - [1] - """ + Backtracking helper that appends permutations into result. + Example: + >>> res = [] + >>> create_state_space_tree([1, 2], [], 0, [False, False], res) + >>> res + [[1, 2], [2, 1]] + """ if index == len(sequence): - print(current_sequence) + # append a shallow copy + result.append(current_sequence[:]) return for i in range(len(sequence)): if not index_used[i]: current_sequence.append(sequence[i]) index_used[i] = True - create_state_space_tree(sequence, current_sequence, index + 1, index_used) + create_state_space_tree(sequence, current_sequence, index + 1, index_used, result) current_sequence.pop() index_used[i] = False -""" -remove the comment to take an input from the user - -print("Enter the elements") -sequence = list(map(int, input().split())) -""" - -sequence: list[int | str] = [3, 1, 2, 4] -generate_all_permutations(sequence) +if __name__ == "__main__": + # example usage; kept under __main__ so it doesn't run on import/tests + print(generate_all_permutations([3, 1, 2, 4])) + print(generate_all_permutations(["A", "B", "C"])) -sequence_2: list[int | str] = ["A", "B", "C"] -generate_all_permutations(sequence_2) From 8a0a7ea8ab695178962d4ffbb463f56ddd0cf388 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Thu, 2 Oct 2025 11:31:36 +0000 Subject: [PATCH 2/4] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- backtracking/all_permutations.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/backtracking/all_permutations.py b/backtracking/all_permutations.py index f9701e1411c7..1ad26764b15d 100644 --- a/backtracking/all_permutations.py +++ b/backtracking/all_permutations.py @@ -64,7 +64,9 @@ def create_state_space_tree( if not index_used[i]: current_sequence.append(sequence[i]) index_used[i] = True - create_state_space_tree(sequence, current_sequence, index + 1, index_used, result) + create_state_space_tree( + sequence, current_sequence, index + 1, index_used, result + ) current_sequence.pop() index_used[i] = False @@ -73,4 +75,3 @@ def create_state_space_tree( # example usage; kept under __main__ so it doesn't run on import/tests print(generate_all_permutations([3, 1, 2, 4])) print(generate_all_permutations(["A", "B", "C"])) - From f4e0e8f2616d3f324762506124da1873082cb519 Mon Sep 17 00:00:00 2001 From: CuTyche Date: Thu, 2 Oct 2025 17:59:24 +0530 Subject: [PATCH 3/4] Resolve merge conflict and normalize doctests in all_permutations.py --- backtracking/all_permutations.py | 42 ++++++++++++++++++++------------ 1 file changed, 27 insertions(+), 15 deletions(-) diff --git a/backtracking/all_permutations.py b/backtracking/all_permutations.py index 1ad26764b15d..6134136e9ccb 100644 --- a/backtracking/all_permutations.py +++ b/backtracking/all_permutations.py @@ -5,12 +5,11 @@ """ from __future__ import annotations -from typing import List, Union -Element = Union[int, str] +Element = int | str -def generate_all_permutations(sequence: List[Element]) -> List[List[Element]]: +def generate_all_permutations(sequence: list[Element]) -> list[list[Element]]: """ Generate and return all permutations of the given sequence. @@ -18,12 +17,22 @@ def generate_all_permutations(sequence: List[Element]) -> List[List[Element]]: :return: A list of permutations (each permutation is a list). Example 1 (integers): - >>> generate_all_permutations([1, 2, 3]) - [[1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1]] + >>> generate_all_permutations([1, 2, 3]) # doctest: +NORMALIZE_WHITESPACE + [[1, 2, 3], + [1, 3, 2], + [2, 1, 3], + [2, 3, 1], + [3, 1, 2], + [3, 2, 1]] Example 2 (strings): - >>> generate_all_permutations(["A", "B", "C"]) - [['A', 'B', 'C'], ['A', 'C', 'B'], ['B', 'A', 'C'], ['B', 'C', 'A'], ['C', 'A', 'B'], ['C', 'B', 'A']] + >>> generate_all_permutations(["A", "B", "C"]) # doctest: +NORMALIZE_WHITESPACE + [['A', 'B', 'C'], + ['A', 'C', 'B'], + ['B', 'A', 'C'], + ['B', 'C', 'A'], + ['C', 'A', 'B'], + ['C', 'B', 'A']] Example 3 (single element): >>> generate_all_permutations([1]) @@ -33,18 +42,18 @@ def generate_all_permutations(sequence: List[Element]) -> List[List[Element]]: >>> generate_all_permutations([]) [[]] """ - result: List[List[Element]] = [] + result: list[list[Element]] = [] index_used = [False] * len(sequence) create_state_space_tree(sequence, [], 0, index_used, result) return result def create_state_space_tree( - sequence: List[Element], - current_sequence: List[Element], + sequence: list[Element], + current_sequence: list[Element], index: int, - index_used: List[bool], - result: List[List[Element]], + index_used: list[bool], + result: list[list[Element]], ) -> None: """ Backtracking helper that appends permutations into result. @@ -64,9 +73,11 @@ def create_state_space_tree( if not index_used[i]: current_sequence.append(sequence[i]) index_used[i] = True - create_state_space_tree( - sequence, current_sequence, index + 1, index_used, result - ) + create_state_space_tree(sequence, + current_sequence, + index + 1, + index_used, + result) current_sequence.pop() index_used[i] = False @@ -75,3 +86,4 @@ def create_state_space_tree( # example usage; kept under __main__ so it doesn't run on import/tests print(generate_all_permutations([3, 1, 2, 4])) print(generate_all_permutations(["A", "B", "C"])) + From 2030adea7a36e7b1c6e67660d569717638d97c98 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Thu, 2 Oct 2025 12:47:52 +0000 Subject: [PATCH 4/4] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- backtracking/all_permutations.py | 9 +++------ 1 file changed, 3 insertions(+), 6 deletions(-) diff --git a/backtracking/all_permutations.py b/backtracking/all_permutations.py index 6134136e9ccb..8a9f532abb83 100644 --- a/backtracking/all_permutations.py +++ b/backtracking/all_permutations.py @@ -73,11 +73,9 @@ def create_state_space_tree( if not index_used[i]: current_sequence.append(sequence[i]) index_used[i] = True - create_state_space_tree(sequence, - current_sequence, - index + 1, - index_used, - result) + create_state_space_tree( + sequence, current_sequence, index + 1, index_used, result + ) current_sequence.pop() index_used[i] = False @@ -86,4 +84,3 @@ def create_state_space_tree( # example usage; kept under __main__ so it doesn't run on import/tests print(generate_all_permutations([3, 1, 2, 4])) print(generate_all_permutations(["A", "B", "C"])) -