Add approaches for Parallel Letter Frequency #2863

masiljangajji · 2024-11-12T14:02:27Z

pull request

Approaches for Parallel Letter Frequency, ready for review!

Resolves #2710

Reviewer Resources:

Track Policies

kahgoh

Nice, I think this generally looks good! There's just a couple of things to fix in the Markdown.

kahgoh · 2024-11-12T23:13:57Z

.github/PULL_REQUEST_TEMPLATE.md

 <!-- Your content goes here: -->

-
-


I don't think this related to the PR. Could you please undo this change?

I don't think this related to the PR. Could you please undo this change?

the following error will occur.

.github/PULL_REQUEST_TEMPLATE.md:5 MD012/no-multiple-blanks Multiple consecutive blank lines [Expected: 1; Actual: 2] .github/PULL_REQUEST_TEMPLATE.md:6 MD012/no-multiple-blanks Multiple consecutive blank lines [Expected: 1; Actual: 3]

Should we go ahead and cancel it anyway?

Yeah, I think we should. I've just tried running our Markdown Lint action on our main branch (before your change). I think the rules are a bit different with that one.

kahgoh · 2024-11-13T14:04:22Z

exercises/practice/parallel-letter-frequency/.approaches/introduction.md

+# Introduction
+
+There are multiple ways to solve the Parallel Letter Frequency problem.
+One approach is to use parallelStream, and another involves using ForkJoinPool.


Looking at the existing approaches for other exercises, such as grains, I think it would be good to format the methods and classes with backticks (``) to maintain consistency in the formatting (example in the suggestion below). Could you go through and update?

Suggested change

One approach is to use parallelStream, and another involves using ForkJoinPool.

One approach is to use `Stream.parallelStream`, and another involves using `ForkJoinPool`.

kahgoh · 2024-11-13T14:11:40Z

exercises/practice/parallel-letter-frequency/.approaches/introduction.md

+
+## General guidance
+
+To count occurrences of items, a map data structure is often used, though arrays and lists can work as well. A map, being a key-value pair structure, is suitable for recording frequency by incrementing the value for each key.


We generally format our Markdown one sentence per line. Could you please go through and update the format?

Suggested change

To count occurrences of items, a map data structure is often used, though arrays and lists can work as well. A map, being a key-value pair structure, is suitable for recording frequency by incrementing the value for each key.

To count occurrences of items, a map data structure is often used, though arrays and lists can work as well.

A map, being a key-value pair structure, is suitable for recording frequency by incrementing the value for each key.

kahgoh · 2024-11-13T14:55:30Z

exercises/practice/parallel-letter-frequency/.approaches/fork-join/content.md

+
+Each subtask in LetterCountTask will continue calling compute() to divide itself further until the range is smaller than or equal to the threshold.
+
+For tasks that are within the threshold, letter frequency is calculated. The [`isAlphabetic`][isAlphabetic] method is used to identify all characters classified as alphabetic in Unicode, covering various languages like English, Korean, Japanese, Chinese, etc., returning true for alphabetic characters and false for numbers, special characters, spaces, and others.


Suggest using Character.isAlphabetic here to make it clear the method is from the Character class.

Suggested change

For tasks that are within the threshold, letter frequency is calculated. The [`isAlphabetic`][isAlphabetic] method is used to identify all characters classified as alphabetic in Unicode, covering various languages like English, Korean, Japanese, Chinese, etc., returning true for alphabetic characters and false for numbers, special characters, spaces, and others.

For tasks that are within the threshold, letter frequency is calculated.

The [`Character.isAlphabetic`][isAlphabetic] method is used to identify all characters classified as alphabetic in Unicode, covering various languages like English, Korean, Japanese, Chinese, etc., returning `true` for alphabetic characters and `false` for numbers, special characters, spaces, and others.

masiljangajji · 2024-11-13T16:48:09Z

Hi @kahgoh Thanks for reviewing!

I’ve incorporated the feedback and committed the changes. However, when I run markdownlint-cli2 on PULL_REQUEST_TEMPLATE.md encounter the error , Please check it

kahgoh

Thanks for the updates! There are still some places where I think we should place backticks. I've gone ahead and added them as suggestions.

I wasn't sure if there was misunderstanding in regards my earlier comment about having a sentence per line as I can see there are now empty lines between each sentence. While each sentence should start on its own line, there should only be empty lines between paragraphs.

For example, this from your first commit was fine:

It looks like this:
For example, this from your first commit was fine:


There are multiple ways to solve the Parallel Letter Frequency problem.
One approach is to use `parallelStream`, and another involves using `ForkJoinPool`.

It renders like this:

There are multiple ways to solve the Parallel Letter Frequency problem. One approach is to use parallelStream, and another involves using ForkJoinPool.

But this makes two paragraphs:

There are multiple ways to solve the Parallel Letter Frequency problem.

One approach is to use `parallelStream`, and another involves using `ForkJoinPool`.

It looks like this:

There are multiple ways to solve the Parallel Letter Frequency problem.

One approach is to use parallelStream, and another involves using ForkJoinPool.

Notice the first example looks like one paragraph, whereas the second looks like two.

See other approaches, like the collatz conjecture or Difference of squares for examples on how they are formatted.

I thought the arrangement of paragraphs or empty lines from your first commit was fine - we just needed to move the sentences to start on its own line. I have added some suggestions where the empty lines can be removed to turn them back to paragraphs. Feel free to go through and update other spots accordingly.

kahgoh · 2024-11-13T22:20:47Z

.github/PULL_REQUEST_TEMPLATE.md

 <!-- Your content goes here: -->

-
-


Yeah, I think we should. I've just tried running our Markdown Lint action on our main branch (before your change). I think the rules are a bit different with that one.

kahgoh · 2024-11-13T22:51:50Z

exercises/practice/parallel-letter-frequency/.approaches/fork-join/content.md

+
+The core of [`ForkJoinPool`][ForkJoinPool] is the Fork/Join mechanism, which divides tasks into smaller units and processes them in parallel.
+
+THRESHOLD is the criterion for task division.


Suggested change

THRESHOLD is the criterion for task division.

`THRESHOLD` is the criterion for task division.

kahgoh · 2024-11-13T22:53:13Z

exercises/practice/parallel-letter-frequency/.approaches/fork-join/content.md

+
+THRESHOLD is the criterion for task division.
+
+If the range of texts exceeds the THRESHOLD, the task is divided into two subtasks, and [`invokeAll`][invokeAll](leftTask, rightTask) is called to execute both tasks in parallel.


Suggested change

If the range of texts exceeds the THRESHOLD, the task is divided into two subtasks, and [`invokeAll`][invokeAll](leftTask, rightTask) is called to execute both tasks in parallel.

If the range of texts exceeds the `THRESHOLD`, the task is divided into two subtasks, and [`invokeAll(leftTask, rightTask)`][invokeAll] is called to execute both tasks in parallel.

kahgoh · 2024-11-13T22:54:45Z

exercises/practice/parallel-letter-frequency/.approaches/fork-join/content.md

+
+If the range of texts exceeds the THRESHOLD, the task is divided into two subtasks, and [`invokeAll`][invokeAll](leftTask, rightTask) is called to execute both tasks in parallel.
+
+Each subtask in LetterCountTask will continue calling compute() to divide itself further until the range is smaller than or equal to the threshold.


Suggested change

Each subtask in LetterCountTask will continue calling compute() to divide itself further until the range is smaller than or equal to the threshold.

Each subtask in `LetterCountTask` will continue calling `compute()` to divide itself further until the range is smaller than or equal to the threshold.

kahgoh · 2024-11-13T22:55:06Z

exercises/practice/parallel-letter-frequency/.approaches/introduction.md

+
+The Java 8 [`stream`][stream] API provides methods that make parallel processing easier, including the parallelStream() method.
+
+With parallelStream(), developers can use the ForkJoinPool model for workload division and parallel execution, without the need to manually manage threads or create custom thread pools.


Suggested change

With parallelStream(), developers can use the ForkJoinPool model for workload division and parallel execution, without the need to manually manage threads or create custom thread pools.

With `parallelStream()`, developers can use the ForkJoinPool model for workload division and parallel execution, without the need to manually manage threads or create custom thread pools.

kahgoh · 2024-11-13T22:59:49Z

exercises/practice/parallel-letter-frequency/.approaches/fork-join/content.md

+
+The [`Character.isAlphabetic`][isAlphabetic] method is used to identify all characters classified as alphabetic in Unicode, covering various languages like English, Korean, Japanese, Chinese, etc., returning true for alphabetic characters and false for numbers, special characters, spaces, and others.
+
+Additionally, since uppercase and lowercase letters are treated as the same character (e.g., A and a), each character is converted to lowercase.


Suggested change

Additionally, since uppercase and lowercase letters are treated as the same character (e.g., A and a), each character is converted to lowercase.

Additionally, since uppercase and lowercase letters are treated as the same character (e.g., `A` and `a`), each character is converted to lowercase.

kahgoh · 2024-11-13T23:30:14Z

exercises/practice/parallel-letter-frequency/.approaches/introduction.md

+# Introduction
+
+There are multiple ways to solve the Parallel Letter Frequency problem.
+


Suggest removing the empty line to turn back into paragraph.

Suggested change

kahgoh · 2024-11-13T23:57:29Z

exercises/practice/parallel-letter-frequency/.approaches/introduction.md

+## General guidance
+
+To count occurrences of items, a map data structure is often used, though arrays and lists can work as well.
+


Suggested change

kahgoh · 2024-11-13T23:59:42Z

exercises/practice/parallel-letter-frequency/.approaches/introduction.md

+To count occurrences of items, a map data structure is often used, though arrays and lists can work as well.
+
+A [`map`][map], being a key-value pair structure, is suitable for recording frequency by incrementing the value for each key.
+


Suggested change

kahgoh · 2024-11-14T00:01:44Z

exercises/practice/parallel-letter-frequency/.approaches/introduction.md

+Parallel processing typically takes place in a multi-[`thread`][thread] environment.
+
+The Java 8 [`stream`][stream] API provides methods that make parallel processing easier, including the parallelStream() method.
+


Suggested change

masiljangajji · 2024-11-14T12:39:41Z

Hi @kahgoh
I'm not very familiar with English, so I made a few mistakes. Thank you for the detailed review!

kahgoh

Thanks! I think we're almost there! Just spotted a couple of minor things.

kahgoh · 2024-11-14T13:52:18Z

exercises/practice/parallel-letter-frequency/.approaches/fork-join/content.md

+
+`THRESHOLD` is the criterion for task division.
+If the range of texts exceeds the `THRESHOLD`, the task is divided into two subtasks, and [`invokeAll(leftTask, rightTask)`][invokeAll] is called to execute both tasks in parallel.
+Each subtask in LetterCountTask will continue calling compute() to divide itself further until the range is smaller than or equal to the `THRESHOLD`.


Suggest clarifying that compute is called through invokeAll. Your example only shows invokeAll being called, not compute, so it might be confusing. Also, suggest putting the LetterCountTask and compute in backticks for formatting.

Suggested change

Each subtask in LetterCountTask will continue calling compute() to divide itself further until the range is smaller than or equal to the `THRESHOLD`.

Each subtask in `LetterCountTask` will continue calling `compute()` (via `invokeAll(leftTask, rightTask)`) to divide itself further until the range is smaller than or equal to the `THRESHOLD`.

masiljangajji · 2024-11-14T14:06:43Z

@kahgoh Thank you! Is there anything else that could be improved?

kahgoh

Thanks! It looks good to me now!

masiljangajji · 2024-11-14T14:29:58Z

@kahgoh Thank you so much for the detailed review. This is my first time contributing to open source, and since I'm not very familiar with English, I made a lot of mistakes. Thanks to you, I was able to have a great experience!

masiljangajji added 2 commits November 6, 2024 09:13

Add approaches for Parallel-Letter-Frequency

a0ca392

fix: markdown according to the rules

b84ea23

kahgoh requested changes Nov 13, 2024

View reviewed changes

masiljangajji added 5 commits November 14, 2024 01:06

docs: undo PULL_REQUEST_TEMPLATE.md

4007c38

docs: make it clear the method is from the Character

616bcc2

docs: update(introduction.md) markdown format

1f0531d

docs: update markdown format and make it clear the method

28a8ebc

docs: update markdown format(markdownlint-cli2)

49512f7

kahgoh reviewed Nov 14, 2024

View reviewed changes

masiljangajji added 6 commits November 14, 2024 20:19

docs: update markdown format(PULL_REQUEST_TEMPLATE.md)

42bee45

docs: update fork-join content

faf10e0

docs: update parallel-stream content

72b1485

docs: update introduction

d876b63

docs: rollback invokeAll

9ed7813

docs: erase whitespace

01cbae2

update introduction.md

fbb7525

kahgoh reviewed Nov 14, 2024

View reviewed changes

docs: clarified that compute is called through invokeAll

ba55162

docs: parallelStream hyperlink add

e624a68

kahgoh approved these changes Nov 14, 2024

View reviewed changes

kahgoh merged commit e28da7b into exercism:main Nov 14, 2024
2 checks passed

tasxatzial mentioned this pull request Nov 15, 2024

Adding approach to Queen-Attack #2860

Merged

	One approach is to use parallelStream, and another involves using ForkJoinPool.
	One approach is to use `Stream.parallelStream`, and another involves using `ForkJoinPool`.


		## General guidance

		To count occurrences of items, a map data structure is often used, though arrays and lists can work as well. A map, being a key-value pair structure, is suitable for recording frequency by incrementing the value for each key.

	To count occurrences of items, a map data structure is often used, though arrays and lists can work as well. A map, being a key-value pair structure, is suitable for recording frequency by incrementing the value for each key.
	To count occurrences of items, a map data structure is often used, though arrays and lists can work as well.
	A map, being a key-value pair structure, is suitable for recording frequency by incrementing the value for each key.


		Each subtask in LetterCountTask will continue calling compute() to divide itself further until the range is smaller than or equal to the threshold.

		For tasks that are within the threshold, letter frequency is calculated. The [`isAlphabetic`][isAlphabetic] method is used to identify all characters classified as alphabetic in Unicode, covering various languages like English, Korean, Japanese, Chinese, etc., returning true for alphabetic characters and false for numbers, special characters, spaces, and others.

	For tasks that are within the threshold, letter frequency is calculated. The [`isAlphabetic`][isAlphabetic] method is used to identify all characters classified as alphabetic in Unicode, covering various languages like English, Korean, Japanese, Chinese, etc., returning true for alphabetic characters and false for numbers, special characters, spaces, and others.
	For tasks that are within the threshold, letter frequency is calculated.
	The [`Character.isAlphabetic`][isAlphabetic] method is used to identify all characters classified as alphabetic in Unicode, covering various languages like English, Korean, Japanese, Chinese, etc., returning `true` for alphabetic characters and `false` for numbers, special characters, spaces, and others.


		The core of [`ForkJoinPool`][ForkJoinPool] is the Fork/Join mechanism, which divides tasks into smaller units and processes them in parallel.

		THRESHOLD is the criterion for task division.

	THRESHOLD is the criterion for task division.
	`THRESHOLD` is the criterion for task division.


		THRESHOLD is the criterion for task division.

		If the range of texts exceeds the THRESHOLD, the task is divided into two subtasks, and [`invokeAll`][invokeAll](leftTask, rightTask) is called to execute both tasks in parallel.

	If the range of texts exceeds the THRESHOLD, the task is divided into two subtasks, and [`invokeAll`][invokeAll](leftTask, rightTask) is called to execute both tasks in parallel.
	If the range of texts exceeds the `THRESHOLD`, the task is divided into two subtasks, and [`invokeAll(leftTask, rightTask)`][invokeAll] is called to execute both tasks in parallel.

	Each subtask in LetterCountTask will continue calling compute() to divide itself further until the range is smaller than or equal to the threshold.
	Each subtask in `LetterCountTask` will continue calling `compute()` to divide itself further until the range is smaller than or equal to the threshold.


		The Java 8 [`stream`][stream] API provides methods that make parallel processing easier, including the parallelStream() method.

		With parallelStream(), developers can use the ForkJoinPool model for workload division and parallel execution, without the need to manually manage threads or create custom thread pools.

	With parallelStream(), developers can use the ForkJoinPool model for workload division and parallel execution, without the need to manually manage threads or create custom thread pools.
	With `parallelStream()`, developers can use the ForkJoinPool model for workload division and parallel execution, without the need to manually manage threads or create custom thread pools.


		The [`Character.isAlphabetic`][isAlphabetic] method is used to identify all characters classified as alphabetic in Unicode, covering various languages like English, Korean, Japanese, Chinese, etc., returning true for alphabetic characters and false for numbers, special characters, spaces, and others.

		Additionally, since uppercase and lowercase letters are treated as the same character (e.g., A and a), each character is converted to lowercase.

		# Introduction

		There are multiple ways to solve the Parallel Letter Frequency problem.

		To count occurrences of items, a map data structure is often used, though arrays and lists can work as well.

		A [`map`][map], being a key-value pair structure, is suitable for recording frequency by incrementing the value for each key.

		Parallel processing typically takes place in a multi-[`thread`][thread] environment.

		The Java 8 [`stream`][stream] API provides methods that make parallel processing easier, including the parallelStream() method.

Uh oh!

Add approaches for Parallel Letter Frequency #2863

Add approaches for Parallel Letter Frequency #2863

Uh oh!

Conversation

masiljangajji commented Nov 12, 2024

pull request

Uh oh!

kahgoh left a comment

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

masiljangajji commented Nov 13, 2024

Uh oh!

kahgoh left a comment

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

masiljangajji commented Nov 14, 2024

Uh oh!

kahgoh left a comment

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

masiljangajji commented Nov 14, 2024

Uh oh!

kahgoh left a comment

Choose a reason for hiding this comment

Uh oh!

Uh oh!

masiljangajji commented Nov 14, 2024 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

2 participants

masiljangajji commented Nov 14, 2024 •

edited

Loading