perf(strings): optimize anagram signature using frequency counts

[sowndappan5]

Replaced sorting-based signature implementation with a frequency-based approach using collections.Counter.

This does not change the correctness of results, but improves performance and scalability:

• Original: O(n log n) time, O(n) space
• Modified: O(n + k) time, O(k) space (k ≤ alphabet size)

Example:
word = "a"*100000 + "b"*100000
Original requires sorting 200k characters.
Modified only counts frequencies, making it much faster.

Describe your change:

• Add an algorithm?
• Fix a bug or typo in an existing algorithm?
• Add or change doctests? -- Note: Please avoid changing both code and tests in a single pull request.
• Documentation change?

Checklist:

• I have read CONTRIBUTING.md.
• This pull request is all my own work -- I have not plagiarized.
• I know that pull requests will not be merged if they fail the automated tests.
• This PR only changes one algorithm file. To ease review, please open separate PRs for separate algorithms.
• All new Python files are placed inside an existing directory.
• All filenames are in all lowercase characters with no spaces or dashes.
• All functions and variable names follow Python naming conventions.
• All function parameters and return values are annotated with Python type hints.
• All functions have doctests that pass the automated testing.
• All new algorithms include at least one URL that points to Wikipedia or another similar explanation.
• If this pull request resolves one or more open issues then the description above includes the issue number(s) with a closing keyword: "Fixes #ISSUE-NUMBER".

[sowndappan5]

Hi, I’ve updated the anagram implementation to use a frequency-based signature. All checks have passed. Please let me know if you’d like me to make further improvements.

[MaximSmolskiy]

making results more accurate and avoiding false positives.

@sowndappan5 I don't catch idea why it fixes something and makes results more accurate and avoiding false positives.
Please provide some examples with change in program behavior - current results should be different from previous results and in some sense better

[sowndappan5]

My change improves time and space complexity while keeping results correct.

• Original (sorted-based signature):
  Requires sorting → O(n log n) time, O(n) space.

• Modified (frequency-based signature):
  Counts characters directly → O(n + k) time, O(k) space (k ≤ alphabet size, e.g. 26).

Example (long input):

word = "a" * 100000 + "b" * 100000

• Original: must sort 200k characters (O(n log n)).
• Modified: only counts frequencies (O(n)), far faster and lighter in memory.

So while outputs are the same, the new code is more efficient and scalable.

[MaximSmolskiy]

My change improves time and space complexity while keeping results correct.

• Original (sorted-based signature):
  Requires sorting → O(n log n) time, O(n) space.
• Modified (frequency-based signature):
  Counts characters directly → O(n + k) time, O(k) space (k ≤ alphabet size, e.g. 26).

Example (long input):

word = "a" * 100000 + "b" * 100000

• Original: must sort 200k characters (O(n log n)).
• Modified: only counts frequencies (O(n)), far faster and lighter in memory.

So while outputs are the same, the new code is more efficient and scalable.

@sowndappan5 This answer is very good and detailed. But description is quite confusing - there is nothing said about time and memory optimization, but it says that the results will now be different - making results more accurate and avoiding false positives. Please try to call things by their proper names right away

[sowndappan5]

@MaximSmolskiy Thank you for the feedback. I’ve updated the PR description to include time/space complexity and an example illustrating the improvement.