Thread: Check all values in bool array so that they are true without using return, break?

So I have found very many articles about how you can do this, but all of the solutions that I've found are using multiple return statements. And that is not allowed in this case. It is not allowed to use break to break out of a loop either. So how can you accomplish this without using multiple return statements or break?

I am allowed to use one return statement at the end of the function.

So this is not working because I'm only checking if 1 value is true and then I move on to check if the next is true. So if only 1 value is true it will set hasWon = true;

Code:

bool hasWon = false;
const int size = 10;
bool arr[size] = {0};

for (int i = 0; i < size; i++) {
    if (arr[i] == true) {
         hasWon = true;
    }
}

Do I need a nested for-loop for this to work so that I check for all values that are true somehow?

Research links:

How do I check if all booleans in an array are true? - Unity Answers

java - What is the most elegant way to check if all values in a boolean array are true? - Stack Overflow

I would do

Code:

for (int i = 0; !hasWon && i < size; i++)

Also, it's only necessary to do

Code:

if (arr[i] )

Sure, this would break out of the loop.
But does it really check so that every value in the array is true?

I mean it does, but if one value is true it sets hasWon = true and
breaks out of the loop leaving the other elements as 0 and still
says the player has won?

Am I wrong now?

That algorithm jimblumberg suggested is correct, but the thing is that it is also inefficient: the loop must always run for size number of iterations, even if the very first element of the array was false.

You might recall from studying predicate logic as part of your computer science curriculum that in order to prove a universally quantified statement false, you just need to find a counterexample. Hence, we might write:

Code:

bool allTrue(bool values[], int size) {
    for (int i = 0; i < size; ++i) {
        if (!values[i]) {
            return false;
        }
    }
    return true;
}

So what is happening here is that we run a loop to find a counterexample. If one is found, great. We know that the statement "for all values x, x is true" is false. If not, well, since we have exhausted the possibility of finding a counterexample, it follows that indeed the statement is true, so we return true. You probably saw variations of this many times when searching the Web for examples, and naturally so since it expresses the maths quite nicely.

Unfortunately, it seems you have an artificial restriction on multiple return statements (this might be inspired by something called "single entry - single exit", but that idea is not useful in C++ since C++ has exceptions as a native feature). It also seems to have an artificial restriction on break statements (this might be inspired by them being akin to goto, but in fact break statements are not so arbitrary, hence they don't suffer from quite the same problems as goto).

What you can do though, is to make this mathematical assertion about the universally quantified statement through your hasWon variable, i.e., you assert that the statement is true (hasWon = true), then attempt to find a counterexample as long as the assertion remains true:

Code:

bool allTrue(bool values[], int size) {
    bool hasWon = true;
    for (int i = 0; i < size && hasWon; ++i) {
        if (!values[i]) {
            hasWon = false;
        }
    }
    return hasWon;
}