Sheffield | 25-SDC-Nov | Sheida Shabankari | Sprint 2 |Improve code with precomputing

[sheida-shab]

• I have titled my PR with Region | Cohort | FirstName LastName | Sprint | Assignment Title
• My changes meet the requirements of the task
• I have tested my changes
• My changes follow the style guide

PR summary :

• Improved find_longest_common_prefix using two techniques:

1. Precomputing prefix hashes for each string to avoid repeated character-by-character comparisons.
2. Sorting the strings so that only adjacent strings need to be compared, which greatly reduces the number of comparisons for large lists.
   These changes make the function much faster while keeping all existing tests passing, including the large list test.

• Improved count_letters by precomputing lowercase letters for faster lookup. Only uppercase letters without a lowercase version are counted. All tests, including long strings, pass.

[cjyuan]

Can you use complexity to explain why your implementation is an improvement?

[cjyuan]

How do these "prefix hashes" speed up comparison?

[sheida-shab]

At first, I thought the exercise needed me to precompute and keep some data for each string. So I used prefix hashes, thinking this would avoid comparing letters one by one and make the function much faster.
But after testing, I saw that using hashes did not make it much faster. Sorting the strings and comparing only neighbors worked better, was simpler, and gave the speed improvement needed.

[cjyuan]

Note: With the way you used prefix hashes, the complexity actually became higher (when the length of each string is large).

[sheida-shab]

That makes sense. In my case, prefix hashing introduced additional preprocessing and memory costs without improving the asymptotic complexity. Once I removed it and only compared adjacent strings after sorting, the solution became simpler and faster, especially for longer inputs.

[sheida-shab]

Hi CJ,Thanks for your feedback.
I improved count_letters by reducing time complexity from O(n²) to O(n).

Previously, for each character in the string (O(n)), the code performed a membership check on the entire string (O(n)), resulting in O(n²) complexity.

By precomputing a set of all lowercase characters once (O(n)) and using O(1) set lookups inside the loop, the overall complexity is reduced to O(n) .

[cjyuan]

Can you also do a complexity analysis for find_longest_common_prefix?

[sheida-shab]

The time complexity of find_longest_common_prefix now is O(n log n + n · m), where n is the number of strings and m is the average length of a string.
Sorting the strings takes O(n log n), and then comparing only adjacent strings takes O(n · m) in the worst case.

[cjyuan]

How does the program determine the order between two strings? Is the performance affected by string length when we compare two strings? If we take into account m, then the sorting complexity is no longer just O(nlogn).