From a2c790e490af2bdbdca74682c28f7139a5e0c8c2 Mon Sep 17 00:00:00 2001 From: Sonic0588 Date: Tue, 18 Aug 2020 16:26:37 +0300 Subject: [PATCH 1/8] done --- strings/min_cost_string_conversion.py | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/strings/min_cost_string_conversion.py b/strings/min_cost_string_conversion.py index 34b42f3f0f64..45500cb54551 100644 --- a/strings/min_cost_string_conversion.py +++ b/strings/min_cost_string_conversion.py @@ -1,3 +1,5 @@ +from typing import List, Tuple + """ Algorithm for calculating the most cost-efficient sequence for converting one string into another. @@ -9,7 +11,9 @@ """ -def compute_transform_tables(X, Y, cC, cR, cD, cI): +def compute_transform_tables( + X: str, Y: str, cC: int, cR: int, cD: int, cI: int +) -> Tuple[List[int], List[str]]: X = list(X) Y = list(Y) m = len(X) @@ -46,7 +50,7 @@ def compute_transform_tables(X, Y, cC, cR, cD, cI): return costs, ops -def assemble_transformation(ops, i, j): +def assemble_transformation(ops: List[str], i: int, j: int) -> List[str]: if i == 0 and j == 0: seq = [] return seq From 971c15673b2f0301f00b4464dfcd913a4dbb3b78 Mon Sep 17 00:00:00 2001 From: Sonic0588 Date: Tue, 18 Aug 2020 16:56:46 +0300 Subject: [PATCH 2/8] add types for local variables --- strings/min_cost_string_conversion.py | 32 +++++++++++++-------------- 1 file changed, 16 insertions(+), 16 deletions(-) diff --git a/strings/min_cost_string_conversion.py b/strings/min_cost_string_conversion.py index 45500cb54551..5d3e32d34616 100644 --- a/strings/min_cost_string_conversion.py +++ b/strings/min_cost_string_conversion.py @@ -14,13 +14,13 @@ def compute_transform_tables( X: str, Y: str, cC: int, cR: int, cD: int, cI: int ) -> Tuple[List[int], List[str]]: - X = list(X) - Y = list(Y) - m = len(X) - n = len(Y) + X: List[str] = list(X) + Y: List[str] = list(Y) + m: int = len(X) + n: int = len(Y) - costs = [[0 for _ in range(n + 1)] for _ in range(m + 1)] - ops = [[0 for _ in range(n + 1)] for _ in range(m + 1)] + costs: List[List[int]] = [[0 for _ in range(n + 1)] for _ in range(m + 1)] + ops: List[List[int]] = [[0 for _ in range(n + 1)] for _ in range(m + 1)] for i in range(1, m + 1): costs[i][0] = i * cD @@ -52,19 +52,19 @@ def compute_transform_tables( def assemble_transformation(ops: List[str], i: int, j: int) -> List[str]: if i == 0 and j == 0: - seq = [] + seq: List = [] return seq else: if ops[i][j][0] == "C" or ops[i][j][0] == "R": - seq = assemble_transformation(ops, i - 1, j - 1) + seq: List = assemble_transformation(ops, i - 1, j - 1) seq.append(ops[i][j]) return seq elif ops[i][j][0] == "D": - seq = assemble_transformation(ops, i - 1, j) + seq: List = assemble_transformation(ops, i - 1, j) seq.append(ops[i][j]) return seq else: - seq = assemble_transformation(ops, i, j - 1) + seq: List = assemble_transformation(ops, i, j - 1) seq.append(ops[i][j]) return seq @@ -72,13 +72,13 @@ def assemble_transformation(ops: List[str], i: int, j: int) -> List[str]: if __name__ == "__main__": _, operations = compute_transform_tables("Python", "Algorithms", -1, 1, 2, 2) - m = len(operations) - n = len(operations[0]) - sequence = assemble_transformation(operations, m - 1, n - 1) + m: int = len(operations) + n: int = len(operations[0]) + sequence: List = assemble_transformation(operations, m - 1, n - 1) - string = list("Python") - i = 0 - cost = 0 + string: List[str] = list("Python") + i: int = 0 + cost: int = 0 with open("min_cost.txt", "w") as file: for op in sequence: From 4e00372162f40886e79197e55e88ac1eb1d9d44b Mon Sep 17 00:00:00 2001 From: Sonic0588 Date: Fri, 21 Aug 2020 16:05:13 +0300 Subject: [PATCH 3/8] Revert "add types for local variables" This reverts commit 971c15673b2f0301f00b4464dfcd913a4dbb3b78. --- strings/min_cost_string_conversion.py | 32 +++++++++++++-------------- 1 file changed, 16 insertions(+), 16 deletions(-) diff --git a/strings/min_cost_string_conversion.py b/strings/min_cost_string_conversion.py index 5d3e32d34616..45500cb54551 100644 --- a/strings/min_cost_string_conversion.py +++ b/strings/min_cost_string_conversion.py @@ -14,13 +14,13 @@ def compute_transform_tables( X: str, Y: str, cC: int, cR: int, cD: int, cI: int ) -> Tuple[List[int], List[str]]: - X: List[str] = list(X) - Y: List[str] = list(Y) - m: int = len(X) - n: int = len(Y) + X = list(X) + Y = list(Y) + m = len(X) + n = len(Y) - costs: List[List[int]] = [[0 for _ in range(n + 1)] for _ in range(m + 1)] - ops: List[List[int]] = [[0 for _ in range(n + 1)] for _ in range(m + 1)] + costs = [[0 for _ in range(n + 1)] for _ in range(m + 1)] + ops = [[0 for _ in range(n + 1)] for _ in range(m + 1)] for i in range(1, m + 1): costs[i][0] = i * cD @@ -52,19 +52,19 @@ def compute_transform_tables( def assemble_transformation(ops: List[str], i: int, j: int) -> List[str]: if i == 0 and j == 0: - seq: List = [] + seq = [] return seq else: if ops[i][j][0] == "C" or ops[i][j][0] == "R": - seq: List = assemble_transformation(ops, i - 1, j - 1) + seq = assemble_transformation(ops, i - 1, j - 1) seq.append(ops[i][j]) return seq elif ops[i][j][0] == "D": - seq: List = assemble_transformation(ops, i - 1, j) + seq = assemble_transformation(ops, i - 1, j) seq.append(ops[i][j]) return seq else: - seq: List = assemble_transformation(ops, i, j - 1) + seq = assemble_transformation(ops, i, j - 1) seq.append(ops[i][j]) return seq @@ -72,13 +72,13 @@ def assemble_transformation(ops: List[str], i: int, j: int) -> List[str]: if __name__ == "__main__": _, operations = compute_transform_tables("Python", "Algorithms", -1, 1, 2, 2) - m: int = len(operations) - n: int = len(operations[0]) - sequence: List = assemble_transformation(operations, m - 1, n - 1) + m = len(operations) + n = len(operations[0]) + sequence = assemble_transformation(operations, m - 1, n - 1) - string: List[str] = list("Python") - i: int = 0 - cost: int = 0 + string = list("Python") + i = 0 + cost = 0 with open("min_cost.txt", "w") as file: for op in sequence: From 979d39b8e2f21ad6d5308ce61c82542a577ff3dd Mon Sep 17 00:00:00 2001 From: Sonic0588 Date: Fri, 21 Aug 2020 16:18:41 +0300 Subject: [PATCH 4/8] rename variables --- strings/min_cost_string_conversion.py | 73 ++++++++++++++------------- 1 file changed, 39 insertions(+), 34 deletions(-) diff --git a/strings/min_cost_string_conversion.py b/strings/min_cost_string_conversion.py index 45500cb54551..ce7de67a6795 100644 --- a/strings/min_cost_string_conversion.py +++ b/strings/min_cost_string_conversion.py @@ -4,48 +4,53 @@ Algorithm for calculating the most cost-efficient sequence for converting one string into another. The only allowed operations are ----Copy character with cost cC ----Replace character with cost cR ----Delete character with cost cD ----Insert character with cost cI +---Copy character with copy_cost +---Replace character with replace_cost +---Delete character with delete_cost +---Insert character with insert_cost """ def compute_transform_tables( - X: str, Y: str, cC: int, cR: int, cD: int, cI: int + first_string: str, + second_string: str, + copy_cost: int, + replace_cost: int, + delete_cost: int, + insert_cost: int, ) -> Tuple[List[int], List[str]]: - X = list(X) - Y = list(Y) - m = len(X) - n = len(Y) - - costs = [[0 for _ in range(n + 1)] for _ in range(m + 1)] - ops = [[0 for _ in range(n + 1)] for _ in range(m + 1)] - - for i in range(1, m + 1): - costs[i][0] = i * cD - ops[i][0] = "D%c" % X[i - 1] - - for i in range(1, n + 1): - costs[0][i] = i * cI - ops[0][i] = "I%c" % Y[i - 1] - - for i in range(1, m + 1): - for j in range(1, n + 1): - if X[i - 1] == Y[j - 1]: - costs[i][j] = costs[i - 1][j - 1] + cC - ops[i][j] = "C%c" % X[i - 1] + first_seq = list(first_string) + second_seq = list(second_string) + len_first_seq = len(first_seq) + len_second_seq = len(second_seq) + + costs = [[0 for _ in range(len_second_seq + 1)] for _ in range(len_first_seq + 1)] + ops = [[0 for _ in range(len_second_seq + 1)] for _ in range(len_first_seq + 1)] + + for i in range(1, len_first_seq + 1): + costs[i][0] = i * delete_cost + ops[i][0] = "D%c" % first_seq[i - 1] + + for i in range(1, len_second_seq + 1): + costs[0][i] = i * insert_cost + ops[0][i] = "I%c" % second_seq[i - 1] + + for i in range(1, len_first_seq + 1): + for j in range(1, len_second_seq + 1): + if first_seq[i - 1] == second_seq[j - 1]: + costs[i][j] = costs[i - 1][j - 1] + copy_cost + ops[i][j] = "C%c" % first_seq[i - 1] else: - costs[i][j] = costs[i - 1][j - 1] + cR - ops[i][j] = "R%c" % X[i - 1] + str(Y[j - 1]) + costs[i][j] = costs[i - 1][j - 1] + replace_cost + ops[i][j] = "R%c" % first_seq[i - 1] + str(second_seq[j - 1]) - if costs[i - 1][j] + cD < costs[i][j]: - costs[i][j] = costs[i - 1][j] + cD - ops[i][j] = "D%c" % X[i - 1] + if costs[i - 1][j] + delete_cost < costs[i][j]: + costs[i][j] = costs[i - 1][j] + delete_cost + ops[i][j] = "D%c" % first_seq[i - 1] - if costs[i][j - 1] + cI < costs[i][j]: - costs[i][j] = costs[i][j - 1] + cI - ops[i][j] = "I%c" % Y[j - 1] + if costs[i][j - 1] + insert_cost < costs[i][j]: + costs[i][j] = costs[i][j - 1] + insert_cost + ops[i][j] = "I%c" % second_seq[j - 1] return costs, ops From d2d97fffa701212c562eb68a8c9d4b0bd3bd0546 Mon Sep 17 00:00:00 2001 From: Eugeniy Orlov Date: Fri, 21 Aug 2020 17:27:07 +0300 Subject: [PATCH 5/8] Update strings/min_cost_string_conversion.py Co-authored-by: Christian Clauss --- strings/min_cost_string_conversion.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/strings/min_cost_string_conversion.py b/strings/min_cost_string_conversion.py index ce7de67a6795..65e1b1bf122b 100644 --- a/strings/min_cost_string_conversion.py +++ b/strings/min_cost_string_conversion.py @@ -4,10 +4,10 @@ Algorithm for calculating the most cost-efficient sequence for converting one string into another. The only allowed operations are ----Copy character with copy_cost ----Replace character with replace_cost ----Delete character with delete_cost ----Insert character with insert_cost +--- Cost to copy a character is copy_cost +--- Cost to replace a character is replace_cost +--- Cost to delete a character is delete_cost +--- Cost to insert a character is insert_cost """ From 62ae90003e9bc2fa18a71c62cfbb8ffa51c3f1ed Mon Sep 17 00:00:00 2001 From: Sonic0588 Date: Fri, 21 Aug 2020 17:29:52 +0300 Subject: [PATCH 6/8] rename strings --- strings/min_cost_string_conversion.py | 38 +++++++++++++-------------- 1 file changed, 19 insertions(+), 19 deletions(-) diff --git a/strings/min_cost_string_conversion.py b/strings/min_cost_string_conversion.py index 65e1b1bf122b..3059ebabda6a 100644 --- a/strings/min_cost_string_conversion.py +++ b/strings/min_cost_string_conversion.py @@ -12,45 +12,45 @@ def compute_transform_tables( - first_string: str, - second_string: str, + source_string: str, + destination_string: str, copy_cost: int, replace_cost: int, delete_cost: int, insert_cost: int, ) -> Tuple[List[int], List[str]]: - first_seq = list(first_string) - second_seq = list(second_string) - len_first_seq = len(first_seq) - len_second_seq = len(second_seq) + source_seq = list(source_string) + destination_seq = list(destination_string) + len_source_seq = len(source_seq) + len_destination_seq = len(destination_seq) - costs = [[0 for _ in range(len_second_seq + 1)] for _ in range(len_first_seq + 1)] - ops = [[0 for _ in range(len_second_seq + 1)] for _ in range(len_first_seq + 1)] + costs = [[0 for _ in range(len_destination_seq + 1)] for _ in range(len_source_seq + 1)] + ops = [[0 for _ in range(len_destination_seq + 1)] for _ in range(len_source_seq + 1)] - for i in range(1, len_first_seq + 1): + for i in range(1, len_source_seq + 1): costs[i][0] = i * delete_cost - ops[i][0] = "D%c" % first_seq[i - 1] + ops[i][0] = "D%c" % source_seq[i - 1] - for i in range(1, len_second_seq + 1): + for i in range(1, len_destination_seq + 1): costs[0][i] = i * insert_cost - ops[0][i] = "I%c" % second_seq[i - 1] + ops[0][i] = "I%c" % destination_seq[i - 1] - for i in range(1, len_first_seq + 1): - for j in range(1, len_second_seq + 1): - if first_seq[i - 1] == second_seq[j - 1]: + for i in range(1, len_source_seq + 1): + for j in range(1, len_destination_seq + 1): + if source_seq[i - 1] == destination_seq[j - 1]: costs[i][j] = costs[i - 1][j - 1] + copy_cost - ops[i][j] = "C%c" % first_seq[i - 1] + ops[i][j] = "C%c" % source_seq[i - 1] else: costs[i][j] = costs[i - 1][j - 1] + replace_cost - ops[i][j] = "R%c" % first_seq[i - 1] + str(second_seq[j - 1]) + ops[i][j] = "R%c" % source_seq[i - 1] + str(destination_seq[j - 1]) if costs[i - 1][j] + delete_cost < costs[i][j]: costs[i][j] = costs[i - 1][j] + delete_cost - ops[i][j] = "D%c" % first_seq[i - 1] + ops[i][j] = "D%c" % source_seq[i - 1] if costs[i][j - 1] + insert_cost < costs[i][j]: costs[i][j] = costs[i][j - 1] + insert_cost - ops[i][j] = "I%c" % second_seq[j - 1] + ops[i][j] = "I%c" % destination_seq[j - 1] return costs, ops From 4f345496bb425870712874e68ac99a345eddee95 Mon Sep 17 00:00:00 2001 From: Sonic0588 Date: Fri, 21 Aug 2020 17:36:02 +0300 Subject: [PATCH 7/8] use flake8 --- strings/min_cost_string_conversion.py | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/strings/min_cost_string_conversion.py b/strings/min_cost_string_conversion.py index 3059ebabda6a..f32d1765637d 100644 --- a/strings/min_cost_string_conversion.py +++ b/strings/min_cost_string_conversion.py @@ -24,8 +24,12 @@ def compute_transform_tables( len_source_seq = len(source_seq) len_destination_seq = len(destination_seq) - costs = [[0 for _ in range(len_destination_seq + 1)] for _ in range(len_source_seq + 1)] - ops = [[0 for _ in range(len_destination_seq + 1)] for _ in range(len_source_seq + 1)] + costs = [ + [0 for _ in range(len_destination_seq + 1)] for _ in range(len_source_seq + 1) + ] + ops = [ + [0 for _ in range(len_destination_seq + 1)] for _ in range(len_source_seq + 1) + ] for i in range(1, len_source_seq + 1): costs[i][0] = i * delete_cost From 511b270015e16f161cd465215c9f6a80a1cd2842 Mon Sep 17 00:00:00 2001 From: Christian Clauss Date: Sat, 26 Sep 2020 07:18:02 +0200 Subject: [PATCH 8/8] Update strings/min_cost_string_conversion.py --- strings/min_cost_string_conversion.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/strings/min_cost_string_conversion.py b/strings/min_cost_string_conversion.py index f32d1765637d..e990aaa2679b 100644 --- a/strings/min_cost_string_conversion.py +++ b/strings/min_cost_string_conversion.py @@ -61,8 +61,7 @@ def compute_transform_tables( def assemble_transformation(ops: List[str], i: int, j: int) -> List[str]: if i == 0 and j == 0: - seq = [] - return seq + return [] else: if ops[i][j][0] == "C" or ops[i][j][0] == "R": seq = assemble_transformation(ops, i - 1, j - 1)