Why is this listed here? When I think about loops I don't necessarily think of maps.

Things that are related and seem to be out of scope of this exercise:

• Breaking out of loops using the break keyword
• Skipping iterations using the continue keyword

Instead of adding those to the out of scope I prefer mention them and maybe try to add exercise to cover those topics now that you say it, do you have in mind some other topics that could be out of scope? or I should remove it?

I'd be worried that also adding the control-flow statements to this exercise may make it a bit too big.

6 tasks in a not very complex concept for me seems acceptable

Whoa, I know I said to trim down the contents of the introduction but I think we need to give at least some information 😂

🤣 What do you suggest to add then ? hahaha

Maybe, I don't know to be honest. That would mean that the exercise is limited to just array creation and array indexing?

I'd like to have a good plan going forward, discussions like these become a bit too big for code reviews tbh.

I'd be worried that also adding the control-flow statements to this exercise may make it a bit too big.

This actually makes for a nice while task:

class MakingTheGrade {

    static int evaluateChallengingExam(List<Integer> studentScores) {
        int index = 0;

        while (studentScores.get(index) > 40) {
            index++;
        }

        return index + 1;
    }
}

😆

Do you suggest to change this one for the one that is actually the while task? and make a new one for break ?

Floating another idea for trying to keep this as a break task, it might help to require them to something a bit more with the matching score. For example, if we require them to add the score to a second list (like keeping a list of the first failing score), the solution might look like this:

static void evaluateChallengingExam(List<Integer> studentScores, List<Integer> firstFailingScores) {
  for (int score : studentScores) {
    if (score <= 40) {
      firstFailingScores.add(score);
      break;
    }
  }
}

This way, we can even come up with tests for when the none of the scores pass.

I notice the design says to have an essential comment if the student doesn't use continue. I think another valid way to solve this one is to add only odd scores in an if statements (i.e. no usage of continue):

static int countOddScores(List<Integer> studentScores) {
    int count = 0;

    for (int score : studentScores) {
        if (score % 2 != 0) {
            count++;
        }
    }
}

We could try to make up a more complicated calculation (although, haven't thought how it could fit with the story yet). For example, we could try something like:

• Lets say we are trying to calculate a value. The value starts at 0. Then for each score ...
• If the number is even, go to the next number (don't do anything to value).
• Then, if the number is also greater than 20, add 5 to value.
• Then, if the number is also greater than 60, then double the value.
• Then, if the number is also greater than 80, subtract 50 from value.

We could even add something like "stop adding to the value if the number is greater than 90" to sneak in a possible break.

I think I would also likely use the for loop too (as per @sanderploegsma's comment). Giving them a list to go through "opens the door" for the for loop. Perhaps we could try moving away from a list - we could try ask them to call a method that returns something until a condition is met.

One way that came to my mind is that we could extend the challenging exam scenario by saying we want to see how many attempts it takes for a student to pass on exam. Then we could give them an Attempt object with a score() method that returns different a value each time it is called.

Floating another idea for trying to keep this as a break task, it might help to require them to something a bit more with the matching score. For example, if we require them to add the score to a second list (like keeping a list of the first failing score), the solution might look like this:

static void evaluateChallengingExam(List<Integer> studentScores, List<Integer> firstFailingScores) {
  for (int score : studentScores) {
    if (score <= 40) {
      firstFailingScores.add(score);
      break;
    }
  }
}

This way, we can even come up with tests for when the none of the scores pass.