From 3dc9b194905e465499795639c773ca2264e92e65 Mon Sep 17 00:00:00 2001 From: Nataliia Volkova Date: Sun, 15 Feb 2026 20:25:14 +0000 Subject: [PATCH 1/4] common_prefix --- .../common_prefix/common_prefix.py | 16 ++++++++++------ 1 file changed, 10 insertions(+), 6 deletions(-) diff --git a/Sprint-2/improve_with_precomputing/common_prefix/common_prefix.py b/Sprint-2/improve_with_precomputing/common_prefix/common_prefix.py index f4839e7..126b293 100644 --- a/Sprint-2/improve_with_precomputing/common_prefix/common_prefix.py +++ b/Sprint-2/improve_with_precomputing/common_prefix/common_prefix.py @@ -1,18 +1,22 @@ from typing import List -def find_longest_common_prefix(strings: List[str]): +def find_longest_common_prefix(strings: List[str]) -> str: """ find_longest_common_prefix returns the longest string common at the start of any two strings in the passed list. In the event that an empty list, a list containing one string, or a list of strings with no common prefixes is passed, the empty string will be returned. """ + if len(strings) < 2: + return "" + + strings.sort() + longest = "" - for string_index, string in enumerate(strings): - for other_string in strings[string_index+1:]: - common = find_common_prefix(string, other_string) - if len(common) > len(longest): - longest = common + for i in range(len(strings)-1): + common = find_common_prefix(strings[i], strings[i+1]) + if len(common) > len(longest): + longest = common return longest From 9d9c1befb55ef131a2732c7c8dfb035f9c6d7588 Mon Sep 17 00:00:00 2001 From: Nataliia Volkova Date: Sun, 15 Feb 2026 21:43:54 +0000 Subject: [PATCH 2/4] count_upper_letters --- .../count_letters/count_letters.py | 23 +++++++++++++------ 1 file changed, 16 insertions(+), 7 deletions(-) diff --git a/Sprint-2/improve_with_precomputing/count_letters/count_letters.py b/Sprint-2/improve_with_precomputing/count_letters/count_letters.py index 62c3ec0..5b8fd7c 100644 --- a/Sprint-2/improve_with_precomputing/count_letters/count_letters.py +++ b/Sprint-2/improve_with_precomputing/count_letters/count_letters.py @@ -1,13 +1,22 @@ -def count_letters(s: str) -> int: +def count_letters(string: str) -> int: """ count_letters returns the number of letters which only occur in upper case in the passed string. """ - only_upper = set() - for letter in s: - if is_upper_case(letter): - if letter.lower() not in s: - only_upper.add(letter) - return len(only_upper) + + lower_case_set = set() + upper_case_set = set() + + for letter in string: + if letter.islower(): + lower_case_set.add(letter) + elif letter.isupper(): + upper_case_set.add(letter) + + count = 0 + for letter in upper_case_set: + if letter.lower() not in lower_case_set: + count += 1 + return count def is_upper_case(letter: str) -> bool: From 65cf7b21c8aedc235a4d9f06ac67501252b81053 Mon Sep 17 00:00:00 2001 From: Nataliia Volkova Date: Tue, 21 Apr 2026 14:42:49 +0100 Subject: [PATCH 3/4] explaine complexity --- .../improve_with_precomputing/count_letters/count_letters.py | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/Sprint-2/improve_with_precomputing/count_letters/count_letters.py b/Sprint-2/improve_with_precomputing/count_letters/count_letters.py index 5b8fd7c..9d1b46d 100644 --- a/Sprint-2/improve_with_precomputing/count_letters/count_letters.py +++ b/Sprint-2/improve_with_precomputing/count_letters/count_letters.py @@ -18,6 +18,9 @@ def count_letters(string: str) -> int: count += 1 return count +# The Space complexity for new and old script is O(n), but Time complexity the old one is O(n)^2 which is insufficient compare +# to new code Time complexity O(n). -def is_upper_case(letter: str) -> bool: + +def is_upper_case(letter: str) -> bool: return letter == letter.upper() From 387bfb8871823c31a9655d4f624a4a90f446884f Mon Sep 17 00:00:00 2001 From: Nataliia Volkova Date: Tue, 21 Apr 2026 14:43:49 +0100 Subject: [PATCH 4/4] explaine complexity --- .../improve_with_precomputing/common_prefix/common_prefix.py | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/Sprint-2/improve_with_precomputing/common_prefix/common_prefix.py b/Sprint-2/improve_with_precomputing/common_prefix/common_prefix.py index 126b293..9313743 100644 --- a/Sprint-2/improve_with_precomputing/common_prefix/common_prefix.py +++ b/Sprint-2/improve_with_precomputing/common_prefix/common_prefix.py @@ -26,3 +26,8 @@ def find_common_prefix(left: str, right: str) -> str: if left[i] != right[i]: return left[:i] return left[:min_length] + +# Complexity for old version code where we hade a nested loop and slicer, and compared every string with other string is +# leading to O(n^2*m+n^2), while on the new script we have complexity sorting O(n log n *m) and comparison O(n*m). Even after using sorting +# which is consuming and costly, the overall complexity is lower because we compare fewer pairs. +# O(n^2*m) and O(n log n *m) \ No newline at end of file