Как ограничить декремент?

Question

Как ограничить декремент?

Существует начальная сложность игры, которая

game_difficulty=5   //Initial

Каждые 3 раза, если вы понимаете это правильно, ваша трудность возрастает до бесконечности, но каждые 3 раза, когда вы понимаете это неправильно, ваша трудность уменьшается но не ниже 5. Итак, в этом коде для ex:

if(user_words==words)   win_count+=1;
else()  incorrect_count+=1;if(win_count%3==0) /*increase diff*/;
if(incorrect_count%3==0) /*decrease difficulty*/;

Как мне это сделать?

-2

c++conditional procedural-programming

Решение

Другие решения

Вы можете просто добавить это как условие:

if (user words==words) {
win_count += 1;
if (win_count %3 == 0) {
++diff;
}
} else {
incorrect_count += 1;
if (incorrect_count % 3 == 0 && diff > 5) {
--diff
}
}

0

Например:

if(win_count%3==0) difficulty++;
if(incorrect_count%3==0 && difficulty > 5) difficulty--;

0

Это может быть превращено в мотивирующий пример для пользовательских типов данных.

Создайте класс, который оборачивает сложность int в качестве закрытой переменной-члена, а в открытых функциях-членах убедитесь, что так называемые контракт встретил В итоге вы получите значение, которое всегда гарантированно соответствует вашим требованиям. Вот пример:

class Difficulty
{
public:

// initial values for a new Difficulty object:
Difficulty() :
right_answer_count(0),
wrong_answer_count(0),
value(5)
{}

// called when a right answer should be taken into account:
void GotItRight()
{
++right_answer_count;
if (right_answer_count == 3)
{
right_answer_count = 0;
++value;
}
}

// called when a wrong answer should be taken into account:
void GotItWrong()
{
++wrong_answer_count;
if (wrong_answer_count == 3)
{
wrong_answer_count = 0;
--value;
if (value < 5)
{
value = 5;
}
}
}

// returns the value itself
int Value() const
{
return value;
}

private:
int right_answer_count;
int wrong_answer_count;
int value;
};

А вот как вы будете использовать класс:

Difficulty game_difficulty;

// six right answers:
for (int count = 0; count < 6; ++count)
{
game_difficulty.GotItRight();
}

// check wrapped value:
std::cout << game_difficulty.Value() << "\n";

// three wrong answers:
for (int count = 0; count < 3; ++count)
{
game_difficulty.GotItWrong();
}

// check wrapped value:
std::cout << game_difficulty.Value() << "\n";

// one hundred wrong answers:
for (int count = 0; count < 100; ++count)
{
game_difficulty.GotItWrong();
}

// check wrapped value:
std::cout << game_difficulty.Value() << "\n";

Выход:

7
6
5

Как только вы получите четкое представление о том, как создаются и используются такие типы, вы можете начать изучать перегрузку операторов, чтобы тип можно было использовать как настоящий. intто есть с +, - и так далее.

0

Как мне это сделать?

Вы пометили этот вопрос как C ++. IMHO способ c ++ — создать класс, инкапсулирующий все ваши проблемы.

Возможно что-то вроде:

class GameDifficulty
{
public:
GameDifficulty () :
game_difficulty (5), win_count(0), incorrect_count(0)
{}

~GameDifficulty () {}

void update(const T& words)
{
if(user words==words)   win_count+=1;
else              incorrect_count+=1;

// modify game_difficulty as you desire
if(win_count%3 == 0)
game_difficulty += 1 ; // increase diff no upper limit

if((incorrect_count%3 == 0) && (game_difficulty > 5))
game_difficulty -= 1; //decrease diff;
}

inline int gameDifficulty() { return (game_difficulty); }
// and any other access per needs of your game

private:
int game_difficulty;
int win_count;
int incorrect_count;
}

// примечание — не скомпилировано и не протестировано

использование будет:

// instantiate
GameDiffculty  gameDifficulty;

// ...

// use update()
gameDifficulty.update(word);

// ...

// use access
gameDifficulty.gameDifficulty();

Преимущество: инкапсуляция

Этот код находится в одном месте, не загрязняя другие места в вашем коде.

Вы можете изменить эти политики в одном месте, не влияя на остальную часть вашего кода.

0

Источник

Accepted Answer

Простой ответ:

if(incorrect_count%3==0) difficulty = max(difficulty-1, 5);

Но лично я бы обернул это в небольшой класс, тогда вы можете содержать всю логику и расширять ее по мере продвижения, что-то вроде:

class Difficulty
{
public:
Difficulty() {};

void AddWin()
{
m_IncorrectCount = 0; // reset because we got one right?

if (++m_WinCount % 3)
{
m_WinCount = 0;
++m_CurrentDifficulty;
}
}

void AddIncorrect()
{
m_WinCount = 0; // reset because we got one wrong?

if (++m_IncorrectCount >= 3 && m_CurrentDifficulty > 5)
{
m_IncorrectCount = 0;
--m_CurrentDifficulty;
}
}

int GetDifficulty()
{
return m_CurrentDifficulty;
}

private:
int m_CurrentDifficulty = 5;
int m_WinCount = 0;
int m_IncorrectCount = 0;
};

0