From c9525b4bd31cfcf7f3e0f6f3f39ad4c2f2452b2d Mon Sep 17 00:00:00 2001 From: manumafe98 Date: Thu, 4 Apr 2024 16:02:04 -0300 Subject: [PATCH 01/15] Starting to reformat loops into a unified concept --- concepts/for-loops/.meta/config.json | 8 - concepts/for-loops/about.md | 67 ------- concepts/for-loops/introduction.md | 69 ------- concepts/for-loops/links.json | 6 - concepts/foreach-loops/.meta/config.json | 8 - concepts/foreach-loops/about.md | 45 ----- concepts/foreach-loops/introduction.md | 45 ----- concepts/foreach-loops/links.json | 6 - concepts/loops/.meta/config.json | 5 + concepts/loops/about.md | 178 +++++++++++++++++ concepts/loops/introduction.md | 178 +++++++++++++++++ concepts/loops/links.json | 10 + config.json | 34 ++-- .../concept/making-the-grade/.docs/hints.md | 0 .../making-the-grade/.docs/instructions.md | 0 .../making-the-grade/.docs/introduction.md | 180 ++++++++++++++++++ .../.docs/introduction.md.tpl | 3 + .../concept/making-the-grade/build.gradle | 23 +++ exercises/settings.gradle | 1 + 19 files changed, 598 insertions(+), 268 deletions(-) delete mode 100644 concepts/for-loops/.meta/config.json delete mode 100644 concepts/for-loops/about.md delete mode 100644 concepts/for-loops/introduction.md delete mode 100644 concepts/for-loops/links.json delete mode 100644 concepts/foreach-loops/.meta/config.json delete mode 100644 concepts/foreach-loops/about.md delete mode 100644 concepts/foreach-loops/introduction.md delete mode 100644 concepts/foreach-loops/links.json create mode 100644 concepts/loops/.meta/config.json create mode 100644 concepts/loops/about.md create mode 100644 concepts/loops/introduction.md create mode 100644 concepts/loops/links.json create mode 100644 exercises/concept/making-the-grade/.docs/hints.md create mode 100644 exercises/concept/making-the-grade/.docs/instructions.md create mode 100644 exercises/concept/making-the-grade/.docs/introduction.md create mode 100644 exercises/concept/making-the-grade/.docs/introduction.md.tpl create mode 100644 exercises/concept/making-the-grade/build.gradle diff --git a/concepts/for-loops/.meta/config.json b/concepts/for-loops/.meta/config.json deleted file mode 100644 index 4d60e60ad..000000000 --- a/concepts/for-loops/.meta/config.json +++ /dev/null @@ -1,8 +0,0 @@ -{ - "blurb": "For loops allow for iteration over a specified range.", - "authors": [ - "samuelteixeiras", - "ystromm" - ], - "contributors": [] -} diff --git a/concepts/for-loops/about.md b/concepts/for-loops/about.md deleted file mode 100644 index 6988a26b9..000000000 --- a/concepts/for-loops/about.md +++ /dev/null @@ -1,67 +0,0 @@ -# About For Loops - -The [for loop](https://docs.oracle.com/javase/tutorial/java/nutsandbolts/for.html) provides a mechanism to execute a group of statements repeatedly until some condition is met. -The loop consists of four parts: - -```java -for (initialization; test; update) { - body; -} -``` - -The `initialization` sets an initial state for the loop and is executed exactly once at the start of the loop. -Typically it declares and assigns a variable used in the test expression and update statement. -For example: - -```java -int i = 1 -``` - -The `test` expression tests if the loop should end. -If it evaluates to true, the body and then the update expression will be executed. -If it evaluates to false, neither the body nor the update statement will be executed and execution resumes after the loop's closing bracket. -Typically it checks the variable assigned in the initialization block. -For example: - -```java -i <= 10 -``` - -After executing the loop body, the `update` expression is executed. -Typically it increments or decrements the loop variable by some value. -For example: - -```java -i++ -``` - -A for loop printing out the first four squares would look like this: - -```java -for (int i = 1; i <= 4; i++) { - System.out.println(i * i); -} - -/* => -1 -4 -9 -16 -*/ -``` - -If iterating through every element in a collection, a `for-each` loop is preferred, but it can be done with a `for` loop like this: - -```java -for (int i = 0; i < array.length; i++) { - System.out.print(array[i]); -} -``` - -A `for` loop does have some advantages over a `for-each` loop: - -- You can start or stop at the index you want. -- You can use any (boolean) termination condition you want. -- You can skip elements by customizing the incrementing of the loop variable. -- You can process collections from back to front by counting down. -- You can use `for` loops in scenarios that do not involve collections. diff --git a/concepts/for-loops/introduction.md b/concepts/for-loops/introduction.md deleted file mode 100644 index 7412e28ee..000000000 --- a/concepts/for-loops/introduction.md +++ /dev/null @@ -1,69 +0,0 @@ -# Introduction to For Loops - -The [for loop](https://docs.oracle.com/javase/tutorial/java/nutsandbolts/for.html) provides a mechanism to execute a group of statements repeatedly until some condition is met. -The loop consists of four parts: - -```java -for (initialization; test; update) { - body; -} -``` - -The `initialization` sets an initial state for the loop and is executed exactly once at the start of the loop. -Typically it declares and assigns a variable used in the test expression and update statement. -For example: - -```java -int i = 1 -``` - -The `test` expression tests if the loop should end. -If it evaluates to `true`, the body and then the update expression will be executed. -If it evaluates to `false`, neither the body nor the update statement will be executed and execution resumes after the loop's closing bracket. -Typically it checks the variable assigned in the initialization block. -For example: - -```java -i <= 10 -``` - -After executing the loop body, the `update` expression is executed. -Typically it increments or decrements the loop variable by some value. -For example: - -```java -i++ -``` - -A `for` loop printing out the first four squares would look like this: - -```java -for (int i = 1; i <= 4; i++) { - System.out.println("square of " + i + " is " + i * i); -} -``` - -The output would be: - -```text -square of 1 is 1 -square of 2 is 4 -square of 3 is 9 -square of 4 is 16 -``` - -If iterating through every element in a collection, a `for-each` loop is preferred, but it can be done with a `for` loop like this: - -```java -for (int i = 0; i < array.length; i++) { - System.out.print(array[i]); -} -``` - -A `for` loop does have some advantages over a `for-each` loop: - -- You can start or stop at the index you want. -- You can use any (boolean) termination condition you want. -- You can skip elements by customizing the incrementing of the loop variable. -- You can process collections from back to front by counting down. -- You can use `for` loops in scenarios that do not involve collections. diff --git a/concepts/for-loops/links.json b/concepts/for-loops/links.json deleted file mode 100644 index 15e9e6533..000000000 --- a/concepts/for-loops/links.json +++ /dev/null @@ -1,6 +0,0 @@ -[ - { - "url": "https://docs.oracle.com/javase/tutorial/java/nutsandbolts/for.html", - "description": "for-loop" - } -] diff --git a/concepts/foreach-loops/.meta/config.json b/concepts/foreach-loops/.meta/config.json deleted file mode 100644 index e2102abed..000000000 --- a/concepts/foreach-loops/.meta/config.json +++ /dev/null @@ -1,8 +0,0 @@ -{ - "blurb": "For-each loops allow for iteration over every element in a collection.", - "authors": [ - "samuelteixeiras", - "ystromm" - ], - "contributors": [] -} diff --git a/concepts/foreach-loops/about.md b/concepts/foreach-loops/about.md deleted file mode 100644 index 293b9c38f..000000000 --- a/concepts/foreach-loops/about.md +++ /dev/null @@ -1,45 +0,0 @@ -# About For-Each Loops - -The [for-each loop](https://docs.oracle.com/javase/tutorial/java/nutsandbolts/for.html) provides a mechanism for executing a block of code for each element in a collection. -Some documentation (eg. Oracle's documentation) refers to these as enhanced for loops. - -Here is the general syntax: - -```java -for(declaration: collection) { - body; -} -``` - -The `declaration` declares the variable used to hold the values assigned from the collection. - -The `collection` is an array or a collection holding the values that will be assigned to the loop variable. - -The `body` contains the statements that will be executed once for each value in the collection. - -For example: - -```java -char[] vowels = {'a', 'e', 'i', 'o', 'u'}; - -for(char vowel: vowels) { - System.out.println(vowel); -} -``` - -which outputs: - -```text -a -e -i -o -u -``` - -Generally a `for-each` loop is preferrable over a `for` loop for the following reasons: - -- A `for-each` loop is guaranteed to iterate over _all_ values. -- A `for-each` loop is more _declarative_ meaning the code is communicating _what_ it is doing, instead of _how_ it is doing it. -- A `for-each` loop is foolproof, whereas with `for` loops it is easy to have an off-by-one error (think of using `<` versus `<=`). -- A `for-each` loop works on all collection types, including those that do not support using an index to access elements (eg. a `Set`). diff --git a/concepts/foreach-loops/introduction.md b/concepts/foreach-loops/introduction.md deleted file mode 100644 index 7e2eec3c4..000000000 --- a/concepts/foreach-loops/introduction.md +++ /dev/null @@ -1,45 +0,0 @@ -# Introduction to For-Each Loops - -The [for-each loop](https://docs.oracle.com/javase/tutorial/java/nutsandbolts/for.html) provides a mechanism for executing a block of code for each element in a collection. -Some documentation (eg. Oracle's documentation) refers to these as enhanced for loops. - -Here is the general syntax: - -```java -for(declaration: collection) { - body; -} -``` - -The `declaration` declares the variable used to hold the values assigned from the collection. - -The `collection` is an array or collection holding the values that will be assigned to the loop variable. - -The `body` contains the statements that will be executed once for each value in the collection. - -For example: - -```java -char[] vowels = {'a', 'e', 'i', 'o', 'u'}; - -for(char vowel: vowels) { - System.out.println(vowel); -} -``` - -which outputs: - -```text -a -e -i -o -u -``` - -Generally a `for-each` loop is preferrable over a `for` loop for the following reasons: - -- A `for-each` loop is guaranteed to iterate over _all_ values. -- A `for-each` loop is more _declarative_ meaning the code is communicating _what_ it is doing, instead of _how_ it is doing it. -- A `for-each` loop is foolproof, whereas with `for` loops it is easy to have an off-by-one error (think of using `<` versus `<=`). -- A `for-each` loop works on all collection types, including those that do not support using an index to access elements (eg. a `Set`). diff --git a/concepts/foreach-loops/links.json b/concepts/foreach-loops/links.json deleted file mode 100644 index cd413aee3..000000000 --- a/concepts/foreach-loops/links.json +++ /dev/null @@ -1,6 +0,0 @@ -[ - { - "url": "https://docs.oracle.com/javase/tutorial/java/nutsandbolts/for.html", - "description": "foreach-loop" - } -] diff --git a/concepts/loops/.meta/config.json b/concepts/loops/.meta/config.json new file mode 100644 index 000000000..2111551f8 --- /dev/null +++ b/concepts/loops/.meta/config.json @@ -0,0 +1,5 @@ +{ + "blurb": "Loops are a fundamental concept in Java programming that allow you to execute a block of code repeatedly.", + "authors": ["manumafe98"], + "contributors": [] +} diff --git a/concepts/loops/about.md b/concepts/loops/about.md new file mode 100644 index 000000000..61006051c --- /dev/null +++ b/concepts/loops/about.md @@ -0,0 +1,178 @@ +# About + +In Java there are four looping constructs, two that are condition centric: `while` and `do-while` and the other two are iteration centric: `for` and `for-each`. + +## For + +A for loop provides a mechanism to execute a group of statements repeatedly until some condition is met. + +```java +for (initialization; test; update) { + body; +} +``` + +The `initialization` sets an initial state for the loop and is executed exactly once at the start of the loop. +Typically it declares and assigns a variable used in the test expression and update statement. +For example: + +```java +int i = 1 +``` + +The `test` expression tests if the loop should end. +If it evaluates to `true`, the body and then the update expression will be executed. +If it evaluates to `false`, neither the body nor the update statement will be executed and execution resumes after the loop's closing bracket. +Typically it checks the variable assigned in the initialization block. +For example: + +```java +i <= 10 +``` + +After executing the loop body, the `update` expression is executed. +Typically it increments or decrements the loop variable by some value. +For example: + +```java +i++ +``` + +A `for` loop printing out the first four squares would look like this: + +```java +for (int i = 1; i <= 4; i++) { + System.out.println("square of " + i + " is " + i * i); +} +``` + +The output would be: + +```text +square of 1 is 1 +square of 2 is 4 +square of 3 is 9 +square of 4 is 16 +``` + +If iterating through every element in a collection, a `for-each` loop is preferred, but it can be done with a `for` loop like this: + +```java +for (int i = 0; i < array.length; i++) { + System.out.print(array[i]); +} +``` + +A `for` loop does have some advantages over a `for-each` loop: + +- You can start or stop at the index you want. +- You can use any (boolean) termination condition you want. +- You can skip elements by customizing the incrementing of the loop variable. +- You can process collections from back to front by counting down. +- You can use `for` loops in scenarios that do not involve collections. + +## For-each + +A for-each loop provides a mechanism for executing a block of code for each element in a collection. + +```java +for (declaration: collection) { + body; +} +``` + +The `declaration` declares the variable used to hold the values assigned from the collection. + +The `collection` is an array or collection holding the values that will be assigned to the loop variable. + +The `body` contains the statements that will be executed once for each value in the collection. + +For example: + +```java +char[] vowels = {'a', 'e', 'i', 'o', 'u'}; + +for(char vowel: vowels) { + System.out.println(vowel); +} +``` + +which outputs: + +```text +a +e +i +o +u +``` + +Generally a `for-each` loop is preferrable over a `for` loop for the following reasons: + +- A `for-each` loop is guaranteed to iterate over _all_ values. +- A `for-each` loop is more _declarative_ meaning the code is communicating _what_ it is doing, instead of _how_ it is doing it. +- A `for-each` loop is foolproof, whereas with `for` loops it is easy to have an off-by-one error (think of using `<` versus `<=`). +- A `for-each` loop works on all collection types, including those that do not support using an index to access elements (eg. a `Set`). + +## While + +The `while` loop continually executes a block of statements while a particular condition is true. + +```java +while (condition) { + body; +} +``` + +The `condition` It's a statement that can be true or false. As long as the condition is true, the loop keeps running. +The `body` it's the code that gets executed repeatedly until the condition becomes false. + +For example: + +```java +int counter = 1; + +while (counter <= 5) { + System.out.println(counter); + counter++; +} +``` + +which outputs: + +```text +1 +2 +3 +4 +5 +``` + +Generally good rule of thumb is to use a `while` loops when you don't know exactly how many times you need to loop beforehand. + +## Do-while + +As `while` loops `do-while` loops are condition centric loops, but unlike a regular `while` loop, a `do-while` loop guarantees that the code inside the loop will run at least once, no matter what. + +```java +do { + body; +} while (condition); +``` + +For example: + +```java +int counter = 1; + +do { + System.out.println(counter); + counter++; +} while (counter < 2); +``` + +which outputs: + +```text +1 +``` diff --git a/concepts/loops/introduction.md b/concepts/loops/introduction.md new file mode 100644 index 000000000..144755dc6 --- /dev/null +++ b/concepts/loops/introduction.md @@ -0,0 +1,178 @@ +# Introduction + +In Java there are four looping constructs, two that are condition centric: `while` and `do-while` and the other two are iteration centric: `for` and `for-each`. + +## For + +A for loop provides a mechanism to execute a group of statements repeatedly until some condition is met. + +```java +for (initialization; test; update) { + body; +} +``` + +The `initialization` sets an initial state for the loop and is executed exactly once at the start of the loop. +Typically it declares and assigns a variable used in the test expression and update statement. +For example: + +```java +int i = 1 +``` + +The `test` expression tests if the loop should end. +If it evaluates to `true`, the body and then the update expression will be executed. +If it evaluates to `false`, neither the body nor the update statement will be executed and execution resumes after the loop's closing bracket. +Typically it checks the variable assigned in the initialization block. +For example: + +```java +i <= 10 +``` + +After executing the loop body, the `update` expression is executed. +Typically it increments or decrements the loop variable by some value. +For example: + +```java +i++ +``` + +A `for` loop printing out the first four squares would look like this: + +```java +for (int i = 1; i <= 4; i++) { + System.out.println("square of " + i + " is " + i * i); +} +``` + +The output would be: + +```text +square of 1 is 1 +square of 2 is 4 +square of 3 is 9 +square of 4 is 16 +``` + +If iterating through every element in a collection, a `for-each` loop is preferred, but it can be done with a `for` loop like this: + +```java +for (int i = 0; i < array.length; i++) { + System.out.print(array[i]); +} +``` + +A `for` loop does have some advantages over a `for-each` loop: + +- You can start or stop at the index you want. +- You can use any (boolean) termination condition you want. +- You can skip elements by customizing the incrementing of the loop variable. +- You can process collections from back to front by counting down. +- You can use `for` loops in scenarios that do not involve collections. + +## For-each + +A for-each loop provides a mechanism for executing a block of code for each element in a collection. + +```java +for (declaration: collection) { + body; +} +``` + +The `declaration` declares the variable used to hold the values assigned from the collection. + +The `collection` is an array or collection holding the values that will be assigned to the loop variable. + +The `body` contains the statements that will be executed once for each value in the collection. + +For example: + +```java +char[] vowels = {'a', 'e', 'i', 'o', 'u'}; + +for(char vowel: vowels) { + System.out.println(vowel); +} +``` + +which outputs: + +```text +a +e +i +o +u +``` + +Generally a `for-each` loop is preferrable over a `for` loop for the following reasons: + +- A `for-each` loop is guaranteed to iterate over _all_ values. +- A `for-each` loop is more _declarative_ meaning the code is communicating _what_ it is doing, instead of _how_ it is doing it. +- A `for-each` loop is foolproof, whereas with `for` loops it is easy to have an off-by-one error (think of using `<` versus `<=`). +- A `for-each` loop works on all collection types, including those that do not support using an index to access elements (eg. a `Set`). + +## While + +The `while` loop continually executes a block of statements while a particular condition is true. + +```java +while (condition) { + body; +} +``` + +The `condition` It's a statement that can be true or false. As long as the condition is true, the loop keeps running. +The `body` it's the code that gets executed repeatedly until the condition becomes false. + +For example: + +```java +int counter = 1; + +while (counter <= 5) { + System.out.println(counter); + counter++; +} +``` + +which outputs: + +```text +1 +2 +3 +4 +5 +``` + +Generally good rule of thumb is to use a `while` loops when you don't know exactly how many times you need to loop beforehand. + +## Do-while + +As `while` loops `do-while` loops are condition centric loops, but unlike a regular `while` loop, a `do-while` loop guarantees that the code inside the loop will run at least once, no matter what. + +```java +do { + body; +} while (condition); +``` + +For example: + +```java +int counter = 1; + +do { + System.out.println(counter); + counter++; +} while (counter < 2); +``` + +which outputs: + +```text +1 +``` diff --git a/concepts/loops/links.json b/concepts/loops/links.json new file mode 100644 index 000000000..555411ece --- /dev/null +++ b/concepts/loops/links.json @@ -0,0 +1,10 @@ +[ + { + "url": "https://docs.oracle.com/javase/tutorial/java/nutsandbolts/for.html", + "description": "The for and for-each statements" + }, + { + "url": "https://docs.oracle.com/javase/tutorial/java/nutsandbolts/while.html", + "description": "The while and do-while statements" + } +] diff --git a/config.json b/config.json index 65507f432..8569e7090 100644 --- a/config.json +++ b/config.json @@ -61,12 +61,11 @@ "name": "Bird Watcher", "uuid": "60600885-8684-45c3-b8a9-a2f9e3ce2d97", "concepts": [ - "arrays", - "for-loops", - "foreach-loops" + "arrays" ], "prerequisites": [ - "if-else-statements" + "if-else-statements", + "loops" ], "status": "active" }, @@ -308,6 +307,18 @@ "generic-types" ], "status": "beta" + }, + { + "slug": "making-the-grade", + "name": "Making the Grade", + "uuid": "e5d2a004-8c9b-4da3-831b-f7bbabf178a3", + "concepts": [ + "loops" + ], + "prerequisites": [ + "if-else-statements" + ], + "status": "beta" } ], "practice": [ @@ -1853,16 +1864,6 @@ "slug": "exceptions", "name": "Exceptions" }, - { - "uuid": "3a1f7a96-b4a5-43d3-99e2-7c248e74e6c8", - "slug": "foreach-loops", - "name": "For-Each Loops" - }, - { - "uuid": "b1bb63e6-4540-48fc-9d11-4ee72653484e", - "slug": "for-loops", - "name": "For Loops" - }, { "uuid": "7de03b7d-ed91-4699-b275-96a6ab2e441c", "slug": "generic-types", @@ -1883,6 +1884,11 @@ "slug": "lists", "name": "Lists" }, + { + "uuid": "b84a2119-71cc-46d0-af7f-32fe9a07d0e2", + "slug": "loops", + "name": "Loops" + }, { "uuid": "54118389-9c01-431b-a850-f47da498f845", "slug": "method-overloading", diff --git a/exercises/concept/making-the-grade/.docs/hints.md b/exercises/concept/making-the-grade/.docs/hints.md new file mode 100644 index 000000000..e69de29bb diff --git a/exercises/concept/making-the-grade/.docs/instructions.md b/exercises/concept/making-the-grade/.docs/instructions.md new file mode 100644 index 000000000..e69de29bb diff --git a/exercises/concept/making-the-grade/.docs/introduction.md b/exercises/concept/making-the-grade/.docs/introduction.md new file mode 100644 index 000000000..a26ae9fd1 --- /dev/null +++ b/exercises/concept/making-the-grade/.docs/introduction.md @@ -0,0 +1,180 @@ +# Introduction + +## Loops + +In Java there are four looping constructs, two that are condition centric: `while` and `do-while` and the other two are iteration centric: `for` and `for-each`. + +### For + +A for loop provides a mechanism to execute a group of statements repeatedly until some condition is met. + +```java +for (initialization; test; update) { + body; +} +``` + +The `initialization` sets an initial state for the loop and is executed exactly once at the start of the loop. +Typically it declares and assigns a variable used in the test expression and update statement. +For example: + +```java +int i = 1 +``` + +The `test` expression tests if the loop should end. +If it evaluates to `true`, the body and then the update expression will be executed. +If it evaluates to `false`, neither the body nor the update statement will be executed and execution resumes after the loop's closing bracket. +Typically it checks the variable assigned in the initialization block. +For example: + +```java +i <= 10 +``` + +After executing the loop body, the `update` expression is executed. +Typically it increments or decrements the loop variable by some value. +For example: + +```java +i++ +``` + +A `for` loop printing out the first four squares would look like this: + +```java +for (int i = 1; i <= 4; i++) { + System.out.println("square of " + i + " is " + i * i); +} +``` + +The output would be: + +```text +square of 1 is 1 +square of 2 is 4 +square of 3 is 9 +square of 4 is 16 +``` + +If iterating through every element in a collection, a `for-each` loop is preferred, but it can be done with a `for` loop like this: + +```java +for (int i = 0; i < array.length; i++) { + System.out.print(array[i]); +} +``` + +A `for` loop does have some advantages over a `for-each` loop: + +- You can start or stop at the index you want. +- You can use any (boolean) termination condition you want. +- You can skip elements by customizing the incrementing of the loop variable. +- You can process collections from back to front by counting down. +- You can use `for` loops in scenarios that do not involve collections. + +### For-each + +A for-each loop provides a mechanism for executing a block of code for each element in a collection. + +```java +for (declaration: collection) { + body; +} +``` + +The `declaration` declares the variable used to hold the values assigned from the collection. + +The `collection` is an array or collection holding the values that will be assigned to the loop variable. + +The `body` contains the statements that will be executed once for each value in the collection. + +For example: + +```java +char[] vowels = {'a', 'e', 'i', 'o', 'u'}; + +for(char vowel: vowels) { + System.out.println(vowel); +} +``` + +which outputs: + +```text +a +e +i +o +u +``` + +Generally a `for-each` loop is preferrable over a `for` loop for the following reasons: + +- A `for-each` loop is guaranteed to iterate over _all_ values. +- A `for-each` loop is more _declarative_ meaning the code is communicating _what_ it is doing, instead of _how_ it is doing it. +- A `for-each` loop is foolproof, whereas with `for` loops it is easy to have an off-by-one error (think of using `<` versus `<=`). +- A `for-each` loop works on all collection types, including those that do not support using an index to access elements (eg. a `Set`). + +### While + +The `while` loop continually executes a block of statements while a particular condition is true. + +```java +while (condition) { + body; +} +``` + +The `condition` It's a statement that can be true or false. As long as the condition is true, the loop keeps running. +The `body` it's the code that gets executed repeatedly until the condition becomes false. + +For example: + +```java +int counter = 1; + +while (counter <= 5) { + System.out.println(counter); + counter++; +} +``` + +which outputs: + +```text +1 +2 +3 +4 +5 +``` + +Generally good rule of thumb is to use a `while` loops when you don't know exactly how many times you need to loop beforehand. + +### Do-while + +As `while` loops `do-while` loops are condition centric loops, but unlike a regular `while` loop, a `do-while` loop guarantees that the code inside the loop will run at least once, no matter what. + +```java +do { + body; +} while (condition); +``` + +For example: + +```java +int counter = 1; + +do { + System.out.println(counter); + counter++; +} while (counter < 2); +``` + +which outputs: + +```text +1 +``` diff --git a/exercises/concept/making-the-grade/.docs/introduction.md.tpl b/exercises/concept/making-the-grade/.docs/introduction.md.tpl new file mode 100644 index 000000000..313a2f9d4 --- /dev/null +++ b/exercises/concept/making-the-grade/.docs/introduction.md.tpl @@ -0,0 +1,3 @@ +# Introduction + +%{concept:loops} diff --git a/exercises/concept/making-the-grade/build.gradle b/exercises/concept/making-the-grade/build.gradle new file mode 100644 index 000000000..d2eca9ec7 --- /dev/null +++ b/exercises/concept/making-the-grade/build.gradle @@ -0,0 +1,23 @@ +plugins { + id "java" +} + +repositories { + mavenCentral() +} + +dependencies { + testImplementation platform("org.junit:junit-bom:5.10.0") + testImplementation "org.junit.jupiter:junit-jupiter" + testImplementation "org.assertj:assertj-core:3.25.1" +} + +test { + useJUnitPlatform() + + testLogging { + exceptionFormat = "full" + showStandardStreams = true + events = ["passed", "failed", "skipped"] + } +} diff --git a/exercises/settings.gradle b/exercises/settings.gradle index 916d7dd7f..962bd3765 100644 --- a/exercises/settings.gradle +++ b/exercises/settings.gradle @@ -15,6 +15,7 @@ include 'concept:karls-languages' include 'concept:lasagna' include 'concept:log-levels' include 'concept:logs-logs-logs' +include 'concept:making-the-grade' include 'concept:need-for-speed' include 'concept:remote-control-competition' include 'concept:salary-calculator' From 2bfe1858a4c2df5bf324c696a713c04c5a0cd131 Mon Sep 17 00:00:00 2001 From: manumafe98 Date: Fri, 5 Apr 2024 13:20:58 -0300 Subject: [PATCH 02/15] Adding instructions for the exercise and structure of the concept --- config.json | 72 +++++++++---------- .../making-the-grade/.docs/instructions.md | 62 ++++++++++++++++ .../making-the-grade/.meta/config.json | 23 ++++++ .../concept/making-the-grade/.meta/design.md | 0 .../src/reference/java/MakingTheGrade.java | 3 + .../src/main/java/MakingTheGrade.java | 3 + .../src/test/java/MakingTheGradeTest.java | 3 + 7 files changed, 130 insertions(+), 36 deletions(-) create mode 100644 exercises/concept/making-the-grade/.meta/config.json create mode 100644 exercises/concept/making-the-grade/.meta/design.md create mode 100644 exercises/concept/making-the-grade/.meta/src/reference/java/MakingTheGrade.java create mode 100644 exercises/concept/making-the-grade/src/main/java/MakingTheGrade.java create mode 100644 exercises/concept/making-the-grade/src/test/java/MakingTheGradeTest.java diff --git a/config.json b/config.json index 8569e7090..61e57a843 100644 --- a/config.json +++ b/config.json @@ -64,8 +64,7 @@ "arrays" ], "prerequisites": [ - "if-else-statements", - "loops" + "if-else-statements" ], "status": "active" }, @@ -316,7 +315,8 @@ "loops" ], "prerequisites": [ - "if-else-statements" + "if-else-statements", + "lists" ], "status": "beta" } @@ -505,7 +505,7 @@ "uuid": "8e983ed2-62f7-439a-a144-fb8fdbdf4d30", "practices": [], "prerequisites": [ - "foreach-loops", + "loops", "strings" ], "difficulty": 2 @@ -516,7 +516,7 @@ "uuid": "c31bbc6d-bdcf-44f7-bf35-5f98752e38d0", "practices": [], "prerequisites": [ - "for-loops", + "loops", "strings" ], "difficulty": 3 @@ -548,7 +548,7 @@ "uuid": "ce899ca6-9cc7-47ba-b76f-1bbcf2630b76", "practices": [], "prerequisites": [ - "for-loops" + "loops" ], "difficulty": 3 }, @@ -700,7 +700,7 @@ "practices": [], "prerequisites": [ "chars", - "for-loops" + "loops" ], "difficulty": 4 }, @@ -711,7 +711,7 @@ "practices": [], "prerequisites": [ "if-else-statements", - "for-loops", + "loops", "strings" ], "difficulty": 4 @@ -746,7 +746,7 @@ "prerequisites": [ "chars", "numbers", - "for-loops" + "loops" ], "difficulty": 4 }, @@ -757,7 +757,7 @@ "practices": [], "prerequisites": [ "numbers", - "for-loops" + "loops" ], "difficulty": 4 }, @@ -779,7 +779,7 @@ "practices": [], "prerequisites": [ "exceptions", - "for-loops", + "loops", "if-else-statements", "numbers" ], @@ -791,7 +791,7 @@ "uuid": "9906491b-a638-408d-86a4-4ad320a92658", "practices": [], "prerequisites": [ - "for-loops", + "loops", "arrays" ], "difficulty": 4 @@ -804,7 +804,7 @@ "prerequisites": [ "chars", "if-else-statements", - "for-loops" + "loops" ], "difficulty": 4 }, @@ -857,7 +857,7 @@ "uuid": "581afdbb-dfb6-4dc5-9554-a025b5469a3c", "practices": [], "prerequisites": [ - "for-loops", + "loops", "arrays" ], "difficulty": 4 @@ -888,7 +888,7 @@ "uuid": "6a617ddb-04e3-451c-bb30-27ccd0be9125", "practices": [], "prerequisites": [ - "for-loops", + "loops", "enums", "bit-manipulation" ], @@ -901,7 +901,7 @@ "practices": [], "prerequisites": [ "chars", - "foreach-loops" + "loops" ], "difficulty": 5 }, @@ -966,7 +966,7 @@ "uuid": "85aa50ac-0141-49eb-bc6f-62f3f7a97647", "practices": [], "prerequisites": [ - "foreach-loops", + "loops", "strings" ], "difficulty": 5 @@ -978,7 +978,7 @@ "practices": [], "prerequisites": [ "if-else-statements", - "for-loops" + "loops" ], "difficulty": 5 }, @@ -1049,7 +1049,7 @@ "prerequisites": [ "chars", "if-else-statements", - "for-loops" + "loops" ], "difficulty": 5 }, @@ -1080,7 +1080,7 @@ "uuid": "3603b770-87a5-4758-91f3-b4d1f9075bc1", "practices": [], "prerequisites": [ - "for-loops", + "loops", "arrays" ], "difficulty": 5 @@ -1092,7 +1092,7 @@ "practices": [], "prerequisites": [ "arrays", - "for-loops", + "loops", "if-else-statements", "strings" ], @@ -1106,7 +1106,7 @@ "prerequisites": [ "chars", "exceptions", - "for-loops", + "loops", "if-else-statements", "numbers" ], @@ -1120,7 +1120,7 @@ "prerequisites": [ "arrays", "exceptions", - "for-loops", + "loops", "if-else-statements", "numbers" ], @@ -1182,7 +1182,7 @@ "uuid": "4b3f7771-c642-4278-a3d9-2fb958f26361", "practices": [], "prerequisites": [ - "for-loops", + "loops", "arrays" ], "difficulty": 6 @@ -1193,7 +1193,7 @@ "uuid": "76d28d97-75d3-47eb-bb77-3d347b76f1b6", "practices": [], "prerequisites": [ - "foreach-loops", + "loops", "strings" ], "difficulty": 6 @@ -1227,7 +1227,7 @@ "practices": [], "prerequisites": [ "strings", - "for-loops" + "loops" ], "difficulty": 6 }, @@ -1284,7 +1284,7 @@ "prerequisites": [ "arrays", "chars", - "foreach-loops", + "loops", "if-else-statements" ], "difficulty": 6 @@ -1328,7 +1328,7 @@ "uuid": "163fcc6b-c054-4232-a88b-0aded846a6eb", "practices": [], "prerequisites": [ - "for-loops", + "loops", "numbers" ], "difficulty": 6 @@ -1349,7 +1349,7 @@ "uuid": "57b76837-4610-466f-9373-d5c2697625f1", "practices": [], "prerequisites": [ - "for-loops", + "loops", "lists", "strings" ], @@ -1376,7 +1376,7 @@ "arrays", "if-else-statements", "lists", - "for-loops" + "loops" ], "difficulty": 7 }, @@ -1413,7 +1413,7 @@ "prerequisites": [ "chars", "constructors", - "for-loops", + "loops", "if-else-statements", "numbers" ], @@ -1484,7 +1484,7 @@ "chars", "if-else-statements", "lists", - "for-loops" + "loops" ], "difficulty": 7 }, @@ -1664,7 +1664,7 @@ "uuid": "1bac7473-9ee8-4cfc-928b-77792102ffc1", "practices": [], "prerequisites": [ - "for-loops", + "loops", "randomness", "strings" ], @@ -1690,7 +1690,7 @@ "practices": [], "prerequisites": [ "exceptions", - "for-loops", + "loops", "if-else-statements", "numbers" ], @@ -1705,7 +1705,7 @@ "strings", "if-else-statements", "lists", - "for-loops" + "loops" ], "difficulty": 8 }, @@ -1750,7 +1750,7 @@ "prerequisites": [ "chars", "exceptions", - "for-loops", + "loops", "if-else-statements", "numbers", "randomness" diff --git a/exercises/concept/making-the-grade/.docs/instructions.md b/exercises/concept/making-the-grade/.docs/instructions.md index e69de29bb..2cc7d655c 100644 --- a/exercises/concept/making-the-grade/.docs/instructions.md +++ b/exercises/concept/making-the-grade/.docs/instructions.md @@ -0,0 +1,62 @@ +# Instructions + +You're a teaching assistant correcting student exams. +Keeping track of results manually is getting both tedious and mistake-prone. +You decide to make things a little more interesting by putting together some functions to count and calculate results for the class. + +## 1. Non-Passing Students + +As you were grading the exam, you noticed some students weren't performing as well as you had hoped. +But you were distracted, and forgot to note exactly _how many_ students. + +Create the method `countFailedStudentd(List studentScores)` that takes a `List` of students scores. +This method should count up the number of students who don't have passing scores and return that count as an integer. +A student needs a score greater than **40** to achieve a passing grade on the exam. + +```java +MakingTheGrade.countFailedStudentd(List.of(40, 70, 80, 20, 39)); +// => 3 +``` + +## 2. Get the average of the first 10 graded exams + +As your second task of the day the professor asks you to get the average score of the first 10 students to handle the exam. + +Create the method `getAverageScoreOfTheFirstTenExams(List studentScores)` that takes a `List` of students scores. +This method should get the first 10 students sum their score and return the average of the sum as an integer. + +```java +MakingTheGrade.getAverageScoreOfTheFirstTenExams(List.of(40, 70, 80, 20, 39, 50, 100, 90, 66, 15, 79)); +// => 57 +``` + +## 3. Calculating letter grades + +The teacher you are assisting needs to handle a letter with the amount of students needed to score a maximum score of 95 to the principal of the school. +This letter has to have at least 1 student in it (if the first students alone exceeds the score should be added as well). +And if already one student was added to the letter do not exceed the maximum score. + +Create the method `MakingTheGrade.letterGrades(Map studentScores, int maxScore)` that takes a `Map` of students with their scores and a `int` that represents the maximum score to be achieved for the letter to be completed. +This method should return the list of students added to the letter. + +```java +MakingTheGrade.letterGrades(Map.of("Joci", 100, "Sara", 20, "Bern", 53, "Fred", 91)); +// => ["Joci"] + +MakingTheGrade.letterGrades(Map.of("Jan", 20, "Kora", 40, "Sara", 30, "Peter", 85)); +// => ["Jan", "Kora", "Sara"] +``` + +## 4. Matching Names to Scores + +You have a list of exam scores in descending order, and another list of student names also sorted in descending order by their exam scores. You would like to match each student name with their exam score and print out an overall class ranking. + +Create the method `studentRanking(List studentScores, List studentNames)` with parameters `List` of studentScores and `List` studentNames. Match each student name on the studentNames list with their score from the studentScores list. You can assume each argument list will be sorted from highest score(er) to lowest score(er). The function should return a list of strings with the format . : . + +```java +List studentScores = List.of(100, 99, 90, 84, 66, 53, 47); +List studentNames = List.of("Joci", "Sara", "Kora", "Jan", "John", "Bern", "Fred"); + +MakingTheGrade.studentRanking(studentScores, studentNames); +// => ["1. Joci: 100", "2. Sara: 99", "3. Kora: 90", "4. Jan: 84", "5. John: 66", "6. Bern: 53", "7. Fred: 47"] +``` diff --git a/exercises/concept/making-the-grade/.meta/config.json b/exercises/concept/making-the-grade/.meta/config.json new file mode 100644 index 000000000..d0898c0db --- /dev/null +++ b/exercises/concept/making-the-grade/.meta/config.json @@ -0,0 +1,23 @@ +{ + "authors": [ + "manumafe98" + ], + "files": { + "solution": [ + "src/main/java/MakingTheGrade.java" + ], + "test": [ + "src/test/java/MakingTheGradeTest.java" + ], + "exemplar": [ + ".meta/src/reference/java/MakingTheGrade.java" + ], + "invalidator": [ + "build.gradle" + ] + }, + "forked_from": [ + "python/making-the-grade" + ], + "blurb": "Learn to use different kinds of loops by automating the tasks of an assitant teacher." +} \ No newline at end of file diff --git a/exercises/concept/making-the-grade/.meta/design.md b/exercises/concept/making-the-grade/.meta/design.md new file mode 100644 index 000000000..e69de29bb diff --git a/exercises/concept/making-the-grade/.meta/src/reference/java/MakingTheGrade.java b/exercises/concept/making-the-grade/.meta/src/reference/java/MakingTheGrade.java new file mode 100644 index 000000000..49a08dc2b --- /dev/null +++ b/exercises/concept/making-the-grade/.meta/src/reference/java/MakingTheGrade.java @@ -0,0 +1,3 @@ +public class MakingTheGrade { + +} diff --git a/exercises/concept/making-the-grade/src/main/java/MakingTheGrade.java b/exercises/concept/making-the-grade/src/main/java/MakingTheGrade.java new file mode 100644 index 000000000..49a08dc2b --- /dev/null +++ b/exercises/concept/making-the-grade/src/main/java/MakingTheGrade.java @@ -0,0 +1,3 @@ +public class MakingTheGrade { + +} diff --git a/exercises/concept/making-the-grade/src/test/java/MakingTheGradeTest.java b/exercises/concept/making-the-grade/src/test/java/MakingTheGradeTest.java new file mode 100644 index 000000000..cf565db72 --- /dev/null +++ b/exercises/concept/making-the-grade/src/test/java/MakingTheGradeTest.java @@ -0,0 +1,3 @@ +public class MakingTheGradeTest { + +} From d4cc8c5609fab3afdd548fc0ae0258929791b22c Mon Sep 17 00:00:00 2001 From: manumafe98 Date: Fri, 5 Apr 2024 14:34:54 -0300 Subject: [PATCH 03/15] Adding design.md content Adding reference resolution Making small updates to instructions Adding blueprint to give to students --- .../making-the-grade/.docs/instructions.md | 22 ++++---- .../concept/making-the-grade/.meta/design.md | 38 ++++++++++++++ .../src/reference/java/MakingTheGrade.java | 51 ++++++++++++++++++- .../src/main/java/MakingTheGrade.java | 19 ++++++- 4 files changed, 116 insertions(+), 14 deletions(-) diff --git a/exercises/concept/making-the-grade/.docs/instructions.md b/exercises/concept/making-the-grade/.docs/instructions.md index 2cc7d655c..b0396f97e 100644 --- a/exercises/concept/making-the-grade/.docs/instructions.md +++ b/exercises/concept/making-the-grade/.docs/instructions.md @@ -9,41 +9,39 @@ You decide to make things a little more interesting by putting together some fun As you were grading the exam, you noticed some students weren't performing as well as you had hoped. But you were distracted, and forgot to note exactly _how many_ students. -Create the method `countFailedStudentd(List studentScores)` that takes a `List` of students scores. +Create the method `countFailedStudents(List studentScores)` that takes a `List` of students scores. This method should count up the number of students who don't have passing scores and return that count as an integer. A student needs a score greater than **40** to achieve a passing grade on the exam. ```java -MakingTheGrade.countFailedStudentd(List.of(40, 70, 80, 20, 39)); +MakingTheGrade.countFailedStudents(List.of(40, 70, 80, 20, 39)); // => 3 ``` -## 2. Get the average of the first 10 graded exams +## 2. Get the average grade of students -As your second task of the day the professor asks you to get the average score of the first 10 students to handle the exam. +As your second task of the day the professor asks you to get the average score of a certain number of students. -Create the method `getAverageScoreOfTheFirstTenExams(List studentScores)` that takes a `List` of students scores. -This method should get the first 10 students sum their score and return the average of the sum as an integer. +Create the method `getAverageScoreOfStudents(List studentScores, int numberOfStudents)` that takes a `List` of studentScores and a `int` of numberOfStudents. This method should get the average score of the number of students passed. numberOfStudents it's guaranteed to be lower than the size of the list of scores. ```java -MakingTheGrade.getAverageScoreOfTheFirstTenExams(List.of(40, 70, 80, 20, 39, 50, 100, 90, 66, 15, 79)); +MakingTheGrade.getAverageScoreOfStudents(List.of(40, 70, 80, 20, 39, 50, 100, 90, 66, 15, 79), 10); // => 57 ``` ## 3. Calculating letter grades -The teacher you are assisting needs to handle a letter with the amount of students needed to score a maximum score of 95 to the principal of the school. +The teacher you are assisting needs to handle a letter with the amount of students needed to sum a score of 95 to the principal of the school. This letter has to have at least 1 student in it (if the first students alone exceeds the score should be added as well). And if already one student was added to the letter do not exceed the maximum score. -Create the method `MakingTheGrade.letterGrades(Map studentScores, int maxScore)` that takes a `Map` of students with their scores and a `int` that represents the maximum score to be achieved for the letter to be completed. -This method should return the list of students added to the letter. +Create the method `MakingTheGrade.letterGrades(List studentScores, List studentNames)` that takes a `List studentScores` of students scores and `List studentNames` corresponding with the names of the students. This method should return the list of students added to the letter. ```java -MakingTheGrade.letterGrades(Map.of("Joci", 100, "Sara", 20, "Bern", 53, "Fred", 91)); +MakingTheGrade.letterGrades(List.of(100, 20, 53, 91), List.of("Joci", "Sara", "Bern", "Fred")); // => ["Joci"] -MakingTheGrade.letterGrades(Map.of("Jan", 20, "Kora", 40, "Sara", 30, "Peter", 85)); +MakingTheGrade.letterGrades(List.of(20, 40, 30, 85), List.of("Jan", "Kora", "Sara", "Peter")); // => ["Jan", "Kora", "Sara"] ``` diff --git a/exercises/concept/making-the-grade/.meta/design.md b/exercises/concept/making-the-grade/.meta/design.md index e69de29bb..8a3a708b9 100644 --- a/exercises/concept/making-the-grade/.meta/design.md +++ b/exercises/concept/making-the-grade/.meta/design.md @@ -0,0 +1,38 @@ +# Design + +## Learning objectives + +- Know how to repeteadly execute code using a `for` loop.´ +- Know how to repeteadly execute code using a `for-each` loop. +- Know how to repeteadly execute code using a `while` loop. +- Know how to repeteadly execute code using a `do-while` loop. + +## Out of scope + +- Specific iteration over a `Map` + +## Concepts + +- `loops` + +## Prerequisites + +This exercise's prerequisites Concepts are: + +- `lists` +- `if-else-statements` + +## Analyzer + +This exercise could benefit from the following rules in the [analyzer]: + +- `essential`: If the student did not use a `for-each` loop in the `countFailedStudents` method, instruct them to do so. +- `essential`: If the student did not use a `while` loop in the `getAverageScoreOfStudents` method, instruct them to do so. +- `essential`: If the student did not use a `do-while` loop in the `letterGrades` method, instruct them to do so. +- `essential`: If the student did not use a `for` loop in the `studentRanking` method, instruct them to do so. +- `informative`: If the solution uses `String.format` in the `studentRanking` method, inform the student that this cause a small performance penalty compared to string concatenation. + +If the solution does not receive any of the listed feedback, it must be exemplar. +Leave a `celebratory` comment to celebrate the success! + +[analyzer]: https://github.com/exercism/java-analyzer diff --git a/exercises/concept/making-the-grade/.meta/src/reference/java/MakingTheGrade.java b/exercises/concept/making-the-grade/.meta/src/reference/java/MakingTheGrade.java index 49a08dc2b..04a65aeb9 100644 --- a/exercises/concept/making-the-grade/.meta/src/reference/java/MakingTheGrade.java +++ b/exercises/concept/making-the-grade/.meta/src/reference/java/MakingTheGrade.java @@ -1,3 +1,52 @@ -public class MakingTheGrade { +import java.util.List; +import java.util.ArrayList; + +class MakingTheGrade { + + static int countFailedStudents(List studentScores) { + int count = 0; + + for (int score : studentScores) { + if (score <= 40) { + count++; + } + } + + return count; + } + + static int getAverageScoreOfStudents(List studentScores, int numberOfStudents) { + int count = 0; + int sum = 0; + + while (count < numberOfStudents) { + sum += studentScores.get(count); + count++; + } + + return sum / numberOfStudents; + } + + static List letterGrades(List studentScores, List studentNames) { + List letter = new ArrayList<>(); + int sum = 0; + int count = 0; + + do { + sum += studentScores.get(count); + letter.add(studentNames.get(count)); + count++; + } while (sum < 95); + } + static List studentRanking(List studentScores, List studentNames) { + List ranking = new ArrayList<>(); + + for (int i = 0; i < studentScores.size(); i++) { + String student = String.valueOf(i) + ". " + studentNames.get(i) + ": " + String.valueOf(studentScores.get(i)); + ranking.add(student); + } + + return ranking; + } } diff --git a/exercises/concept/making-the-grade/src/main/java/MakingTheGrade.java b/exercises/concept/making-the-grade/src/main/java/MakingTheGrade.java index 49a08dc2b..2b4ccaa53 100644 --- a/exercises/concept/making-the-grade/src/main/java/MakingTheGrade.java +++ b/exercises/concept/making-the-grade/src/main/java/MakingTheGrade.java @@ -1,3 +1,20 @@ -public class MakingTheGrade { +import java.util.List; + +class MakingTheGrade { + + static int countFailedStudents(List studentScores) { + throw new UnsupportedOperationException("Please implement the (static) MakingTheGrade.countFailedStudents() method"); + } + + static int getAverageScoreOfStudents(List studentScores, int numberOfStudents) { + throw new UnsupportedOperationException("Please implement the (static) MakingTheGrade.getAverageScoreOfStudents() method"); + } + + static List letterGrades(List studentScores, List studentNames) { + throw new UnsupportedOperationException("Please implement the (static) MakingTheGrade.letterGrades() method"); + } + static List studentRanking(List studentScores, List studentNames) { + throw new UnsupportedOperationException("Please implement the (static) MakingTheGrade.studentRanking() method"); + } } From 799fa606e1cbfd82ac3d5167803c8fd55eb2c6d5 Mon Sep 17 00:00:00 2001 From: manumafe98 Date: Fri, 5 Apr 2024 17:11:28 -0300 Subject: [PATCH 04/15] Adding hints, tests and updating reference resolution to fix some issues --- .../concept/making-the-grade/.docs/hints.md | 17 +++ .../src/reference/java/MakingTheGrade.java | 8 +- .../src/test/java/MakingTheGradeTest.java | 129 +++++++++++++++++- 3 files changed, 151 insertions(+), 3 deletions(-) diff --git a/exercises/concept/making-the-grade/.docs/hints.md b/exercises/concept/making-the-grade/.docs/hints.md index e69de29bb..794533d57 100644 --- a/exercises/concept/making-the-grade/.docs/hints.md +++ b/exercises/concept/making-the-grade/.docs/hints.md @@ -0,0 +1,17 @@ +# Hints + +## 1. Non-Passing Students + +- Try using one of the loops that is iteration centric. + +## 2. Get the average grade of students + +- Try using one of the loops that is condition centric using numberOfStudents as one of the core conditions. + +## 3. Calculating letter grades + +- Remember that there is a condition centric loop that guarantees the body to be executed at least once. + +## 4. Matching Names to Scores + +- Try using a iteration centric loop that allow you to work with indexes. diff --git a/exercises/concept/making-the-grade/.meta/src/reference/java/MakingTheGrade.java b/exercises/concept/making-the-grade/.meta/src/reference/java/MakingTheGrade.java index 04a65aeb9..8755f797b 100644 --- a/exercises/concept/making-the-grade/.meta/src/reference/java/MakingTheGrade.java +++ b/exercises/concept/making-the-grade/.meta/src/reference/java/MakingTheGrade.java @@ -36,14 +36,18 @@ static List letterGrades(List studentScores, List stude sum += studentScores.get(count); letter.add(studentNames.get(count)); count++; - } while (sum < 95); + } while (sum + studentScores.get(count) < 95); + + return letter; } static List studentRanking(List studentScores, List studentNames) { List ranking = new ArrayList<>(); for (int i = 0; i < studentScores.size(); i++) { - String student = String.valueOf(i) + ". " + studentNames.get(i) + ": " + String.valueOf(studentScores.get(i)); + String student = String.valueOf(i + 1) + ". " + studentNames.get(i) + ": " + + String.valueOf(studentScores.get(i)); + ranking.add(student); } diff --git a/exercises/concept/making-the-grade/src/test/java/MakingTheGradeTest.java b/exercises/concept/making-the-grade/src/test/java/MakingTheGradeTest.java index cf565db72..ff7a946bb 100644 --- a/exercises/concept/making-the-grade/src/test/java/MakingTheGradeTest.java +++ b/exercises/concept/making-the-grade/src/test/java/MakingTheGradeTest.java @@ -1,3 +1,130 @@ -public class MakingTheGradeTest { +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; + +import java.util.List; + +import static org.assertj.core.api.Assertions.assertThat; + +class MakingTheGradeTest { + @Test + @Tag("task:1") + @DisplayName("All students scored above 40") + void testAllStudentsScoredAbove40() { + assertThat(MakingTheGrade.countFailedStudents(List.of(50, 60, 70, 80, 90, 100))).isEqualTo(0); + } + + @Test + @Tag("task:1") + @DisplayName("One student failed the exam") + void testOneStudentFailedTheExam() { + assertThat(MakingTheGrade.countFailedStudents(List.of(39, 100, 90, 96, 73))).isEqualTo(1); + } + + @Test + @Tag("task:1") + @DisplayName("Multiple students failed the exam") + void testMultipleStudentsFailedTheExam() { + assertThat(MakingTheGrade.countFailedStudents(List.of(20, 10, 15, 35, 50, 60, 85))).isEqualTo(4); + } + + @Test + @Tag("task:2") + @DisplayName("Getting the average of 10 students") + void testGettingTheAverageOf10Students() { + assertThat( + MakingTheGrade.getAverageScoreOfStudents(List.of(40, 70, 80, 20, 39, 50, 100, 90, 66, 15, 79), 10) + ).isEqualTo(57); + } + + @Test + @Tag("task:2") + @DisplayName("Getting the average of 5 students, with multiple failed scores") + void testGettingTheAverageOf5StudentsWithMultipleFailedScores() { + assertThat( + MakingTheGrade.getAverageScoreOfStudents(List.of(33, 22, 11, 20, 39, 90, 100, 90, 95, 87, 75, 74, 13), 5) + ).isEqualTo(25); + } + + @Test + @Tag("task:2") + @DisplayName("Getting the average of 7 students, without failed scores") + void testGettingTheAverageOf7StudentsWithoutFailedScores() { + assertThat( + MakingTheGrade.getAverageScoreOfStudents(List.of(70, 60, 65, 55, 95, 100, 80, 70, 20, 30, 15, 100, 50), 7) + ).isEqualTo(75); + } + + @Test + @Tag("task:3") + @DisplayName("First student exceeds the score limit for the letter") + void testFirstStudentExceedTheScoreForTheLetter() { + assertThat( + MakingTheGrade.letterGrades( + List.of(100, 20, 53, 91), + List.of("Joci", "Sara", "Bern", "Fred")) + ).isEqualTo(List.of("Joci")); + } + + @Test + @Tag("task:3") + @DisplayName("The sum of the scores of the first three students are lower than 95") + void testSumOfFirstThreeStudentsLowerThan95() { + assertThat( + MakingTheGrade.letterGrades( + List.of(20, 40, 30, 85), + List.of("Jan", "Kora", "Sara", "Peter")) + ).isEqualTo(List.of("Jan", "Kora", "Sara")); + } + + @Test + @Tag("task:3") + @DisplayName("The sum of the scores of the first two students exceed 95") + void testSumOfFirstTwoStudentsExceed95() { + assertThat( + MakingTheGrade.letterGrades( + List.of(50, 46, 100, 15), + List.of("Cole", "Mason", "Enzo", "Connor")) + ).isEqualTo(List.of("Cole")); + } + + @Test + @Tag("task:4") + @DisplayName("Creating an all exceeded students ranking") + void testAllStudentsExceededRanking() { + List answer = List.of( + "1. Joci: 100", "2. Sara: 99", "3. Kora: 90", + "4. Jan: 84", "5. John: 66", "6. Bern: 53", "7. Fred: 47"); + + assertThat( + MakingTheGrade.studentRanking( + List.of(100, 99, 90, 84, 66, 53, 47), + List.of("Joci", "Sara", "Kora", "Jan", "John", "Bern", "Fred")) + ).isEqualTo(answer); + } + + @Test + @Tag("task:4") + @DisplayName("Creating an all failed students ranking") + void testAllStudentsFailedRanking() { + List answer = List.of( + "1. Kai: 35", "2. Kevin: 30", "3. Erling: 29", "4. Jude: 26", + "5. Benjamin: 19", "6. Malo: 13", "7. Moises: 5"); + + assertThat( + MakingTheGrade.studentRanking( + List.of(35, 30, 29, 26, 19, 13, 5), + List.of("Kai", "Kevin", "Erling", "Jude", "Benjamin", "Malo", "Moises")) + ).isEqualTo(answer); + } + + @Test + @Tag("task:4") + @DisplayName("Giving empty students and score lists") + void testEmptyLists() { + assertThat( + MakingTheGrade.studentRanking(List.of(),List.of()) + ).isEqualTo(List.of()); + } } From c562a88aa004f8400730adcbb34a7b041d7d08ef Mon Sep 17 00:00:00 2001 From: manumafe98 Date: Fri, 5 Apr 2024 17:35:18 -0300 Subject: [PATCH 05/15] Fixing checkstyle error, adding gradle wrappers and adding missing whitespace to config.json --- .../making-the-grade/.meta/config.json | 2 +- .../gradle/wrapper/gradle-wrapper.jar | Bin 0 -> 43453 bytes .../gradle/wrapper/gradle-wrapper.properties | 6 + exercises/concept/making-the-grade/gradlew | 249 ++++++++++++++++++ .../concept/making-the-grade/gradlew.bat | 92 +++++++ .../src/test/java/MakingTheGradeTest.java | 2 +- 6 files changed, 349 insertions(+), 2 deletions(-) create mode 100644 exercises/concept/making-the-grade/gradle/wrapper/gradle-wrapper.jar create mode 100644 exercises/concept/making-the-grade/gradle/wrapper/gradle-wrapper.properties create mode 100644 exercises/concept/making-the-grade/gradlew create mode 100644 exercises/concept/making-the-grade/gradlew.bat diff --git a/exercises/concept/making-the-grade/.meta/config.json b/exercises/concept/making-the-grade/.meta/config.json index d0898c0db..e2456d9a6 100644 --- a/exercises/concept/making-the-grade/.meta/config.json +++ b/exercises/concept/making-the-grade/.meta/config.json @@ -20,4 +20,4 @@ "python/making-the-grade" ], "blurb": "Learn to use different kinds of loops by automating the tasks of an assitant teacher." -} \ No newline at end of file +} diff --git a/exercises/concept/making-the-grade/gradle/wrapper/gradle-wrapper.jar b/exercises/concept/making-the-grade/gradle/wrapper/gradle-wrapper.jar new file mode 100644 index 0000000000000000000000000000000000000000..e6441136f3d4ba8a0da8d277868979cfbc8ad796 GIT binary patch literal 43453 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 yu?e%!_ptzGB|8GrCfu%p?(_ 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
NnX)EH+Nua)3Y(c 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 '} + case $link in #( + /*) app_path=$link ;; #( + *) app_path=$APP_HOME$link ;; + esac +done + +# This is normally unused +# shellcheck disable=SC2034 +APP_BASE_NAME=${0##*/} +# Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036) +APP_HOME=$( cd "${APP_HOME:-./}" > /dev/null && pwd -P ) || exit + +# Use the maximum available, or set MAX_FD != -1 to use that value. +MAX_FD=maximum + +warn () { + echo "$*" +} >&2 + +die () { + echo + echo "$*" + echo + exit 1 +} >&2 + +# OS specific support (must be 'true' or 'false'). +cygwin=false +msys=false +darwin=false +nonstop=false +case "$( uname )" in #( + CYGWIN* ) cygwin=true ;; #( + Darwin* ) darwin=true ;; #( + MSYS* | MINGW* ) msys=true ;; #( + NONSTOP* ) nonstop=true ;; +esac + +CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar + + +# Determine the Java command to use to start the JVM. +if [ -n "$JAVA_HOME" ] ; then + if [ -x "$JAVA_HOME/jre/sh/java" ] ; then + # IBM's JDK on AIX uses strange locations for the executables + JAVACMD=$JAVA_HOME/jre/sh/java + else + JAVACMD=$JAVA_HOME/bin/java + fi + if [ ! -x "$JAVACMD" ] ; then + die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME + +Please set the JAVA_HOME variable in your environment to match the +location of your Java installation." + fi +else + JAVACMD=java + if ! command -v java >/dev/null 2>&1 + then + die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. + +Please set the JAVA_HOME variable in your environment to match the +location of your Java installation." + fi +fi + +# Increase the maximum file descriptors if we can. +if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then + case $MAX_FD in #( + max*) + # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked. + # shellcheck disable=SC2039,SC3045 + MAX_FD=$( ulimit -H -n ) || + warn "Could not query maximum file descriptor limit" + esac + case $MAX_FD in #( + '' | soft) :;; #( + *) + # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked. + # shellcheck disable=SC2039,SC3045 + ulimit -n "$MAX_FD" || + warn "Could not set maximum file descriptor limit to $MAX_FD" + esac +fi + +# Collect all arguments for the java command, stacking in reverse order: +# * args from the command line +# * the main class name +# * -classpath +# * -D...appname settings +# * --module-path (only if needed) +# * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables. + +# For Cygwin or MSYS, switch paths to Windows format before running java +if "$cygwin" || "$msys" ; then + APP_HOME=$( cygpath --path --mixed "$APP_HOME" ) + CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" ) + + JAVACMD=$( cygpath --unix "$JAVACMD" ) + + # Now convert the arguments - kludge to limit ourselves to /bin/sh + for arg do + if + case $arg in #( + -*) false ;; # don't mess with options #( + /?*) t=${arg#/} t=/${t%%/*} # looks like a POSIX filepath + [ -e "$t" ] ;; #( + *) false ;; + esac + then + arg=$( cygpath --path --ignore --mixed "$arg" ) + fi + # Roll the args list around exactly as many times as the number of + # args, so each arg winds up back in the position where it started, but + # possibly modified. + # + # NB: a `for` loop captures its iteration list before it begins, so + # changing the positional parameters here affects neither the number of + # iterations, nor the values presented in `arg`. + shift # remove old arg + set -- "$@" "$arg" # push replacement arg + done +fi + + +# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. +DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"' + +# Collect all arguments for the java command: +# * DEFAULT_JVM_OPTS, JAVA_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments, +# and any embedded shellness will be escaped. +# * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be +# treated as '${Hostname}' itself on the command line. + +set -- \ + "-Dorg.gradle.appname=$APP_BASE_NAME" \ + -classpath "$CLASSPATH" \ + org.gradle.wrapper.GradleWrapperMain \ + "$@" + +# Stop when "xargs" is not available. +if ! command -v xargs >/dev/null 2>&1 +then + die "xargs is not available" +fi + +# Use "xargs" to parse quoted args. +# +# With -n1 it outputs one arg per line, with the quotes and backslashes removed. +# +# In Bash we could simply go: +# +# readarray ARGS < <( xargs -n1 <<<"$var" ) && +# set -- "${ARGS[@]}" "$@" +# +# but POSIX shell has neither arrays nor command substitution, so instead we +# post-process each arg (as a line of input to sed) to backslash-escape any +# character that might be a shell metacharacter, then use eval to reverse +# that process (while maintaining the separation between arguments), and wrap +# the whole thing up as a single "set" statement. +# +# This will of course break if any of these variables contains a newline or +# an unmatched quote. +# + +eval "set -- $( + printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" | + xargs -n1 | + sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' | + tr '\n' ' ' + )" '"$@"' + +exec "$JAVACMD" "$@" diff --git a/exercises/concept/making-the-grade/gradlew.bat b/exercises/concept/making-the-grade/gradlew.bat new file mode 100644 index 000000000..25da30dbd --- /dev/null +++ b/exercises/concept/making-the-grade/gradlew.bat @@ -0,0 +1,92 @@ +@rem +@rem Copyright 2015 the original author or authors. +@rem +@rem Licensed under the Apache License, Version 2.0 (the "License"); +@rem you may not use this file except in compliance with the License. +@rem You may obtain a copy of the License at +@rem +@rem https://www.apache.org/licenses/LICENSE-2.0 +@rem +@rem Unless required by applicable law or agreed to in writing, software +@rem distributed under the License is distributed on an "AS IS" BASIS, +@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +@rem See the License for the specific language governing permissions and +@rem limitations under the License. +@rem + +@if "%DEBUG%"=="" @echo off +@rem ########################################################################## +@rem +@rem Gradle startup script for Windows +@rem +@rem ########################################################################## + +@rem Set local scope for the variables with windows NT shell +if "%OS%"=="Windows_NT" setlocal + +set DIRNAME=%~dp0 +if "%DIRNAME%"=="" set DIRNAME=. +@rem This is normally unused +set APP_BASE_NAME=%~n0 +set APP_HOME=%DIRNAME% + +@rem Resolve any "." and ".." in APP_HOME to make it shorter. +for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi + +@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. +set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m" + +@rem Find java.exe +if defined JAVA_HOME goto findJavaFromJavaHome + +set JAVA_EXE=java.exe +%JAVA_EXE% -version >NUL 2>&1 +if %ERRORLEVEL% equ 0 goto execute + +echo. 1>&2 +echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 1>&2 +echo. 1>&2 +echo Please set the JAVA_HOME variable in your environment to match the 1>&2 +echo location of your Java installation. 1>&2 + +goto fail + +:findJavaFromJavaHome +set JAVA_HOME=%JAVA_HOME:"=% +set JAVA_EXE=%JAVA_HOME%/bin/java.exe + +if exist "%JAVA_EXE%" goto execute + +echo. 1>&2 +echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 1>&2 +echo. 1>&2 +echo Please set the JAVA_HOME variable in your environment to match the 1>&2 +echo location of your Java installation. 1>&2 + +goto fail + +:execute +@rem Setup the command line + +set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar + + +@rem Execute Gradle +"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %* + +:end +@rem End local scope for the variables with windows NT shell +if %ERRORLEVEL% equ 0 goto mainEnd + +:fail +rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of +rem the _cmd.exe /c_ return code! +set EXIT_CODE=%ERRORLEVEL% +if %EXIT_CODE% equ 0 set EXIT_CODE=1 +if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE% +exit /b %EXIT_CODE% + +:mainEnd +if "%OS%"=="Windows_NT" endlocal + +:omega diff --git a/exercises/concept/making-the-grade/src/test/java/MakingTheGradeTest.java b/exercises/concept/making-the-grade/src/test/java/MakingTheGradeTest.java index ff7a946bb..819f9cf97 100644 --- a/exercises/concept/making-the-grade/src/test/java/MakingTheGradeTest.java +++ b/exercises/concept/making-the-grade/src/test/java/MakingTheGradeTest.java @@ -124,7 +124,7 @@ void testAllStudentsFailedRanking() { @DisplayName("Giving empty students and score lists") void testEmptyLists() { assertThat( - MakingTheGrade.studentRanking(List.of(),List.of()) + MakingTheGrade.studentRanking(List.of(), List.of()) ).isEqualTo(List.of()); } } From 6d6c4bb0e6b9b75443bb960ae20b049683bbd38d Mon Sep 17 00:00:00 2001 From: Manuel Maxera <95315128+manumafe98@users.noreply.github.com> Date: Fri, 26 Apr 2024 17:28:56 -0300 Subject: [PATCH 06/15] Update exercises/concept/making-the-grade/.docs/hints.md Co-authored-by: Sander Ploegsma --- exercises/concept/making-the-grade/.docs/hints.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/exercises/concept/making-the-grade/.docs/hints.md b/exercises/concept/making-the-grade/.docs/hints.md index 794533d57..784daa442 100644 --- a/exercises/concept/making-the-grade/.docs/hints.md +++ b/exercises/concept/making-the-grade/.docs/hints.md @@ -6,7 +6,7 @@ ## 2. Get the average grade of students -- Try using one of the loops that is condition centric using numberOfStudents as one of the core conditions. +- Try using one of the loops that is condition centric using `numberOfStudents` as one of the core conditions. ## 3. Calculating letter grades From 1050cbc8fa84fd444629cd81ca5d77530d4cf254 Mon Sep 17 00:00:00 2001 From: Manuel Maxera <95315128+manumafe98@users.noreply.github.com> Date: Fri, 26 Apr 2024 17:29:09 -0300 Subject: [PATCH 07/15] Update concepts/loops/about.md Co-authored-by: Sander Ploegsma --- concepts/loops/about.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/concepts/loops/about.md b/concepts/loops/about.md index 61006051c..a47a70c8b 100644 --- a/concepts/loops/about.md +++ b/concepts/loops/about.md @@ -55,7 +55,7 @@ square of 3 is 9 square of 4 is 16 ``` -If iterating through every element in a collection, a `for-each` loop is preferred, but it can be done with a `for` loop like this: +Iterating through every element in a collection is usually performed using a `for-each`, but it can be done with a `for` loop like this: ```java for (int i = 0; i < array.length; i++) { From 5f81a4ffbada9cd16e5597d08fed2eb3a408089d Mon Sep 17 00:00:00 2001 From: Manuel Maxera <95315128+manumafe98@users.noreply.github.com> Date: Fri, 26 Apr 2024 17:29:21 -0300 Subject: [PATCH 08/15] Update exercises/concept/making-the-grade/.meta/config.json Co-authored-by: Sander Ploegsma --- exercises/concept/making-the-grade/.meta/config.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/exercises/concept/making-the-grade/.meta/config.json b/exercises/concept/making-the-grade/.meta/config.json index e2456d9a6..005357cc8 100644 --- a/exercises/concept/making-the-grade/.meta/config.json +++ b/exercises/concept/making-the-grade/.meta/config.json @@ -19,5 +19,5 @@ "forked_from": [ "python/making-the-grade" ], - "blurb": "Learn to use different kinds of loops by automating the tasks of an assitant teacher." + "blurb": "Learn to use different kinds of loops by automating the tasks of an assistant teacher." } From 4020fde28576e0a6d80cf81b6a57a0c5cba72fb7 Mon Sep 17 00:00:00 2001 From: Manuel Maxera <95315128+manumafe98@users.noreply.github.com> Date: Fri, 26 Apr 2024 17:29:30 -0300 Subject: [PATCH 09/15] Update exercises/concept/making-the-grade/.docs/instructions.md Co-authored-by: Sander Ploegsma --- exercises/concept/making-the-grade/.docs/instructions.md | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/exercises/concept/making-the-grade/.docs/instructions.md b/exercises/concept/making-the-grade/.docs/instructions.md index b0396f97e..72a9d6f8f 100644 --- a/exercises/concept/making-the-grade/.docs/instructions.md +++ b/exercises/concept/making-the-grade/.docs/instructions.md @@ -22,7 +22,9 @@ MakingTheGrade.countFailedStudents(List.of(40, 70, 80, 20, 39)); As your second task of the day the professor asks you to get the average score of a certain number of students. -Create the method `getAverageScoreOfStudents(List studentScores, int numberOfStudents)` that takes a `List` of studentScores and a `int` of numberOfStudents. This method should get the average score of the number of students passed. numberOfStudents it's guaranteed to be lower than the size of the list of scores. +Create the method `getAverageScoreOfStudents(List studentScores, int numberOfStudents)` that takes a `List` of studentScores and a `int` of numberOfStudents. +This method should get the average score of the number of students passed. +The number of students is guaranteed to be lower than the size of the list of scores. ```java MakingTheGrade.getAverageScoreOfStudents(List.of(40, 70, 80, 20, 39, 50, 100, 90, 66, 15, 79), 10); From 7f0a64dd965564717026f5a3db407d74860a7594 Mon Sep 17 00:00:00 2001 From: manumafe98 Date: Fri, 26 Apr 2024 17:40:47 -0300 Subject: [PATCH 10/15] Re ordering the topic presentation sentence to match the order the topics were introduced Adding links to the corresponding headings topics --- concepts/loops/about.md | 7 ++++++- concepts/loops/introduction.md | 9 +++++++-- .../making-the-grade/.docs/introduction.md | 19 +++++++++++-------- 3 files changed, 24 insertions(+), 11 deletions(-) diff --git a/concepts/loops/about.md b/concepts/loops/about.md index a47a70c8b..632fbe5d1 100644 --- a/concepts/loops/about.md +++ b/concepts/loops/about.md @@ -1,6 +1,6 @@ # About -In Java there are four looping constructs, two that are condition centric: `while` and `do-while` and the other two are iteration centric: `for` and `for-each`. +In Java there are four looping constructs, two that are iteration centric: [`For`] and [`For-each`] and the other two are condition centric: [`While`] and [`Do-while`]. ## For @@ -176,3 +176,8 @@ which outputs: ```text 1 ``` + +[`For`]: #for +[`For-each`]: #for-each +[`While`]: #while +[`Do-while`]: #do-while diff --git a/concepts/loops/introduction.md b/concepts/loops/introduction.md index 144755dc6..0379d888d 100644 --- a/concepts/loops/introduction.md +++ b/concepts/loops/introduction.md @@ -1,6 +1,6 @@ # Introduction -In Java there are four looping constructs, two that are condition centric: `while` and `do-while` and the other two are iteration centric: `for` and `for-each`. +In Java there are four looping constructs, two that are iteration centric: [`For`] and [`For-each`] and the other two are condition centric: [`While`] and [`Do-while`]. ## For @@ -55,7 +55,7 @@ square of 3 is 9 square of 4 is 16 ``` -If iterating through every element in a collection, a `for-each` loop is preferred, but it can be done with a `for` loop like this: +Iterating through every element in a collection is usually performed using a `for-each`, but it can be done with a `for` loop like this: ```java for (int i = 0; i < array.length; i++) { @@ -176,3 +176,8 @@ which outputs: ```text 1 ``` + +[`For`]: #for +[`For-each`]: #for-each +[`While`]: #while +[`Do-while`]: #do-while diff --git a/exercises/concept/making-the-grade/.docs/introduction.md b/exercises/concept/making-the-grade/.docs/introduction.md index a26ae9fd1..0379d888d 100644 --- a/exercises/concept/making-the-grade/.docs/introduction.md +++ b/exercises/concept/making-the-grade/.docs/introduction.md @@ -1,10 +1,8 @@ # Introduction -## Loops +In Java there are four looping constructs, two that are iteration centric: [`For`] and [`For-each`] and the other two are condition centric: [`While`] and [`Do-while`]. -In Java there are four looping constructs, two that are condition centric: `while` and `do-while` and the other two are iteration centric: `for` and `for-each`. - -### For +## For A for loop provides a mechanism to execute a group of statements repeatedly until some condition is met. @@ -57,7 +55,7 @@ square of 3 is 9 square of 4 is 16 ``` -If iterating through every element in a collection, a `for-each` loop is preferred, but it can be done with a `for` loop like this: +Iterating through every element in a collection is usually performed using a `for-each`, but it can be done with a `for` loop like this: ```java for (int i = 0; i < array.length; i++) { @@ -73,7 +71,7 @@ A `for` loop does have some advantages over a `for-each` loop: - You can process collections from back to front by counting down. - You can use `for` loops in scenarios that do not involve collections. -### For-each +## For-each A for-each loop provides a mechanism for executing a block of code for each element in a collection. @@ -116,7 +114,7 @@ Generally a `for-each` loop is preferrable over a `for` loop for the following r - A `for-each` loop is foolproof, whereas with `for` loops it is easy to have an off-by-one error (think of using `<` versus `<=`). - A `for-each` loop works on all collection types, including those that do not support using an index to access elements (eg. a `Set`). -### While +## While The `while` loop continually executes a block of statements while a particular condition is true. @@ -152,7 +150,7 @@ which outputs: Generally good rule of thumb is to use a `while` loops when you don't know exactly how many times you need to loop beforehand. -### Do-while +## Do-while As `while` loops `do-while` loops are condition centric loops, but unlike a regular `while` loop, a `do-while` loop guarantees that the code inside the loop will run at least once, no matter what. @@ -178,3 +176,8 @@ which outputs: ```text 1 ``` + +[`For`]: #for +[`For-each`]: #for-each +[`While`]: #while +[`Do-while`]: #do-while From 5c8960587914dcad670a314832c3f4b5d3d31532 Mon Sep 17 00:00:00 2001 From: manumafe98 Date: Sun, 28 Apr 2024 19:04:27 -0300 Subject: [PATCH 11/15] Updating for loop introduction Adding a different introduction instead of copying the about.md Adding continue and break statements explanation and exercises --- concepts/loops/about.md | 55 +++++- concepts/loops/introduction.md | 184 +----------------- .../concept/making-the-grade/.docs/hints.md | 11 ++ .../making-the-grade/.docs/instructions.md | 25 +++ .../making-the-grade/.docs/introduction.md | 184 +----------------- .../concept/making-the-grade/.meta/design.md | 4 + .../src/reference/java/MakingTheGrade.java | 28 +++ .../src/main/java/MakingTheGrade.java | 8 + .../src/test/java/MakingTheGradeTest.java | 18 ++ 9 files changed, 154 insertions(+), 363 deletions(-) diff --git a/concepts/loops/about.md b/concepts/loops/about.md index 632fbe5d1..a5875dbf0 100644 --- a/concepts/loops/about.md +++ b/concepts/loops/about.md @@ -4,7 +4,8 @@ In Java there are four looping constructs, two that are iteration centric: [`For ## For -A for loop provides a mechanism to execute a group of statements repeatedly until some condition is met. +A for loop is a control flow statement that allows you to efficiently execute a block of code multiple times. +It achieves this repetition through a concept called iteration, where a variable (often called a loop counter) takes on different values within a specified range. This loop continues executing the code block until the iteration reaches its end. ```java for (initialization; test; update) { @@ -24,6 +25,7 @@ The `test` expression tests if the loop should end. If it evaluates to `true`, the body and then the update expression will be executed. If it evaluates to `false`, neither the body nor the update statement will be executed and execution resumes after the loop's closing bracket. Typically it checks the variable assigned in the initialization block. + For example: ```java @@ -177,6 +179,57 @@ which outputs: 1 ``` +## Break + +The break statement acts as an "exit door" for a looping construct. +When encountered within the loop's body, `break` immediately terminates the loop's execution. + +For example: + +```java +for (int i = 0; i < 10; i++) { + if (i == 5) { + break; + } + + System.out.println(i); +} +``` + +which outputs: + +```text +0 +1 +2 +3 +4 +``` + +## Continue + +The continue statement in the other hand acts similar to a "skip button" in a looping construct. +When encountered within a loop's body, `continue` skips the remaining statements in the current iteration. + +For exmaple: + +```java +for (int i = 0; i < 5; i++) { + if (i < 3) { + continue; + } + + System.out.println(i); +} +``` + +which outputs: + +```text +3 +4 +``` + [`For`]: #for [`For-each`]: #for-each [`While`]: #while diff --git a/concepts/loops/introduction.md b/concepts/loops/introduction.md index 0379d888d..a43f20ef3 100644 --- a/concepts/loops/introduction.md +++ b/concepts/loops/introduction.md @@ -1,183 +1,5 @@ # Introduction -In Java there are four looping constructs, two that are iteration centric: [`For`] and [`For-each`] and the other two are condition centric: [`While`] and [`Do-while`]. - -## For - -A for loop provides a mechanism to execute a group of statements repeatedly until some condition is met. - -```java -for (initialization; test; update) { - body; -} -``` - -The `initialization` sets an initial state for the loop and is executed exactly once at the start of the loop. -Typically it declares and assigns a variable used in the test expression and update statement. -For example: - -```java -int i = 1 -``` - -The `test` expression tests if the loop should end. -If it evaluates to `true`, the body and then the update expression will be executed. -If it evaluates to `false`, neither the body nor the update statement will be executed and execution resumes after the loop's closing bracket. -Typically it checks the variable assigned in the initialization block. -For example: - -```java -i <= 10 -``` - -After executing the loop body, the `update` expression is executed. -Typically it increments or decrements the loop variable by some value. -For example: - -```java -i++ -``` - -A `for` loop printing out the first four squares would look like this: - -```java -for (int i = 1; i <= 4; i++) { - System.out.println("square of " + i + " is " + i * i); -} -``` - -The output would be: - -```text -square of 1 is 1 -square of 2 is 4 -square of 3 is 9 -square of 4 is 16 -``` - -Iterating through every element in a collection is usually performed using a `for-each`, but it can be done with a `for` loop like this: - -```java -for (int i = 0; i < array.length; i++) { - System.out.print(array[i]); -} -``` - -A `for` loop does have some advantages over a `for-each` loop: - -- You can start or stop at the index you want. -- You can use any (boolean) termination condition you want. -- You can skip elements by customizing the incrementing of the loop variable. -- You can process collections from back to front by counting down. -- You can use `for` loops in scenarios that do not involve collections. - -## For-each - -A for-each loop provides a mechanism for executing a block of code for each element in a collection. - -```java -for (declaration: collection) { - body; -} -``` - -The `declaration` declares the variable used to hold the values assigned from the collection. - -The `collection` is an array or collection holding the values that will be assigned to the loop variable. - -The `body` contains the statements that will be executed once for each value in the collection. - -For example: - -```java -char[] vowels = {'a', 'e', 'i', 'o', 'u'}; - -for(char vowel: vowels) { - System.out.println(vowel); -} -``` - -which outputs: - -```text -a -e -i -o -u -``` - -Generally a `for-each` loop is preferrable over a `for` loop for the following reasons: - -- A `for-each` loop is guaranteed to iterate over _all_ values. -- A `for-each` loop is more _declarative_ meaning the code is communicating _what_ it is doing, instead of _how_ it is doing it. -- A `for-each` loop is foolproof, whereas with `for` loops it is easy to have an off-by-one error (think of using `<` versus `<=`). -- A `for-each` loop works on all collection types, including those that do not support using an index to access elements (eg. a `Set`). - -## While - -The `while` loop continually executes a block of statements while a particular condition is true. - -```java -while (condition) { - body; -} -``` - -The `condition` It's a statement that can be true or false. As long as the condition is true, the loop keeps running. -The `body` it's the code that gets executed repeatedly until the condition becomes false. - -For example: - -```java -int counter = 1; - -while (counter <= 5) { - System.out.println(counter); - counter++; -} -``` - -which outputs: - -```text -1 -2 -3 -4 -5 -``` - -Generally good rule of thumb is to use a `while` loops when you don't know exactly how many times you need to loop beforehand. - -## Do-while - -As `while` loops `do-while` loops are condition centric loops, but unlike a regular `while` loop, a `do-while` loop guarantees that the code inside the loop will run at least once, no matter what. - -```java -do { - body; -} while (condition); -``` - -For example: - -```java -int counter = 1; - -do { - System.out.println(counter); - counter++; -} while (counter < 2); -``` - -which outputs: - -```text -1 -``` - -[`For`]: #for -[`For-each`]: #for-each -[`While`]: #while -[`Do-while`]: #do-while +Programming is full of tasks that need to be done over and over again. +To handle these repetitive actions efficiently, Java offers special control flow statements called looping constructs. +This concept will guide you through exploring these constructs and how to use them to your advantage. diff --git a/exercises/concept/making-the-grade/.docs/hints.md b/exercises/concept/making-the-grade/.docs/hints.md index 784daa442..d68604794 100644 --- a/exercises/concept/making-the-grade/.docs/hints.md +++ b/exercises/concept/making-the-grade/.docs/hints.md @@ -15,3 +15,14 @@ ## 4. Matching Names to Scores - Try using a iteration centric loop that allow you to work with indexes. + +## 5. Count Odd Scores + +- Remember that you could use the modulus operator `%` to check if a division has a certain reminder. +- Try using a iteration centric loop +- Check the statements/keywords covered in the concept an use one of them. + +## 6. Challenging Exam + +- Try using a iteration centric loop +- Check the statements/keywords covered in the concept an use one of them. diff --git a/exercises/concept/making-the-grade/.docs/instructions.md b/exercises/concept/making-the-grade/.docs/instructions.md index 72a9d6f8f..87eecc991 100644 --- a/exercises/concept/making-the-grade/.docs/instructions.md +++ b/exercises/concept/making-the-grade/.docs/instructions.md @@ -60,3 +60,28 @@ List studentNames = List.of("Joci", "Sara", "Kora", "Jan", "John", "Bern MakingTheGrade.studentRanking(studentScores, studentNames); // => ["1. Joci: 100", "2. Sara: 99", "3. Kora: 90", "4. Jan: 84", "5. John: 66", "6. Bern: 53", "7. Fred: 47"] ``` + +## 5. Count Odd Scores + +As an investigation, the principal asked the teacher to count how many scores of the math exam result being odd scores, and since you want to help him handle it efficiently. + +We are going to create the method `countOddScores(List studentScores)` with the parameter `List` of studentScores. +This method should count up the number of odd students scores and return that count as an integer. + +```java +MakingTheGrade.countOddScores(List.of(20, 35, 40, 10, 39, 77)); +// => 3 +``` + +## 6. Challenging Exam + +The teacher has prepared a challenging exam and wants to analyze the results. As his assistant you'll evaluate the exams in the same order students handed them in. The teacher is particularly interested in knowing how many students passed the exam before the first non-passing student. +As you know a student needs a score greater than **40** to achieve a passing grade on the exam. + +Create the method `evaluateChallengingExam(List studentScores)` that takes a `List` of students scores in the handed order. +This method should count up the number of passing student scores until the first non-passing score and return that count as an integer. + +```java +MakingTheGrade.evaluateChallengingExam(List.of(45, 90, 15, 100, 70)); +// => 2 +``` diff --git a/exercises/concept/making-the-grade/.docs/introduction.md b/exercises/concept/making-the-grade/.docs/introduction.md index 0379d888d..a43f20ef3 100644 --- a/exercises/concept/making-the-grade/.docs/introduction.md +++ b/exercises/concept/making-the-grade/.docs/introduction.md @@ -1,183 +1,5 @@ # Introduction -In Java there are four looping constructs, two that are iteration centric: [`For`] and [`For-each`] and the other two are condition centric: [`While`] and [`Do-while`]. - -## For - -A for loop provides a mechanism to execute a group of statements repeatedly until some condition is met. - -```java -for (initialization; test; update) { - body; -} -``` - -The `initialization` sets an initial state for the loop and is executed exactly once at the start of the loop. -Typically it declares and assigns a variable used in the test expression and update statement. -For example: - -```java -int i = 1 -``` - -The `test` expression tests if the loop should end. -If it evaluates to `true`, the body and then the update expression will be executed. -If it evaluates to `false`, neither the body nor the update statement will be executed and execution resumes after the loop's closing bracket. -Typically it checks the variable assigned in the initialization block. -For example: - -```java -i <= 10 -``` - -After executing the loop body, the `update` expression is executed. -Typically it increments or decrements the loop variable by some value. -For example: - -```java -i++ -``` - -A `for` loop printing out the first four squares would look like this: - -```java -for (int i = 1; i <= 4; i++) { - System.out.println("square of " + i + " is " + i * i); -} -``` - -The output would be: - -```text -square of 1 is 1 -square of 2 is 4 -square of 3 is 9 -square of 4 is 16 -``` - -Iterating through every element in a collection is usually performed using a `for-each`, but it can be done with a `for` loop like this: - -```java -for (int i = 0; i < array.length; i++) { - System.out.print(array[i]); -} -``` - -A `for` loop does have some advantages over a `for-each` loop: - -- You can start or stop at the index you want. -- You can use any (boolean) termination condition you want. -- You can skip elements by customizing the incrementing of the loop variable. -- You can process collections from back to front by counting down. -- You can use `for` loops in scenarios that do not involve collections. - -## For-each - -A for-each loop provides a mechanism for executing a block of code for each element in a collection. - -```java -for (declaration: collection) { - body; -} -``` - -The `declaration` declares the variable used to hold the values assigned from the collection. - -The `collection` is an array or collection holding the values that will be assigned to the loop variable. - -The `body` contains the statements that will be executed once for each value in the collection. - -For example: - -```java -char[] vowels = {'a', 'e', 'i', 'o', 'u'}; - -for(char vowel: vowels) { - System.out.println(vowel); -} -``` - -which outputs: - -```text -a -e -i -o -u -``` - -Generally a `for-each` loop is preferrable over a `for` loop for the following reasons: - -- A `for-each` loop is guaranteed to iterate over _all_ values. -- A `for-each` loop is more _declarative_ meaning the code is communicating _what_ it is doing, instead of _how_ it is doing it. -- A `for-each` loop is foolproof, whereas with `for` loops it is easy to have an off-by-one error (think of using `<` versus `<=`). -- A `for-each` loop works on all collection types, including those that do not support using an index to access elements (eg. a `Set`). - -## While - -The `while` loop continually executes a block of statements while a particular condition is true. - -```java -while (condition) { - body; -} -``` - -The `condition` It's a statement that can be true or false. As long as the condition is true, the loop keeps running. -The `body` it's the code that gets executed repeatedly until the condition becomes false. - -For example: - -```java -int counter = 1; - -while (counter <= 5) { - System.out.println(counter); - counter++; -} -``` - -which outputs: - -```text -1 -2 -3 -4 -5 -``` - -Generally good rule of thumb is to use a `while` loops when you don't know exactly how many times you need to loop beforehand. - -## Do-while - -As `while` loops `do-while` loops are condition centric loops, but unlike a regular `while` loop, a `do-while` loop guarantees that the code inside the loop will run at least once, no matter what. - -```java -do { - body; -} while (condition); -``` - -For example: - -```java -int counter = 1; - -do { - System.out.println(counter); - counter++; -} while (counter < 2); -``` - -which outputs: - -```text -1 -``` - -[`For`]: #for -[`For-each`]: #for-each -[`While`]: #while -[`Do-while`]: #do-while +Programming is full of tasks that need to be done over and over again. +To handle these repetitive actions efficiently, Java offers special control flow statements called looping constructs. +This concept will guide you through exploring these constructs and how to use them to your advantage. diff --git a/exercises/concept/making-the-grade/.meta/design.md b/exercises/concept/making-the-grade/.meta/design.md index 8a3a708b9..ea551faf5 100644 --- a/exercises/concept/making-the-grade/.meta/design.md +++ b/exercises/concept/making-the-grade/.meta/design.md @@ -30,6 +30,10 @@ This exercise could benefit from the following rules in the [analyzer]: - `essential`: If the student did not use a `while` loop in the `getAverageScoreOfStudents` method, instruct them to do so. - `essential`: If the student did not use a `do-while` loop in the `letterGrades` method, instruct them to do so. - `essential`: If the student did not use a `for` loop in the `studentRanking` method, instruct them to do so. +- `essential`: If the student did not use the `continue` statement in the `countOddScores` method, instruct them to do so. +- `essential`: If the student did not use the `break` statement in the `evaluateChallengingExam` method, instruct them to do so. +- `actionable`: If the student solved the exercise using a different loop that `for-each` in the `countOddScores` method, encourage them to use `for-each` instead. +- `actionable`: If the student solved the exercise using a different loop that `for-each` in the `evaluateChallengingExam` method, encourage them to use `for-each` instead. - `informative`: If the solution uses `String.format` in the `studentRanking` method, inform the student that this cause a small performance penalty compared to string concatenation. If the solution does not receive any of the listed feedback, it must be exemplar. diff --git a/exercises/concept/making-the-grade/.meta/src/reference/java/MakingTheGrade.java b/exercises/concept/making-the-grade/.meta/src/reference/java/MakingTheGrade.java index 8755f797b..9ea3314fb 100644 --- a/exercises/concept/making-the-grade/.meta/src/reference/java/MakingTheGrade.java +++ b/exercises/concept/making-the-grade/.meta/src/reference/java/MakingTheGrade.java @@ -53,4 +53,32 @@ static List studentRanking(List studentScores, List stu return ranking; } + + static int countOddScores(List studentScores) { + int count = 0; + + for (int score : studentScores) { + if (score % 2 == 0) { + continue; + } + + count++; + } + + return count; + } + + static int evaluateChallengingExam(List studentScores) { + int count = 0; + + for (int score : studentScores) { + if (score <= 40) { + break; + } + + count++; + } + + return count; + } } diff --git a/exercises/concept/making-the-grade/src/main/java/MakingTheGrade.java b/exercises/concept/making-the-grade/src/main/java/MakingTheGrade.java index 2b4ccaa53..2f7a7b529 100644 --- a/exercises/concept/making-the-grade/src/main/java/MakingTheGrade.java +++ b/exercises/concept/making-the-grade/src/main/java/MakingTheGrade.java @@ -17,4 +17,12 @@ static List letterGrades(List studentScores, List stude static List studentRanking(List studentScores, List studentNames) { throw new UnsupportedOperationException("Please implement the (static) MakingTheGrade.studentRanking() method"); } + + static int countOddScores(List studentScores) { + throw new UnsupportedOperationException("Please implement the (static) MakingTheGrade.countOddScores() method"); + } + + static int evaluateChallengingExam(List studentScores) { + throw new UnsupportedOperationException("Please implement the (static) MakingTheGrade.evaluateChallengingExam() method"); + } } diff --git a/exercises/concept/making-the-grade/src/test/java/MakingTheGradeTest.java b/exercises/concept/making-the-grade/src/test/java/MakingTheGradeTest.java index 819f9cf97..d436e2868 100644 --- a/exercises/concept/making-the-grade/src/test/java/MakingTheGradeTest.java +++ b/exercises/concept/making-the-grade/src/test/java/MakingTheGradeTest.java @@ -127,4 +127,22 @@ void testEmptyLists() { MakingTheGrade.studentRanking(List.of(), List.of()) ).isEqualTo(List.of()); } + + @Test + @Tag("task:5") + @DisplayName("Three student scores were odd after the correction of the math tests") + void testThreeOddScores() { + assertThat( + MakingTheGrade.countOddScores(List.of(20, 35, 40, 10, 39, 77)) + ).isEqualTo(3); + } + + @Test + @Tag("task:6") + @DisplayName("Two students passed the exam before the first non-passing score") + void testTwoStudentsPassedTheExamBeforeTheNonPassingScore() { + assertThat( + MakingTheGrade.evaluateChallengingExam(List.of(45, 90, 15, 100, 70)) + ).isEqualTo(2); + } } From f07285472cd65551c84053ee8c4f64eb2e4cd88e Mon Sep 17 00:00:00 2001 From: Manuel Maxera <95315128+manumafe98@users.noreply.github.com> Date: Tue, 7 May 2024 12:03:48 -0300 Subject: [PATCH 12/15] Update concepts/loops/about.md Co-authored-by: Sander Ploegsma --- concepts/loops/about.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/concepts/loops/about.md b/concepts/loops/about.md index a5875dbf0..80a192226 100644 --- a/concepts/loops/about.md +++ b/concepts/loops/about.md @@ -208,7 +208,7 @@ which outputs: ## Continue -The continue statement in the other hand acts similar to a "skip button" in a looping construct. +The continue statement on the other hand acts similar to a "skip button" in a looping construct. When encountered within a loop's body, `continue` skips the remaining statements in the current iteration. For exmaple: From f31c25c00cd138496676953169c3564dbbb55c65 Mon Sep 17 00:00:00 2001 From: manumafe98 Date: Tue, 7 May 2024 18:23:58 -0300 Subject: [PATCH 13/15] Updating about.md to make break and continue be under the Loop control statements section Adding two tests for task 5 and 6 Updating design.md to remove out of scope and add new missing learning objective --- concepts/loops/about.md | 8 +++-- .../concept/making-the-grade/.meta/design.md | 5 +-- .../src/test/java/MakingTheGradeTest.java | 36 +++++++++++++++++++ 3 files changed, 43 insertions(+), 6 deletions(-) diff --git a/concepts/loops/about.md b/concepts/loops/about.md index a5875dbf0..3a718afb3 100644 --- a/concepts/loops/about.md +++ b/concepts/loops/about.md @@ -179,7 +179,11 @@ which outputs: 1 ``` -## Break +## Loop control statements + +Loop control statements are special keywords used within loops to alter the normal execution flow. + +### Break The break statement acts as an "exit door" for a looping construct. When encountered within the loop's body, `break` immediately terminates the loop's execution. @@ -206,7 +210,7 @@ which outputs: 4 ``` -## Continue +### Continue The continue statement in the other hand acts similar to a "skip button" in a looping construct. When encountered within a loop's body, `continue` skips the remaining statements in the current iteration. diff --git a/exercises/concept/making-the-grade/.meta/design.md b/exercises/concept/making-the-grade/.meta/design.md index ea551faf5..709fa5fff 100644 --- a/exercises/concept/making-the-grade/.meta/design.md +++ b/exercises/concept/making-the-grade/.meta/design.md @@ -6,10 +6,7 @@ - Know how to repeteadly execute code using a `for-each` loop. - Know how to repeteadly execute code using a `while` loop. - Know how to repeteadly execute code using a `do-while` loop. - -## Out of scope - -- Specific iteration over a `Map` +- Know the control flow statements `break` and `continue`. ## Concepts diff --git a/exercises/concept/making-the-grade/src/test/java/MakingTheGradeTest.java b/exercises/concept/making-the-grade/src/test/java/MakingTheGradeTest.java index d436e2868..edbb10194 100644 --- a/exercises/concept/making-the-grade/src/test/java/MakingTheGradeTest.java +++ b/exercises/concept/making-the-grade/src/test/java/MakingTheGradeTest.java @@ -137,6 +137,24 @@ void testThreeOddScores() { ).isEqualTo(3); } + @Test + @Tag("task:5") + @DisplayName("None of the scores are odd") + void testNoneOfTheScoresAreOdd() { + assertThat( + MakingTheGrade.countOddScores(List.of(20, 40, 60, 80, 10)) + ).isEqualTo(0); + } + + @Test + @Tag("task:5") + @DisplayName("All the scores are odd") + void testAllTheScoresAreOdd() { + assertThat( + MakingTheGrade.countOddScores(List.of(11, 33, 55, 77, 99)) + ).isEqualTo(5); + } + @Test @Tag("task:6") @DisplayName("Two students passed the exam before the first non-passing score") @@ -145,4 +163,22 @@ void testTwoStudentsPassedTheExamBeforeTheNonPassingScore() { MakingTheGrade.evaluateChallengingExam(List.of(45, 90, 15, 100, 70)) ).isEqualTo(2); } + + @Test + @Tag("task:6") + @DisplayName("None of the students passed the exam") + void testNoneOfTheStudentsPassedTheExam() { + assertThat( + MakingTheGrade.evaluateChallengingExam(List.of(5, 10, 25, 2, 37)) + ).isEqualTo(0); + } + + @Test + @Tag("task:6") + @DisplayName("All the students passed the exam") + void testAllTheStudentsPassedTheExam() { + assertThat( + MakingTheGrade.evaluateChallengingExam(List.of(90, 98, 75, 80, 100)) + ).isEqualTo(5); + } } From d24c6c08bc53ddad273bb02a7cadddc7d6f68dff Mon Sep 17 00:00:00 2001 From: Manuel Maxera <95315128+manumafe98@users.noreply.github.com> Date: Mon, 15 Jul 2024 23:33:06 -0300 Subject: [PATCH 14/15] Update exercises/concept/making-the-grade/.docs/instructions.md Co-authored-by: Kah Goh --- exercises/concept/making-the-grade/.docs/instructions.md | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/exercises/concept/making-the-grade/.docs/instructions.md b/exercises/concept/making-the-grade/.docs/instructions.md index 87eecc991..65dbaa867 100644 --- a/exercises/concept/making-the-grade/.docs/instructions.md +++ b/exercises/concept/making-the-grade/.docs/instructions.md @@ -75,7 +75,9 @@ MakingTheGrade.countOddScores(List.of(20, 35, 40, 10, 39, 77)); ## 6. Challenging Exam -The teacher has prepared a challenging exam and wants to analyze the results. As his assistant you'll evaluate the exams in the same order students handed them in. The teacher is particularly interested in knowing how many students passed the exam before the first non-passing student. +The teacher has prepared a challenging exam and wants to analyze the results. +As his assistant you'll evaluate the exams in the same order students handed them in. +The teacher is particularly interested in knowing how many students passed the exam before the first non-passing student. As you know a student needs a score greater than **40** to achieve a passing grade on the exam. Create the method `evaluateChallengingExam(List studentScores)` that takes a `List` of students scores in the handed order. From 4085a81ec389884e9cba7521a7575f754c1f8c3c Mon Sep 17 00:00:00 2001 From: manumafe98 Date: Mon, 15 Jul 2024 23:40:22 -0300 Subject: [PATCH 15/15] Deleting trailing spaces --- exercises/concept/making-the-grade/.docs/instructions.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/exercises/concept/making-the-grade/.docs/instructions.md b/exercises/concept/making-the-grade/.docs/instructions.md index 65dbaa867..22b72e7ff 100644 --- a/exercises/concept/making-the-grade/.docs/instructions.md +++ b/exercises/concept/making-the-grade/.docs/instructions.md @@ -75,8 +75,8 @@ MakingTheGrade.countOddScores(List.of(20, 35, 40, 10, 39, 77)); ## 6. Challenging Exam -The teacher has prepared a challenging exam and wants to analyze the results. -As his assistant you'll evaluate the exams in the same order students handed them in. +The teacher has prepared a challenging exam and wants to analyze the results. +As his assistant you'll evaluate the exams in the same order students handed them in. The teacher is particularly interested in knowing how many students passed the exam before the first non-passing student. As you know a student needs a score greater than **40** to achieve a passing grade on the exam.