Is there a way to run a statement when a condition in a loop is met at least once?

for loop
which loop is guaranteed to execute at least one time
while loop
how does a for loop start?
an if-else statement can always replace an if statement.
while loop example
do while loop
for loop example

I am currently doing games on my free time and am currently working on a hangman game. However, I have stumbled upon a problem and I think I could solve it if there was a way to run a statement if a condition inside a loop is met at least once, and if the condition isn't met even once, it'll do another thing. Is it possible to do? Does anyone have any ideas? I appreaciate any suggestions.

I tried doing something like this:

for (){
if (string [i] == letter that the player inputed){
// replace underscores with the letter guessed
// and also turn a bool statement true
}
else {
 // turn the bool statement false
  }
}
if (!bool variable){
 // print that the letter guessed was not in the answer
 // and substract one from the number of guesses available
}

However I noticed that it doesn't work because the loop will run and if the last letter that it checks is not in the answer, the bool will turn false, thus printing that the letter was not in the answer and substracting one from the score. (It's also my first time posting here, and I don't know if that's how I'm supposed to write a code, so I apologize beforehand if I'm not doing it correctly) `

You should approach this problem from the different angle:

for( ... ) {
    if( your condition is met ) {
        do_whatever_you_have_to();

        break;   // <<--- exit the loop, so it's done only once
    }
}

Loops: while and for, Loops are a way to repeat the same code multiple times. If the loop body has a single statement, we can omit the curly braces {…} : The loop will first execute the body, then check the condition, and, while it's truthy, the body of the loop to execute at least once regardless of the condition being truthy. Assuming that you mean, for (i in 1:101), you won't get a value equal to 1 in the loop because .01 cannot be exactly represented in binary. With the modified for statement, the 100'th value is not exactly equal to 1: x[100] - 1 ## [1] 6.661338e-16 To break when something "exceeds or equals" another value, you would use >=.

You don't have to put flag guessed off if the comparation fails

string s;
bool guessed = false;
char inputted_letter; // comes from somewhere
for (size_t i = 0; i < s.size(); ++i) {
  if (s[i] == inputted_letter) {
    // replace underscores with the letter guessed
    guessed = true;
  }
}

if (!guessed) {
  // print that the letter guessed was not in the answer
  // and substract one from the number of guesses available
}

Can someone just help me fully understand how to use while loops , In the above the condition is tested after the first run of the code. There is no entry condition, only an exit condition. While loops execute at least zero times (the entry condition must be met). Do-while loops execute at least once (while the condition is met). There are two ways to use the While keyword to check a condition in a DoLoop statement. You can check the condition before you enter the loop, or you can check it after the loop has run at least once. In the following ChkFirstWhile procedure, you check the condition before you enter the loop. If myNum is set to 9 instead of 20, the statements inside the loop will

You don't have to set false in the loop:

bool has_found = false;

for (auto& c : word_to_guess)
{
    if (input_letter == c) {
        // replace _ by current letter...
        has_found = true;
    }
}
if (!has_found){
    // print that the letter guessed was not in the answer
    // and substract one from the number of guesses available
}

But I suggest that your loop does only one thing at a time:

bool contains(const std::string& word_to_guess, char input_letter)
{
    return std::any_of(word_to_guess.begin(),
                       word_to_guess.end(),
                       [&](char c){ return input_letter == c; })
    /*
    for (auto& c : word_to_guess)
    {
        if (input_letter == c) {
            return true;
        }
    }
    return false;
    */
}


if (contains(word_to_guess, input_letter)
{
    // show current letter...
    for (std::size_t i = 0; i != hangman_word.size(); ++i) {
        if (word_to_guess[i] == input_letter) {
            hangman_word[i] = word_to_guess[i];
        }
    }
} else {
    // print that the letter guessed was not in the answer
    // and substract one from the number of guesses available
}

For, While and Do While Loops in C, Learn how to use loops in C, including for, while and do while loops, with examples Being able to have your program repeatedly execute a block of code is one of the when working with loops (the conditions are the same as with if statements). If the condition is empty, it is evaluated as true and the loop will repeat until� When the condition is on the Do line, the loop may not run at all. So it will run zero or more times. When the condition is on the Loop line, the loop will always run at least once. So it will run one or more times. In our the last example, the condition is on the Loop line because we always want to get at least one value from the user. In the

Can you do what you are asking; possibly, however you stated you were making the game Hangman in C++ and I think you are going about this with the wrong approach, therefore, choosing or implementing the wrong algorithms. You are trying to traverse through two strings with possible different lengths from the back end which if it isn't done correctly can lead to issues, will tend to be hard to track especially if their comparisons determine loop conditions, exit or return statements.

I have implemented my version of "Hangman", now albeit the formatting isn't the prettiest, nor are the level dictionaries being generated from a large pool of random words. I express this in the comments of the code that these would generally be read in from a text file and saved into these structures. For simplicity's sake, I initialized them with random words directly in the code.

Take a look to see what I've done:


#include <string>
#include <iostream>
#include <vector>
#include <map>
#include <random>    

class Game;

int main() {
    using namespace util;

    try {
        Game game("Hangman");
        game.start();
    } catch (const std::exception& e) {
        std::cerr << e.what() << std::endl;
        return EXIT_FAILURE;
    }

    return EXIT_SUCCESS;
} 

class Game {
private:
    std::string title_;
    bool is_running_{ false };

    std::string answer_;
    std::string guessed_;

    std::map<unsigned, std::vector<std::string>> dictionary_; // unsigned represents difficulty level of word
    unsigned choosen_difficulty_;

    std::string guessed_characters_{"\n"};

public:
    Game(const std::string& title) : title_{ title }, choosen_difficulty_{ 0 } {
        initialize();
        start_over();
    }

    void start() {
        is_running_ = true;

        // the player has as many attempts as twice the length of hidden answer's word length. 
        int number_tries = answer_.size() * 2;

        while (is_running_ || number_tries > 0) {
            displayGuessedWord();
            displayGuessedCharacters();

            // ask the player to guess a character;
            char guess;

            // get a character and make sure it is a valid alphabet character
            do {
                std::cout << "Guess a character ";
                std::cin >> guess;
                // Note: I'm using ascii characters in this case 
                // but for demonstration purposes only!
                if ((guess < 'a' && guess > 'z') ||
                    (guess < 'A' && guess > 'Z')) {
                    std::cout << "invalid entry ";
                }
            } while ( (guess < 'a' && guess > 'z') ||
                      (guess < 'A' && guess > 'Z') );

            // test character and update guessed word and number of tries.
            test_character(guess);
            update_guessed_characters(guess);
            number_tries--;

            // failed condition
            if (number_tries <= 0 && guessed_ != answer_) {
                std::cout << "\nGame Over!\n";              
                is_running_ = try_again(number_tries);
            // winning condition
            } else if (number_tries > 0 && guessed_ == answer_) {
                std::cout << "\nCongratulations!\n";
                is_running_ = try_again(number_tries);
            }

            if (!is_running_) break;                
        }
    }

private:
    void displayGuessedWord() {
        std::cout << '\n' << guessed_ << '\n';
    }
    void displayGuessedCharacters() {
        std::cout << guessed_characters_ << '\n';
    }

    void initialize() {
        // Normally this would be read in from a file upon game initialization
        // but for demonstration purpose, I'll generate a few small vectors of strings
        // and associate them to their difficulty level

        // levels are based on 3 factors, the length of the word, the repetitive occurance 
        // of common characters, and the amount of less commonly used characters.
        std::vector<std::string> level_1{ "ate", "cat", "dog", "coat", "coal", "does" };
        std::vector<std::string> level_2{ "able", "believe", "balloon", "better", "funny", "happy" };
        std::vector<std::string> level_3{ "ability", "carpenter", "dogmatic", "hilarious", "generosity", "hostility" };
        // ... etc. I'll use just these here for simplicty where each vector has six entries, however,
        // with random number generators, this can be done generically for any size 
        // or number of elements in each of the different vectors.

        // create generate the map:
        dictionary_[1] = level_1;
        dictionary_[2] = level_2;
        dictionary_[3] = level_3;
    }

    std::string getWordFromDictionary(unsigned difficulty, std::map<unsigned, std::vector<std::string>>& dict) {
        auto level = dict[difficulty]; // extract the vector based on difficulty level
        auto size = level.size();      // get the size of that vector
        std::random_device dev;        // create a random device                     
        std::mt19937 rng(dev());       // create a pseudo random generator
        // create a uniform int distribution type with the range from 0 to size-1
        std::uniform_int_distribution<std::mt19937::result_type> dist(0, size - 1);
        return level[dist(rng)]; // return a random string from this level.
    }

    void start_over() {
        system("cls"); // Note: I'm running visual studio on Windows!

        std::cout << "Welcome to " << title_ << '\n';

        // We can use a random generator to pick a word from the given difficulty
        // but first we need to get user input for the chosen level.
        do {
            std::cout << "Choose your difficulty [1-3]\n";
            std::cin >> choosen_difficulty_;

            if (choosen_difficulty_ < 1 || choosen_difficulty_ > 3) {
                std::cout << "Invalid entry:\n";
            }
        } while (choosen_difficulty_ < 1 || choosen_difficulty_ > 3);

        answer_ = getWordFromDictionary(choosen_difficulty_, dictionary_);

        // clear and resize guessed word to be that of answer_ and add bunch of hypens.
        guessed_.clear();
        guessed_.resize(answer_.size(), '-');

        // also reset the guessed_characters
        guessed_characters_ = std::string("\n");
    }

    bool try_again(int& tries) {
        std::cout << "Would you like to try again?\n";
        char c;
        std::cin >> c;
        if (c == 'y' || c == 'Y') {
            start_over();
            // don't forget to update this so that the loop can repeat
            tries = answer_.size() * 2;
            return true;
        }
        else {
            std::cout << "Thank you for playing " << title_ << '\n';
            return false;
        }
    }

    void test_character(const char c) {
        // here is where you would use the standard library for taking the character
        // passed into this function, updating the guessed_characters

        // get all indexes
        std::vector<unsigned> locations;
        for (unsigned i = 0; i < answer_.size(); i++)
            if (answer_[i] == c)
                locations.push_back(i);

        // now update the guessed word
        if ( locations.size() > 0 )
            for (size_t n = 0; n < locations.size(); n++)
            guessed_[locations[n]] = c;
    }

    void update_guessed_characters(const char c) {
        guessed_characters_.insert(0, &c); // just push to the front
    }
};

If you noticed how I structured the game class above; I am using while and do-while loops in conjunction with for-loops and if-statements and a single boolean flag to determine the state of the game. The game state is also determined from the update to the guessed characters and guessed word. Then I compare that to the answer. Depending on certain conditions the loop will continue seeking input from the user or will exit.

I am not guaranteeing that this code is 100% bug-free for I didn't do any rigorous testing or checking corner cases or special cases but the code has run without error and I've tested all primary game state cases. It appears to be working fine.

I know that there could be many improvements and simplifications made if I had chosen to use some of the standard library functions for working with strings, but I wanted to illustrate the individual steps that are involved in the design or thinking process of making a game with states and their transitions. I could of also put the game class declaration into its own header file with its implementation in a cpp file, but I left that as a single class that is shown in main.cpp for easy copy and paste and compilation.

With this particular game, I did not use a switch and case statements, I just stuck with some while and do-while loops, a few for loops, and if statements since there are only a few game states and transitions to worry about. This implementation also demonstrates the algorithms that are involved and shows how they interconnect with each other. I hope this helps to give you a better understanding of the design process.

When making a game that has different states with a bit of complexity to it, you should start by making your state table first and list all of its transitions before you even write any code. Then you should list your starting, continuing, winning, failing and exiting states or cases. Then you need to draw up how you would transition from one state to another by their required conditions. This will help you in the long run!

Once you have the game state and its transitions laid out properly, then you can start to make your required functions for those states and begin to connect them together. After that is when you would write the internal of the functions or their implementation of what they would do.

Finally, after you have that down is where you want to do some debugging and unit and case testing and if everything appears to be okay, then it would be safe to improve your current algorithms or choosing better ones for peak or most efficient performance.

Java Flow Control: while and do-while Statements, Conditional statements and loops are a very important tool in programming. In Java, there are several ways to control the flow of the code: are repeatedly executed until some condition is met, or alternatively as long as a condition is true . like while(true) , the block of code would execute indefinitely (or at least, try to). This is called an infinite loop and is to be avoided unless we have a way of breaking out of the loop - typically with a break statement. The condition can be any type of Boolean expression, the same as with if statements. Since while checks the condition before executing any code, it is possible that the block of code within the while loop is never executed if the condition was false at the beginning. This is different from a for loop, which typically executes a set number of times.

Statements and flow control - C++ Tutorials, The if keyword is used to execute a statement or block, if, and only if, a condition is fulfilled. If, after any execution of statement , expression is no longer true, the loop thus the statement shall alter values checked in the condition in some way , loop needs to be executed at least once to prompt for input, and the condition � Of course you could mean you want to restart loop () halfway through the code in loop, in which case you should use the return; statement, which will cause the current function call to exit immediately and return control to the calling function. In the case of loop () this will cause it to be restarted. – Code Gorilla Nov 28 '16 at 8:10

C Programming Course Notes - Looping Constructs, While loops check for the stopping condition first, and may not execute the This guarantees that the loop will be performed at least once, which is useful for However it can be any legal C/C++ statement, such as "N += 3" or "counter = base + delta". The limits as to how deeply loops may be nested is implementation� Learn C Programming MCQ Questions and Answers on Loops like While Loop, For Loop and Do While Loop. Loops execute a series of statements until a condition is met or satisfied. Easily attend exams after reading these Multiple Choice Questions. Go through C Theory Notes on Loops before studying questions.

Do while loop, In most computer programming languages, a do while loop is a control flow statement that executes a block of code at least once, and then either repeatedly � And as for the f(y)==0 that was just there because that was the only one that made the loop go until a certain point was met. Since the function had both negative and positive side (Like f(0.8) could give me -0.62 while f(0) gives me 1) just using one where f(y)>(some number) or f(y)<(some number) just made it stop far too prematurely since it

Comments
  • Yes, it’s possible. What language? What does the current code look like?
  • The language I'm using to create the game is c++
  • I updated the post with a pseudo code of what I tried doing, but I noticed that it doesn't work because the loop will run and if the last letter that it checks is not in the answer, the bool will turn false, thus printing that the letter was not in the answer and substracting one from the score. (It's also my first time posting here, and I don't know if that's how I'm supposed to write a code, so I apologize beforehand if I'm not doing it correctly)
  • If I'm understanding correctly from what you wrote, you can declare a bool variable outside the scope of the for loop and set the initial value to false, and flip it to true in the if condition. Does that work for you?
  • Yes, but the problem is that if the last character of the string is not the same as the inputted letter, the bool will turn false, even if any of the previous ones were true. And then, running the statement when the letter was not in the answer.
  • But what if the answer has more than one instance of that letter? It will only replace one of the underscores and finalize the statement.
  • @Influence_r you asked how to do something once. now you're asking how to do something every time when the condition is met -- if this is what you want, creating a boolean flag and keeping it updated, then do something based on that after the loop is finished (as you wrote in the question) is a valid approach.
  • @Influence_r check out my answer, you have to keep track of all of the index locations of that string for the comparison character and save them to a vector or an array... I demonstrate this in my answer but did not mention it; it was left there as a hidden challenge for you to pick up, but my answer does help to resolve this problem!
  • Yes, but the problem is that if the last character of the string is not the same as the inputted letter, the bool will turn false, even if any of the previous ones were true. And then, running the statement when the letter was not in the answer.
  • In example I provided is only one change of a flag possible - in case of positive if condition, it means exactly what you expect.