Solving the Top k most frequent words problem using a max-heap

[amos-syd]

Describe your change:

This PR aims to add an algorithm to identify the top k most frequent strings given a provided string list of elements.
To do this, the algorithm is using a max-heap implementation already existing in this repository (a generic type was introduced to allow the usage).

Time complexity is O(n), where n is the number of words:

• O(n) for building the max-heap
• k*O(logn) for extracting the k most frequent strings

• Add an algorithm?
• Fix a bug or typo in an existing algorithm?
• 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 commit message contains Fixes: #{$ISSUE_NO}.

[algorithms-keeper]

Click here to look at the relevant links ⬇️

🔗 Relevant Links

Repository:

• Contributing guidelines
• Project Euler solution guidelines

Python:

• Formatted string literals (f-strings)
• Type hints
• doctest
• unittest
• pytest

Automated review generated by algorithms-keeper. If there's any problem regarding this review, please open an issue about it.

---

algorithms-keeper commands and options

algorithms-keeper actions can be triggered by commenting on this PR:

• @algorithms-keeper review to trigger the checks for only added pull request files
• @algorithms-keeper review-all to trigger the checks for all the pull request files, including the modified files. As we cannot post review comments on lines not part of the diff, this command will post all the messages in one comment.

NOTE: Commands are in beta and so this feature is restricted only to a member or owner of the organization.

[CaedenPH]

Very well written algorithm, great stuff!

[amos-syd]

Hello @cclauss, I'm tagging you as I saw your involvement in several PRs.
Do you know who can I ask to for a review? Is there anything I should still change in the PR?
Thank you!

[cclauss]

All of this seems like it could be done in just a few lines using only a collections.Counter so what are the advantages of this approach?

[amos-syd]

All of this seems like it could be done in just a few lines using only a collections.Counter so what are the advantages of this approach?

Thanks for the feedback.
I had a look to collections.Counter and noticed that, indeed, most_common solves exactly this problem: https://github.com/python/cpython/blob/3.11/Lib/collections/__init__.py#L608

This is using heapq.nlargest behind the scenes: https://github.com/python/cpython/blob/3.11/Lib/heapq.py#L523

There is already a Heap class in this repository, I imagined it would be useful to show a typical usage of heaps (i.e. finding out order statistics). Do you think I should close this PR entirely, or do you have other suggestions?

Thank you

[cclauss]

fromcollectionsimportCounterdeftop_k_frequent_words(words, k_value):
return [x[0] forxinCounter(words).most_common(k_value)]

[cclauss]

Please put the text of our last two messages into the file’s docstring and then we can merge this. That will show why this work was done and that there also that the Python standard library provides a far more straightforward way to solve the same problem.

[amos-syd]

Please put the text of our last two messages into the file’s docstring and then we can merge this. That will show why this work was done and that there also that the Python standard library provides a far more straightforward way to solve the same problem.

Thanks for the feedback.
I have updated the docstring mentioning the (preferable) Python standard library solution.

[cclauss]

Nice!

[amos-syd]

Describe your change:

This PR aims to add an algorithm to identify the top k most frequent strings given a provided string list of elements.
To do this, the algorithm is using a max-heap implementation already existing in this repository (a generic type was introduced to allow the usage).

Time complexity is O(n), where n is the number of words:

• O(n) for building the max-heap
• k*O(logn) for extracting the k most frequent strings

• Add an algorithm?
• Fix a bug or typo in an existing algorithm?
• 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 commit message contains Fixes: #{$ISSUE_NO}.

[algorithms-keeper]

Click here to look at the relevant links ⬇️

🔗 Relevant Links

Repository:

• Contributing guidelines
• Project Euler solution guidelines

Python:

• Formatted string literals (f-strings)
• Type hints
• doctest
• unittest
• pytest

Automated review generated by algorithms-keeper. If there's any problem regarding this review, please open an issue about it.

---

algorithms-keeper commands and options

algorithms-keeper actions can be triggered by commenting on this PR:

• @algorithms-keeper review to trigger the checks for only added pull request files
• @algorithms-keeper review-all to trigger the checks for all the pull request files, including the modified files. As we cannot post review comments on lines not part of the diff, this command will post all the messages in one comment.

NOTE: Commands are in beta and so this feature is restricted only to a member or owner of the organization.

[CaedenPH]

Very well written algorithm, great stuff!

[amos-syd]

Hello @cclauss, I'm tagging you as I saw your involvement in several PRs.
Do you know who can I ask to for a review? Is there anything I should still change in the PR?
Thank you!

[cclauss]

All of this seems like it could be done in just a few lines using only a collections.Counter so what are the advantages of this approach?

[amos-syd]

All of this seems like it could be done in just a few lines using only a collections.Counter so what are the advantages of this approach?

Thanks for the feedback.
I had a look to collections.Counter and noticed that, indeed, most_common solves exactly this problem: https://github.com/python/cpython/blob/3.11/Lib/collections/__init__.py#L608

This is using heapq.nlargest behind the scenes: https://github.com/python/cpython/blob/3.11/Lib/heapq.py#L523

There is already a Heap class in this repository, I imagined it would be useful to show a typical usage of heaps (i.e. finding out order statistics). Do you think I should close this PR entirely, or do you have other suggestions?

Thank you

[cclauss]

fromcollectionsimportCounterdeftop_k_frequent_words(words, k_value):
return [x[0] forxinCounter(words).most_common(k_value)]

[cclauss]

Please put the text of our last two messages into the file’s docstring and then we can merge this. That will show why this work was done and that there also that the Python standard library provides a far more straightforward way to solve the same problem.

[amos-syd]

Please put the text of our last two messages into the file’s docstring and then we can merge this. That will show why this work was done and that there also that the Python standard library provides a far more straightforward way to solve the same problem.

Thanks for the feedback.
I have updated the docstring mentioning the (preferable) Python standard library solution.

[cclauss]

Nice!

[amos-syd]

Describe your change:

This PR aims to add an algorithm to identify the top k most frequent strings given a provided string list of elements.
To do this, the algorithm is using a max-heap implementation already existing in this repository (a generic type was introduced to allow the usage).

Time complexity is O(n), where n is the number of words:

• O(n) for building the max-heap
• k*O(logn) for extracting the k most frequent strings

• Add an algorithm?
• Fix a bug or typo in an existing algorithm?
• 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 commit message contains Fixes: #{$ISSUE_NO}.

[algorithms-keeper]

Click here to look at the relevant links ⬇️

🔗 Relevant Links

Repository:

• Contributing guidelines
• Project Euler solution guidelines

Python:

• Formatted string literals (f-strings)
• Type hints
• doctest
• unittest
• pytest

Automated review generated by algorithms-keeper. If there's any problem regarding this review, please open an issue about it.

---

algorithms-keeper commands and options

algorithms-keeper actions can be triggered by commenting on this PR:

• @algorithms-keeper review to trigger the checks for only added pull request files
• @algorithms-keeper review-all to trigger the checks for all the pull request files, including the modified files. As we cannot post review comments on lines not part of the diff, this command will post all the messages in one comment.

NOTE: Commands are in beta and so this feature is restricted only to a member or owner of the organization.

[CaedenPH]

Very well written algorithm, great stuff!

[amos-syd]

Hello @cclauss, I'm tagging you as I saw your involvement in several PRs.
Do you know who can I ask to for a review? Is there anything I should still change in the PR?
Thank you!

[cclauss]

All of this seems like it could be done in just a few lines using only a collections.Counter so what are the advantages of this approach?

[amos-syd]

All of this seems like it could be done in just a few lines using only a collections.Counter so what are the advantages of this approach?

Thanks for the feedback.
I had a look to collections.Counter and noticed that, indeed, most_common solves exactly this problem: https://github.com/python/cpython/blob/3.11/Lib/collections/__init__.py#L608

This is using heapq.nlargest behind the scenes: https://github.com/python/cpython/blob/3.11/Lib/heapq.py#L523

There is already a Heap class in this repository, I imagined it would be useful to show a typical usage of heaps (i.e. finding out order statistics). Do you think I should close this PR entirely, or do you have other suggestions?

Thank you

[cclauss]

fromcollectionsimportCounterdeftop_k_frequent_words(words, k_value):
return [x[0] forxinCounter(words).most_common(k_value)]

[cclauss]

Please put the text of our last two messages into the file’s docstring and then we can merge this. That will show why this work was done and that there also that the Python standard library provides a far more straightforward way to solve the same problem.

[amos-syd]

Please put the text of our last two messages into the file’s docstring and then we can merge this. That will show why this work was done and that there also that the Python standard library provides a far more straightforward way to solve the same problem.

Thanks for the feedback.
I have updated the docstring mentioning the (preferable) Python standard library solution.

[cclauss]

Nice!

[amos-syd]

Describe your change:

This PR aims to add an algorithm to identify the top k most frequent strings given a provided string list of elements.
To do this, the algorithm is using a max-heap implementation already existing in this repository (a generic type was introduced to allow the usage).

Time complexity is O(n), where n is the number of words:

• O(n) for building the max-heap
• k*O(logn) for extracting the k most frequent strings

• Add an algorithm?
• Fix a bug or typo in an existing algorithm?
• 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 commit message contains Fixes: #{$ISSUE_NO}.

[algorithms-keeper]

Click here to look at the relevant links ⬇️

🔗 Relevant Links

Repository:

• Contributing guidelines
• Project Euler solution guidelines

Python:

• Formatted string literals (f-strings)
• Type hints
• doctest
• unittest
• pytest

Automated review generated by algorithms-keeper. If there's any problem regarding this review, please open an issue about it.

---

algorithms-keeper commands and options

algorithms-keeper actions can be triggered by commenting on this PR:

• @algorithms-keeper review to trigger the checks for only added pull request files
• @algorithms-keeper review-all to trigger the checks for all the pull request files, including the modified files. As we cannot post review comments on lines not part of the diff, this command will post all the messages in one comment.

NOTE: Commands are in beta and so this feature is restricted only to a member or owner of the organization.

[CaedenPH]

Very well written algorithm, great stuff!

[amos-syd]

Hello @cclauss, I'm tagging you as I saw your involvement in several PRs.
Do you know who can I ask to for a review? Is there anything I should still change in the PR?
Thank you!

[cclauss]

All of this seems like it could be done in just a few lines using only a collections.Counter so what are the advantages of this approach?

[amos-syd]

All of this seems like it could be done in just a few lines using only a collections.Counter so what are the advantages of this approach?

Thanks for the feedback.
I had a look to collections.Counter and noticed that, indeed, most_common solves exactly this problem: https://github.com/python/cpython/blob/3.11/Lib/collections/__init__.py#L608

This is using heapq.nlargest behind the scenes: https://github.com/python/cpython/blob/3.11/Lib/heapq.py#L523

There is already a Heap class in this repository, I imagined it would be useful to show a typical usage of heaps (i.e. finding out order statistics). Do you think I should close this PR entirely, or do you have other suggestions?

Thank you

[cclauss]

fromcollectionsimportCounterdeftop_k_frequent_words(words, k_value):
return [x[0] forxinCounter(words).most_common(k_value)]

[cclauss]

Please put the text of our last two messages into the file’s docstring and then we can merge this. That will show why this work was done and that there also that the Python standard library provides a far more straightforward way to solve the same problem.

[amos-syd]

Please put the text of our last two messages into the file’s docstring and then we can merge this. That will show why this work was done and that there also that the Python standard library provides a far more straightforward way to solve the same problem.

Thanks for the feedback.
I have updated the docstring mentioning the (preferable) Python standard library solution.

[cclauss]

Nice!

[amos-syd]

Describe your change:

This PR aims to add an algorithm to identify the top k most frequent strings given a provided string list of elements.
To do this, the algorithm is using a max-heap implementation already existing in this repository (a generic type was introduced to allow the usage).

Time complexity is O(n), where n is the number of words:

• O(n) for building the max-heap
• k*O(logn) for extracting the k most frequent strings

• Add an algorithm?
• Fix a bug or typo in an existing algorithm?
• 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 commit message contains Fixes: #{$ISSUE_NO}.

[algorithms-keeper]

Click here to look at the relevant links ⬇️

🔗 Relevant Links

Repository:

• Contributing guidelines
• Project Euler solution guidelines

Python:

• Formatted string literals (f-strings)
• Type hints
• doctest
• unittest
• pytest

Automated review generated by algorithms-keeper. If there's any problem regarding this review, please open an issue about it.

---

algorithms-keeper commands and options

algorithms-keeper actions can be triggered by commenting on this PR:

• @algorithms-keeper review to trigger the checks for only added pull request files
• @algorithms-keeper review-all to trigger the checks for all the pull request files, including the modified files. As we cannot post review comments on lines not part of the diff, this command will post all the messages in one comment.

NOTE: Commands are in beta and so this feature is restricted only to a member or owner of the organization.

[CaedenPH]

Very well written algorithm, great stuff!

[amos-syd]

Hello @cclauss, I'm tagging you as I saw your involvement in several PRs.
Do you know who can I ask to for a review? Is there anything I should still change in the PR?
Thank you!

[cclauss]

All of this seems like it could be done in just a few lines using only a collections.Counter so what are the advantages of this approach?

[amos-syd]

All of this seems like it could be done in just a few lines using only a collections.Counter so what are the advantages of this approach?

Thanks for the feedback.
I had a look to collections.Counter and noticed that, indeed, most_common solves exactly this problem: https://github.com/python/cpython/blob/3.11/Lib/collections/__init__.py#L608

This is using heapq.nlargest behind the scenes: https://github.com/python/cpython/blob/3.11/Lib/heapq.py#L523

There is already a Heap class in this repository, I imagined it would be useful to show a typical usage of heaps (i.e. finding out order statistics). Do you think I should close this PR entirely, or do you have other suggestions?

Thank you

[cclauss]

fromcollectionsimportCounterdeftop_k_frequent_words(words, k_value):
return [x[0] forxinCounter(words).most_common(k_value)]

[cclauss]

Please put the text of our last two messages into the file’s docstring and then we can merge this. That will show why this work was done and that there also that the Python standard library provides a far more straightforward way to solve the same problem.

[amos-syd]

Please put the text of our last two messages into the file’s docstring and then we can merge this. That will show why this work was done and that there also that the Python standard library provides a far more straightforward way to solve the same problem.

Thanks for the feedback.
I have updated the docstring mentioning the (preferable) Python standard library solution.

[cclauss]

Nice!

[amos-syd]

Describe your change:

This PR aims to add an algorithm to identify the top k most frequent strings given a provided string list of elements.
To do this, the algorithm is using a max-heap implementation already existing in this repository (a generic type was introduced to allow the usage).

Time complexity is O(n), where n is the number of words:

• O(n) for building the max-heap
• k*O(logn) for extracting the k most frequent strings

• Add an algorithm?
• Fix a bug or typo in an existing algorithm?
• 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 commit message contains Fixes: #{$ISSUE_NO}.

[algorithms-keeper]

Click here to look at the relevant links ⬇️

🔗 Relevant Links

Repository:

• Contributing guidelines
• Project Euler solution guidelines

Python:

• Formatted string literals (f-strings)
• Type hints
• doctest
• unittest
• pytest

Automated review generated by algorithms-keeper. If there's any problem regarding this review, please open an issue about it.

---

algorithms-keeper commands and options

algorithms-keeper actions can be triggered by commenting on this PR:

• @algorithms-keeper review to trigger the checks for only added pull request files
• @algorithms-keeper review-all to trigger the checks for all the pull request files, including the modified files. As we cannot post review comments on lines not part of the diff, this command will post all the messages in one comment.

NOTE: Commands are in beta and so this feature is restricted only to a member or owner of the organization.

[CaedenPH]

Very well written algorithm, great stuff!

[amos-syd]

Hello @cclauss, I'm tagging you as I saw your involvement in several PRs.
Do you know who can I ask to for a review? Is there anything I should still change in the PR?
Thank you!

[cclauss]

All of this seems like it could be done in just a few lines using only a collections.Counter so what are the advantages of this approach?

[amos-syd]

All of this seems like it could be done in just a few lines using only a collections.Counter so what are the advantages of this approach?

Thanks for the feedback.
I had a look to collections.Counter and noticed that, indeed, most_common solves exactly this problem: https://github.com/python/cpython/blob/3.11/Lib/collections/__init__.py#L608

This is using heapq.nlargest behind the scenes: https://github.com/python/cpython/blob/3.11/Lib/heapq.py#L523

There is already a Heap class in this repository, I imagined it would be useful to show a typical usage of heaps (i.e. finding out order statistics). Do you think I should close this PR entirely, or do you have other suggestions?

Thank you

[cclauss]

fromcollectionsimportCounterdeftop_k_frequent_words(words, k_value):
return [x[0] forxinCounter(words).most_common(k_value)]

[cclauss]

Please put the text of our last two messages into the file’s docstring and then we can merge this. That will show why this work was done and that there also that the Python standard library provides a far more straightforward way to solve the same problem.

[amos-syd]

Please put the text of our last two messages into the file’s docstring and then we can merge this. That will show why this work was done and that there also that the Python standard library provides a far more straightforward way to solve the same problem.

Thanks for the feedback.
I have updated the docstring mentioning the (preferable) Python standard library solution.

[cclauss]

Nice!

[amos-syd]

Describe your change:

This PR aims to add an algorithm to identify the top k most frequent strings given a provided string list of elements.
To do this, the algorithm is using a max-heap implementation already existing in this repository (a generic type was introduced to allow the usage).

Time complexity is O(n), where n is the number of words:

• O(n) for building the max-heap
• k*O(logn) for extracting the k most frequent strings

• Add an algorithm?
• Fix a bug or typo in an existing algorithm?
• 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 commit message contains Fixes: #{$ISSUE_NO}.

[algorithms-keeper]

Click here to look at the relevant links ⬇️

🔗 Relevant Links

Repository:

• Contributing guidelines
• Project Euler solution guidelines

Python:

• Formatted string literals (f-strings)
• Type hints
• doctest
• unittest
• pytest

Automated review generated by algorithms-keeper. If there's any problem regarding this review, please open an issue about it.

---

algorithms-keeper commands and options

algorithms-keeper actions can be triggered by commenting on this PR:

• @algorithms-keeper review to trigger the checks for only added pull request files
• @algorithms-keeper review-all to trigger the checks for all the pull request files, including the modified files. As we cannot post review comments on lines not part of the diff, this command will post all the messages in one comment.

NOTE: Commands are in beta and so this feature is restricted only to a member or owner of the organization.

[CaedenPH]

Very well written algorithm, great stuff!

[amos-syd]

Hello @cclauss, I'm tagging you as I saw your involvement in several PRs.
Do you know who can I ask to for a review? Is there anything I should still change in the PR?
Thank you!

[cclauss]

All of this seems like it could be done in just a few lines using only a collections.Counter so what are the advantages of this approach?

[amos-syd]

All of this seems like it could be done in just a few lines using only a collections.Counter so what are the advantages of this approach?

Thanks for the feedback.
I had a look to collections.Counter and noticed that, indeed, most_common solves exactly this problem: https://github.com/python/cpython/blob/3.11/Lib/collections/__init__.py#L608

This is using heapq.nlargest behind the scenes: https://github.com/python/cpython/blob/3.11/Lib/heapq.py#L523

There is already a Heap class in this repository, I imagined it would be useful to show a typical usage of heaps (i.e. finding out order statistics). Do you think I should close this PR entirely, or do you have other suggestions?

Thank you

[cclauss]

fromcollectionsimportCounterdeftop_k_frequent_words(words, k_value):
return [x[0] forxinCounter(words).most_common(k_value)]

[cclauss]

Please put the text of our last two messages into the file’s docstring and then we can merge this. That will show why this work was done and that there also that the Python standard library provides a far more straightforward way to solve the same problem.

[amos-syd]

Please put the text of our last two messages into the file’s docstring and then we can merge this. That will show why this work was done and that there also that the Python standard library provides a far more straightforward way to solve the same problem.

Thanks for the feedback.
I have updated the docstring mentioning the (preferable) Python standard library solution.

[cclauss]

Nice!

[amos-syd]

Describe your change:

This PR aims to add an algorithm to identify the top k most frequent strings given a provided string list of elements.
To do this, the algorithm is using a max-heap implementation already existing in this repository (a generic type was introduced to allow the usage).

Time complexity is O(n), where n is the number of words:

• O(n) for building the max-heap
• k*O(logn) for extracting the k most frequent strings

• Add an algorithm?
• Fix a bug or typo in an existing algorithm?
• 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 commit message contains Fixes: #{$ISSUE_NO}.

[algorithms-keeper]

Click here to look at the relevant links ⬇️

🔗 Relevant Links

Repository:

• Contributing guidelines
• Project Euler solution guidelines

Python:

• Formatted string literals (f-strings)
• Type hints
• doctest
• unittest
• pytest

Automated review generated by algorithms-keeper. If there's any problem regarding this review, please open an issue about it.

---

algorithms-keeper commands and options

algorithms-keeper actions can be triggered by commenting on this PR:

• @algorithms-keeper review to trigger the checks for only added pull request files
• @algorithms-keeper review-all to trigger the checks for all the pull request files, including the modified files. As we cannot post review comments on lines not part of the diff, this command will post all the messages in one comment.

NOTE: Commands are in beta and so this feature is restricted only to a member or owner of the organization.

[CaedenPH]

Very well written algorithm, great stuff!

[amos-syd]

Hello @cclauss, I'm tagging you as I saw your involvement in several PRs.
Do you know who can I ask to for a review? Is there anything I should still change in the PR?
Thank you!

[cclauss]

All of this seems like it could be done in just a few lines using only a collections.Counter so what are the advantages of this approach?

[amos-syd]

All of this seems like it could be done in just a few lines using only a collections.Counter so what are the advantages of this approach?

Thanks for the feedback.
I had a look to collections.Counter and noticed that, indeed, most_common solves exactly this problem: https://github.com/python/cpython/blob/3.11/Lib/collections/__init__.py#L608

This is using heapq.nlargest behind the scenes: https://github.com/python/cpython/blob/3.11/Lib/heapq.py#L523

There is already a Heap class in this repository, I imagined it would be useful to show a typical usage of heaps (i.e. finding out order statistics). Do you think I should close this PR entirely, or do you have other suggestions?

Thank you

[cclauss]

fromcollectionsimportCounterdeftop_k_frequent_words(words, k_value):
return [x[0] forxinCounter(words).most_common(k_value)]

[cclauss]

Please put the text of our last two messages into the file’s docstring and then we can merge this. That will show why this work was done and that there also that the Python standard library provides a far more straightforward way to solve the same problem.

[amos-syd]

Please put the text of our last two messages into the file’s docstring and then we can merge this. That will show why this work was done and that there also that the Python standard library provides a far more straightforward way to solve the same problem.

Thanks for the feedback.
I have updated the docstring mentioning the (preferable) Python standard library solution.

[cclauss]

Nice!