Adding approach change #2859

jagdish-15 · 2024-11-09T17:28:03Z

pull request

This pull request adds an approach for the "Change" exercise in the Java track, based on discussions with @kahgoh during mentoring.

I was unsure how to generate a uuid for the approach, so I've left it empty for now. I would greatly appreciate guidance on how to generate one.

Reviewer Resources:

Track Policies

jagdish-15 · 2024-11-09T18:03:59Z

There's only one issue causing the unsuccessful check i.e. the uuid.

kahgoh

Sorry it took me a while to get to this one @jagdish-15. Looking at the content, it looks the structure and formatting differ quite a bit from the existing ones, so the comments are mostly trying to become more consistent with the existing ones.

kahgoh · 2024-11-14T23:26:56Z

exercises/practice/change/.approaches/dynamic-programming/content.md

@@ -0,0 +1,86 @@
+# Dynamic Programming Approach
+
+The **Dynamic Programming (DP)** approach is an efficient way to solve the problem of making change for a given total using a list of available coin denominations. It minimizes the number of coins needed by breaking down the problem into smaller subproblems and solving them progressively.


Looking at how we have written the content for some of other approaches (like boolean chain for leap, bit shifting for grains and if statements for Bob, I'd suggest moving the code up here, just under the heading. The description of the approach then begins just under it.

Also, we generally use one sentence per line in our Markdown content. For example:

The **Dynamic Programming (DP)** approach is an efficient way to solve the problem of making change for a given total using a list of available coin denominations. It minimizes the number of coins needed by breaking down the problem into smaller subproblems and solving them progressively.

Sure, I will move the code to the top and start the explanation afterward. I have also used new lines for every sentence separately, except when it is in a bullet point.

kahgoh · 2024-11-14T23:47:37Z

exercises/practice/change/.approaches/dynamic-programming/content.md

+
+- **Efficiency**: This approach is highly efficient in terms of minimizing the number of coins, but it might require significant memory for larger `grandTotal` values, as the space complexity grows linearly with `grandTotal`.
+
+- **Alternative Approaches**:


Could you please remove this section on alternative approaches? This should just focus on the dynamic programming approach as this will become the dynamic programming page. Alternatively, we could move it to a Which approach to use? section in the introduction.md (similar to the isogram or robot name approaches), but we probably should briefly describe the Greedy Approach if we do (and we could possibly move the point about the efficiency there too).

I have removed both the "Efficiency" and "Alternative Approach" sections entirely. I agree that it makes more sense to include these points in the introduction file under a section like "Which Approach to Use?" However, I believe this should be done only after we add another approach to compare. For now, with just a single approach, these sections are unnecessary.

kahgoh · 2024-11-15T12:22:58Z

exercises/practice/change/.approaches/introduction.md

@@ -0,0 +1,26 @@
+# Introduction to Change Calculator


This suggestion is to make the heading consistent with our other existing approaches.

Suggested change

# Introduction to Change Calculator

# Introduction

kahgoh · 2024-11-15T13:22:14Z

exercises/practice/change/.approaches/introduction.md

+
+In the "Change Calculator" exercise, the goal is to determine the minimum number of coins needed to reach a given total using a specific set of coin denominations. This is a classic problem in dynamic programming, where efficient change-making is essential, especially when there are constraints on coin types or large totals.
+
+## Problem Overview


I don't think we need to repeat the exercise here. The other approaches generally have a "General guidance" section that talks about the "key things" to solve the exercise - things that all approaches are likely to have to. For example, in leap, it is as simple as knowing whether a year is divisible by 400, 100 and 4. For grains, its knowing that each square is doubled.

For Change, it could be that not all totals can be reached and somehow figuring out which ones can be reached and how.

Suggested change

## Problem Overview

## General guidance

Sure, I've changed it.

kahgoh · 2024-11-15T13:31:15Z

exercises/practice/change/.approaches/introduction.md

+
+The solution should find the optimal combination of coins to match the total. If it's impossible to match the total exactly, the solution should indicate this by throwing an exception.
+
+## Approach Overview


The other approaches generally have a short listing of all the approaches here, with a link to the specific approach's page just underneath. For example, this would normally be a code listing for your dynamic programming approach followed by a link to the page generated from dynamic-programming/content.md (the URL would be https://exercism.org/tracks/java/exercises/change/approaches/dynamic-programming).

Suggested change

## Approach Overview

## Approach: Dynamic programming

kahgoh · 2024-11-15T13:38:01Z

exercises/practice/change/.approaches/introduction.md

+- **Flexibility**: Handles cases where exact change is impossible by checking at each step.
+- **Scalability**: Works for various coin denominations and totals, though large inputs may impact performance.
+
+For a detailed look at the code and logic, see the full explanation in the [approach file](https://exercism.org/tracks/java/exercises/change/approaches/dynamic-programming).


In regards to the approach file link, there is a preference to use reference linking to make maintenance easier.

I also suggest changing the link text to "Dynamic Programming approach" as students will see a web page based on your content.md (and not the content.md "file").

I agree, and I've made the changes accordingly.

kahgoh · 2024-11-15T14:34:23Z

exercises/practice/change/.approaches/config.json

+        "jagdish-15"
+      ],
+      "contributors": [
+        "kagoh"


Suggested change

"kagoh"

"kahgoh"

I am sorry for the oversight.

jagdish-15 · 2024-11-15T16:23:12Z

Thank you so much, @kahgoh, for all these suggestions. Please let me know if there's anything else I should improve, change, or remove.

kahgoh

Thanks @jagdish-15, that looks better!

kahgoh · 2024-11-17T13:09:58Z

exercises/practice/change/.approaches/dynamic-programming/content.md

+The **Dynamic Programming (DP)** approach is an efficient way to solve the problem of making change for a given total using a list of available coin denominations.
+It minimizes the number of coins needed by breaking down the problem into smaller subproblems and solving them progressively.
+
+This approach ensures that we find the most efficient way to make change and handles edge cases where no solution exists.


I find this sentence redundant because all the approaches will need to do this to successfully solve the exercise.

Suggested change

This approach ensures that we find the most efficient way to make change and handles edge cases where no solution exists.

Yep, I can't deny! I will remove this sentence altogether.

kahgoh · 2024-11-17T13:46:01Z

exercises/practice/change/.approaches/dynamic-programming/content.md

+   - After processing all values up to `grandTotal`, the combination at `coinsUsed[grandTotal]` will represent the most efficient solution.
+   - If no valid combination exists for `grandTotal`, an exception is thrown.
+
+## Key Points


I think the core of this document should be focusing on the specifics of how the approach works. From that point of view, I think the Key Points heading/section is confusing as Time Complexity and Space Complexity isn't a core part of the implementation, but I do think we can certainly mention them. Perhaps we could remove the heading.

Suggested change

## Key Points

Sure, I've removed this heading.

kahgoh · 2024-11-17T13:52:04Z

exercises/practice/change/.approaches/dynamic-programming/content.md

+
+- **Space Complexity**: The space complexity is **O(n)** due to the list `coinsUsed`, which stores the most efficient coin combination for each total up to `grandTotal`.
+
+- **Edge Cases**:


Suggest moving the points from the edge cases to be with your explanation as they are part of the implementation details. Idalso suggest separating them to follow the order of the code to make it easier to follow (i.e putting the point about checking if grandTotal is negative to the top and one about if no exact total to the bottom of the explanation).

I've moved the first point to the start of the explanation as you suggested and removed the second point since it's already covered at the end, just before the 'Time Complexity' section.

kahgoh · 2024-11-18T14:47:25Z

exercises/practice/change/.approaches/dynamic-programming/content.md

+## Conclusion
+
+The dynamic programming approach provides an optimal solution for the change-making problem, ensuring that we minimize the number of coins used while efficiently solving the problem for any `grandTotal`.
+However, it’s essential to consider the trade-offs in terms of memory usage and the time complexity when dealing with very large inputs.


I think we could remove this conclusion section. Similar to my earlier comment, I think the first sentence is redundant as all approaches have find the optimal solution to be valid. The second sentence would probably make more sense in a Which approach to use? section if we have more approaches.

I agree! I've removed the conclusion section altogether.

exercises/practice/change/.approaches/introduction.md

into add-approach-change merging with remote

jagdish-15 · 2024-11-18T19:07:57Z

Sorry for all the back-and-forth! I've submitted it now—please take a look and let me know your thoughts.

kahgoh

No worries, thanks for preserevering! I think we're almost there!

exercises/practice/change/.approaches/dynamic-programming/content.md

…ent.md Co-authored-by: Kah Goh <[email protected]>

kahgoh

Sorry, have some minor style comments that are similar to the ones on the Queen Attack PR

kahgoh · 2024-11-21T09:15:30Z

exercises/practice/change/.approaches/dynamic-programming/content.md

+
+## Time and Space Complexity
+
+- The time complexity of this approach is **O(n * m)**, where `n` is the `grandTotal` and `m` is the number of available coin denominations. This is because we iterate over all coin denominations for each amount up to `grandTotal`.


Suggested change

- The time complexity of this approach is **O(n * m)**, where `n` is the `grandTotal` and `m` is the number of available coin denominations. This is because we iterate over all coin denominations for each amount up to `grandTotal`.

The time complexity of this approach is **O(n * m)**, where `n` is the `grandTotal` and `m` is the number of available coin denominations. This is because we iterate over all coin denominations for each amount up to `grandTotal`.

kahgoh · 2024-11-21T09:15:41Z

exercises/practice/change/.approaches/dynamic-programming/content.md

+
+- The time complexity of this approach is **O(n * m)**, where `n` is the `grandTotal` and `m` is the number of available coin denominations. This is because we iterate over all coin denominations for each amount up to `grandTotal`.
+
+- The space complexity is **O(n)** due to the list `coinsUsed`, which stores the most efficient coin combination for each total up to `grandTotal`.


Suggested change

- The space complexity is **O(n)** due to the list `coinsUsed`, which stores the most efficient coin combination for each total up to `grandTotal`.

The space complexity is **O(n)** due to the list `coinsUsed`, which stores the most efficient coin combination for each total up to `grandTotal`.

kahgoh · 2024-11-21T09:40:32Z

exercises/practice/change/.approaches/dynamic-programming/content.md

+
+## Explanation
+
+1. **Initialize Coins Usage Tracker**:


Similar to one the comments on the Queen Attack approach, should this be a heading?

Suggested change

1. **Initialize Coins Usage Tracker**:

### Initialize Coins Usage Tracker

This would make sense much more as a sub-heading!

kahgoh · 2024-11-21T09:40:44Z

exercises/practice/change/.approaches/dynamic-programming/content.md

+   - We create a list `coinsUsed`, where each index `i` stores the most efficient combination of coins that sum up to the value `i`.
+   - The list is initialized with an empty list at index `0`, as no coins are needed to achieve a total of zero.
+
+2. **Iterative Dynamic Programming**:


Suggested change

2. **Iterative Dynamic Programming**:

### Iterative Dynamic Programming

kahgoh · 2024-11-21T09:40:56Z

exercises/practice/change/.approaches/dynamic-programming/content.md

+   - For each coin, we check if it can be part of the solution (i.e., if `coin <= i` and `coinsUsed[i - coin]` is a valid combination).
+   - If so, we generate a new combination by adding the current coin to the solution for `i - coin`. We then compare the size of this new combination with the existing best combination and keep the one with fewer coins.
+
+3. **Result**:


Suggested change

3. **Result**:

### Result

kahgoh · 2024-11-21T12:53:54Z

exercises/practice/change/.approaches/dynamic-programming/content.md

+
+1. **Initialize Coins Usage Tracker**:
+
+   - If the `grandTotal` is negative, an exception is thrown immediately.


If the making Initialize Coins Usage Tracker a heading the indent should be removed.

Suggested change

- If the `grandTotal` is negative, an exception is thrown immediately.

- If the `grandTotal` is negative, an exception is thrown immediately.

jagdish-15 · 2024-11-23T14:56:36Z

Sorry, have some minor style comments that are similar to the ones on the Queen Attack PR

No problem at all! I appreciate you taking the time to review. I'll address these style comments just like I did on the Queen Attack PR. Thanks for pointing them out!

jagdish-15 · 2024-11-23T15:16:39Z

I’ve updated the files based on your suggestions, and I think they look much better now. Thank you for the feedback—I’ll take it as a learning opportunity. Apologies for the delay in acting on the suggestions, similar to the Queen Attack PR.

kahgoh

Looks good now! Thanks for perservering with this one!

jagdish-15 added 2 commits November 9, 2024 23:07

Adding approach change

e3cbf38

Fixing typo in filename

4a7811f

jagdish-15 force-pushed the add-approach-change branch from 45b9f4f to 4a7811f Compare November 9, 2024 17:37

jagdish-15 added 4 commits November 9, 2024 23:25

Fixing style errors

e8d2787

Fixing style errors

6152c10

Fixing stle errors

5d398d0

Fixing file names

115a331

jagdish-15 added 3 commits November 14, 2024 23:25

Adding uuid for approach of change

d2c2451

Adding snippet for approach of change

b3a98df

Merge branch 'main' into add-approach-change

e338ff2

kahgoh reviewed Nov 15, 2024

View reviewed changes

jagdish-15 added 2 commits November 15, 2024 21:42

Updating approach files

9438325

Fixing styling errors

fde837b

kahgoh reviewed Nov 18, 2024

View reviewed changes

jagdish-15 added 10 commits November 19, 2024 00:03

Adding approach change

7ec2960

Fixing typo in filename

404de05

Fixing style errors

1aa6d9c

Fixing style errors

2fbec2a

Fixing stle errors

c1d07e5

Fixing file names

afee45a

Adding uuid for approach of change

d9694fa

Adding snippet for approach of change

7aa412e

Updating approach files

f3eb007

Fixing styling errors

0b5b6f2

jagdish-15 force-pushed the add-approach-change branch from fde837b to 0b5b6f2 Compare November 18, 2024 18:33

jagdish-15 added 3 commits November 19, 2024 00:04

Merge branch 'add-approach-change' of https://github.com/jagdish-15/java

2df72c4

into add-approach-change merging with remote

Updating approaches for Change after feedback

2758bc3

Fixing styling issues for approache for Change

c0a46c6

This was referenced Nov 18, 2024

Adding approach to Queen-Attack #2860

Merged

Adding approach for Bob #2861

Open

kahgoh reviewed Nov 19, 2024

View reviewed changes

jagdish-15 and others added 3 commits November 19, 2024 21:38

Update exercises/practice/change/.approaches/dynamic-programming/cont…

f76ad5d

…ent.md Co-authored-by: Kah Goh <[email protected]>

Update exercises/practice/change/.approaches/dynamic-programming/cont…

5db8204

…ent.md Co-authored-by: Kah Goh <[email protected]>

Updating content for dynamic approach of change

505a92d

kahgoh reviewed Nov 21, 2024

View reviewed changes

jagdish-15 added 2 commits November 23, 2024 20:30

Merge branch 'main' into add-approach-change

39f0e69

Updating content.md of dynamic approach of chnage exercise

2dea910

Merge branch 'main' into add-approach-change

4e0e5e0

kahgoh approved these changes Nov 25, 2024

View reviewed changes

kahgoh merged commit 109a4c2 into exercism:main Nov 25, 2024
2 checks passed

jagdish-15 deleted the add-approach-change branch November 26, 2024 17:41

		@@ -0,0 +1,86 @@
		# Dynamic Programming Approach

		The Dynamic Programming (DP) approach is an efficient way to solve the problem of making change for a given total using a list of available coin denominations. It minimizes the number of coins needed by breaking down the problem into smaller subproblems and solving them progressively.


		- Efficiency: This approach is highly efficient in terms of minimizing the number of coins, but it might require significant memory for larger `grandTotal` values, as the space complexity grows linearly with `grandTotal`.

		- Alternative Approaches:


		In the "Change Calculator" exercise, the goal is to determine the minimum number of coins needed to reach a given total using a specific set of coin denominations. This is a classic problem in dynamic programming, where efficient change-making is essential, especially when there are constraints on coin types or large totals.

		## Problem Overview


		The solution should find the optimal combination of coins to match the total. If it's impossible to match the total exactly, the solution should indicate this by throwing an exception.

		## Approach Overview


		- Space Complexity: The space complexity is O(n) due to the list `coinsUsed`, which stores the most efficient coin combination for each total up to `grandTotal`.

		- Edge Cases:


		## Time and Space Complexity

		- The time complexity of this approach is *O(n m)**, where `n` is the `grandTotal` and `m` is the number of available coin denominations. This is because we iterate over all coin denominations for each amount up to `grandTotal`.

	- The time complexity of this approach is *O(n m)**, where `n` is the `grandTotal` and `m` is the number of available coin denominations. This is because we iterate over all coin denominations for each amount up to `grandTotal`.
	The time complexity of this approach is *O(n m)**, where `n` is the `grandTotal` and `m` is the number of available coin denominations. This is because we iterate over all coin denominations for each amount up to `grandTotal`.


		- The time complexity of this approach is *O(n m)**, where `n` is the `grandTotal` and `m` is the number of available coin denominations. This is because we iterate over all coin denominations for each amount up to `grandTotal`.

		- The space complexity is O(n) due to the list `coinsUsed`, which stores the most efficient coin combination for each total up to `grandTotal`.

	- The space complexity is O(n) due to the list `coinsUsed`, which stores the most efficient coin combination for each total up to `grandTotal`.
	The space complexity is O(n) due to the list `coinsUsed`, which stores the most efficient coin combination for each total up to `grandTotal`.

	1. Initialize Coins Usage Tracker:
	### Initialize Coins Usage Tracker

	2. Iterative Dynamic Programming:
	### Iterative Dynamic Programming


		1. Initialize Coins Usage Tracker:

		- If the `grandTotal` is negative, an exception is thrown immediately.

Adding approach change #2859

Adding approach change #2859

Conversation

jagdish-15 commented Nov 9, 2024

pull request

jagdish-15 commented Nov 9, 2024

kahgoh left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

jagdish-15 commented Nov 15, 2024

kahgoh left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

jagdish-15 Nov 18, 2024 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

jagdish-15 commented Nov 18, 2024

kahgoh left a comment

Choose a reason for hiding this comment

kahgoh left a comment • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

jagdish-15 commented Nov 23, 2024

jagdish-15 commented Nov 23, 2024

kahgoh left a comment

Choose a reason for hiding this comment

jagdish-15 Nov 18, 2024 •

edited

Loading

kahgoh left a comment •

edited

Loading