Разработка игровой программы

Разработать объектно-ориентированную программу для числовой игры, где 2 игрока должны поочередно выбирать из кучи заданного размера S любое количество предметов, которое не превышает фиксированного значения N<S. Игра должна продолжаться, пока текущий размер кучи больше 0. Победителем считается игрок, который вынудил противника взять последний предмет кучи. Игра должна быть реализована в варианте, когда двумя противниками являются человек (Man) и компьютер (Pen), которому предоставляется право первого хода. Человек может делать любые допустимые ходы, сообщая число взятых им предметов через стандартный ввод. При любой ошибке ввода размер кучи автоматически уменьшается на 1 предмет, и ход передается компьютеру. Компьютер должен действовать по выигрышной стратегии, чтобы остаток кучи после каждого его хода был равен (XN+X+1), где X обозначает наибольшее целое число, при котором этот остаток будет меньше текущего размера кучи. В любом случае результат каждого хода компьютера должен отображаться через поток стандартного вывода. Исходными данными для любой партии игры являются размер кучи S и предельное число предметов N, которое можно взять из кучи за 1 ход. Эти параметры должны передаваться программе через аргументы командной строки ее вызова. Каждый ход должен сопровождать запрос, который отображает текущий размер кучи и идентифицирует игрока, чей ход осуществляется в данный момент. Игра должна завершаться диагностическим сообщением, которое показывает ее конечный результат. При разработке программы следует реализовать производные классы игроков с виртуальной функцией хода, которые наследуют интерфейс игры и доступ к куче от абстрактного базового класса.

#include <stdlib.h>

#include <iostream.h>

// Класс кучи предметов

class Heap {

private:

int size; // размер кучи

public:

Heap(int s) : size(s) {}; // инициализация кучи

// запрос размера и выбор предметов из кучи

int get(int n = 0) { size -= n; return(size); };

}; // Heap

// базовый класс игрока

class Gambler {

protected:

Heap* heap; // адрес кучи

const int limit; // предел выборки за 1 ход

const char* name; // имя игрока

public:

Gambler(Heap& h, int l) : limit(l) { heap = &h; }; // инициализация данных

virtual int move() = 0; // чистая виртуальная функция хода

int query(); // запрос хода

}; // Gambler

// класс человека

class Man : public Gambler {

public:

Man(Heap& h, int l, char* n) : Gambler(h, l) { name = n; };

virtual int move(); // ход человека

}; // Man

// класс копьютера

class Pen : public Gambler {

public:

Pen(Heap& h, int l, char* n) : Gambler(h, l) { name = n; };

virtual int move(); // ход копьютера

}; // Pen

// метод запроса хода

int Gambler::query() {

cout << "Heap = " << heap->get() << " " << name << " > ";

return(heap->get()); // возврат размера кучи

} // query()

// метод хода человека

int Man::move() {

int g; // число выбранных предметов из кучи

cin >> g; // ввод числа выбранных предметов

// анализ числа выбранных предметов

if((g < 1) || (g > (heap->get())) || (g > limit))

g = 1;

// выбор предметов из кучи с возвратом ее размера

return(heap->get(g));

} // Man::move()

// метод хода компьютера

int Pen::move() {

int rest = 0; // остаток кучи

int x = 0; // параметр выбора

int h; // текущий размер кучи

if((h = heap->get()) == 1)

h = heap->get(1);

// подбор выигрышного остатка кучи

while((rest = (x *limit + x + 1)) < h)

x ++;

if((rest > h) || (rest == h))

rest = (x - 1)*limit + x;

heap->get(h - rest); // выбор предметов из кучи

cout << h - rest << "\n"; // вывод хода компьютера

return(heap->get()); // возврат текущего размера кучи

} // Pen::move()

// основная функция

int main(int argc, char* argv[]) {

int i = 0; // индекс игрока

Heap h(atoi(argv[1])); // инициализация кучи

// инициализация и адресация игроков

Gambler* g[] = { new Pen(h, atoi(argv[2]), "Pen"),

new Man(h, atoi(argv[2]), "Man")

};

// реализация партии игры

while(g[i]->query() != 0) {

g[i]->move();

if(++i > 1)

i = 0;

}

// идентификация победителя

cout << "Winner\n";

// освобождение памяти игроков

delete g[0];

delete g[1];

return(0); // корректное завершение программы

} // main()

Результат выполнения программы для кучи из S=11 предметов, из которой за 1 ход можно выбрать не более N=3 предмета

Heap=11 Pen>2

Heap=9 Man>1

Heap=8 Pen>3

Heap=5 Man>2

Heap=3 Pen>2

Heap=1 Man>1

Heap=0 Pen>Winner

Варианты заданий для седьмой лабораторной работы

--------------------------------------------------------------------------------------------------------------------

Разработать объектно-ориентированную программу для числовой игры, где 2 игрока должны поочередно наращивать сумму, достигнутую на предыдущем ходе противника, выбирая числовое приращение, которое не превышает заданной фиксированной величины N. Игра должна продолжаться, пока значение суммы, набранной обоими игроками, меньше заданной величины S>N. Победителем считается игрок, который на своем ходе смог первым набрать требуемую сумму M. Игра должна быть реализована в варианте, когда двумя противниками являются компьютер и человек, которому предоставлено право первого хода. Человек может делать любые допустимые ходы, сообщая величину приращения суммы через стандартный ввод. При любой ошибке ввода сумма автоматически увеличивается на 1, и ход передается компьютеру. Компьютер должен действовать по выигрышной стратегии, согласно которой остаток до предельной суммы S после каждого его хода должен быть кратен (N+1). Если выигрышный ход сделать невозможно, компьютер должен увеличивать текущую сумму на 1. В любом случае приращение суммы на ходе компьютера должно отображаться через поток стандартного вывода. Исходными данными для любой партии игры являются значение суммы S, которую должны набрать игроки, и предельная величина N ее приращения за 1 ход. Эти параметры должны передаваться программе через аргументы командной строки ее вызова. Каждый ход должен сопровождать запрос, который отображает текущую величину суммы и идентифицирует игрока, чей ход ожидается в данный момент. Партию игры должно завершать диагностическое сообщение, которое идентифицирует ее итоговый результат. При разработке программы необходимо реализовать производные классы игроков с виртуальной функцией хода, которые наследуют интерфейс игры и доступ к значению набранной суммы от абстрактного базового класса.

V1

---------------------------------------------------------------------------------------------------------------------

Разработать объектно-ориентированную программу для числовой игры, где 2 игрока должны поочередно наращивать сумму, достигнутую на предыдущем ходе противника, выбирая числовое приращение, которое не превышает заданной фиксированной величины N. Игра должна продолжаться, пока значение суммы, набранной обоими игроками, меньше заданной величины S>N. Победителем считается игрок, который на своем ходе смог первым набрать требуемую сумму M. Игра должна быть реализована в варианте, когда двумя противниками являются компьютер и человек, которому предоставлено право первого хода. Человек может делать любые допустимые ходы, сообщая величину приращения суммы через стандартный ввод. При любой ошибке ввода сумма автоматически увеличивается на 1, и ход передается компьютеру. Компьютер должен действовать по выигрышной стратегии, согласно которой остаток до предельной суммы S после каждого его хода должен быть кратен (N+1). Если выигрышный ход сделать невозможно, компьютер должен увеличивать текущую сумму на N. В любом случае приращение суммы на ходе компьютера должно отображаться через поток стандартного вывода. Исходными данными для любой партии игры являются значение суммы S, которую должны набрать игроки, и предельная величина N ее приращения за 1 ход. Эти параметры должны передаваться программе через аргументы командной строки ее вызова. Каждый ход должен сопровождать запрос, который отображает текущую величину суммы и идентифицирует игрока, чей ход ожидается в данный момент. Партию игры должно завершать диагностическое сообщение, которое идентифицирует ее итоговый результат. При разработке программы необходимо реализовать производные классы игроков с виртуальной функцией хода, которые наследуют интерфейс игры и доступ к значению набранной суммы от абстрактного базового класса.

V2

---------------------------------------------------------------------------------------------------------------------

Разработать объектно-ориентированную программу для числовой игры, где 2 игрока должны поочередно наращивать сумму, достигнутую на предыдущем ходе противника, выбирая числовое приращение, которое не превышает заданной фиксированной величины N. Игра должна продолжаться, пока значение суммы, набранной обоими игроками, меньше заданной величины S>N. Победителем считается игрок, который на своем ходе смог первым набрать требуемую сумму M. Игра должна быть реализована в варианте, когда двумя противниками являются компьютер и человек, которому предоставлено право первого хода. Человек может делать любые допустимые ходы, сообщая величину приращения суммы через стандартный ввод. При любой ошибке ввода сумма автоматически увеличивается на N, и ход передается компьютеру. Компьютер должен действовать по выигрышной стратегии, согласно которой остаток до предельной суммы S после каждого его хода должен быть кратен (N+1). Если выигрышный ход сделать невозможно, компьютер должен увеличивать текущую сумму на 1. В любом случае приращение суммы на ходе компьютера должно отображаться через поток стандартного вывода. Исходными данными для любой партии игры являются значение суммы S, которую должны набрать игроки, и предельная величина N ее приращения за 1 ход. Эти параметры должны передаваться программе через аргументы командной строки ее вызова. Каждый ход должен сопровождать запрос, который отображает текущую величину суммы и идентифицирует игрока, чей ход ожидается в данный момент. Партию игры должно завершать диагностическое сообщение, которое идентифицирует ее итоговый результат. При разработке программы необходимо реализовать производные классы игроков с виртуальной функцией хода, которые наследуют интерфейс игры и доступ к значению набранной суммы от абстрактного базового класса.

V3

---------------------------------------------------------------------------------------------------------------------

Разработать объектно-ориентированную программу для числовой игры, где 2 игрока должны поочередно наращивать сумму, достигнутую на предыдущем ходе противника, выбирая числовое приращение, которое не превышает заданной фиксированной величины N. Игра должна продолжаться, пока значение суммы, набранной обоими игроками, меньше заданной величины S>N. Победителем считается игрок, который на своем ходе смог первым набрать требуемую сумму M. Игра должна быть реализована в варианте, когда двумя противниками являются компьютер и человек, которому предоставлено право первого хода. Человек может делать любые допустимые ходы, сообщая величину приращения суммы через стандартный ввод. При любой ошибке ввода сумма автоматически увеличивается на N, и ход передается компьютеру. Компьютер должен действовать по выигрышной стратегии, согласно которой остаток до предельной суммы S после каждого его хода должен быть кратен (N+1). Если выигрышный ход сделать невозможно, компьютер должен увеличивать текущую сумму на N. В любом случае приращение суммы на ходе компьютера должно отображаться через поток стандартного вывода. Исходными данными для любой партии игры являются значение суммы S, которую должны набрать игроки, и предельная величина N ее приращения за 1 ход. Эти параметры должны передаваться программе через аргументы командной строки ее вызова. Каждый ход должен сопровождать запрос, который отображает текущую величину суммы и идентифицирует игрока, чей ход ожидается в данный момент. Партию игры должно завершать диагностическое сообщение, которое идентифицирует ее итоговый результат. При разработке программы необходимо реализовать производные классы игроков с виртуальной функцией хода, которые наследуют интерфейс игры и доступ к значению набранной суммы от абстрактного базового класса.

V4

---------------------------------------------------------------------------------------------------------------------

Разработать объектно-ориентированную программу для числовой игры, где 2 игрока должны поочередно наращивать сумму, достигнутую на предыдущем ходе противника, выбирая числовое приращение, которое не превышает заданной фиксированной величины N. Игра должна продолжаться, пока значение суммы, набранной обоими игроками, меньше заданной величины S>N. Победителем считается игрок, который на своем ходе смог первым набрать требуемую сумму M. Игра должна быть реализована в варианте, когда двумя противниками являются компьютер и человек, которому предоставлено право первого хода. Человек может делать любые допустимые ходы, сообщая величину приращения суммы через стандартный ввод. При любой ошибке ввода игра должна аварийно завершаться соответствующим диагностическим сообщением. Компьютер должен действовать по выигрышной стратегии, согласно которой остаток до предельной суммы S после каждого его хода должен быть кратен (N+1). Если выигрышный ход сделать невозможно, компьютер должен увеличивать текущую сумму на 1. В любом случае приращение суммы на ходе компьютера должно отображаться через поток стандартного вывода. Исходными данными для любой партии игры являются значение суммы S, которую должны набрать игроки, и предельная величина N ее приращения за 1 ход. Эти параметры должны передаваться программе через аргументы командной строки ее вызова. Каждый ход должен сопровождать запрос, который отображает текущую величину суммы и идентифицирует игрока, чей ход ожидается в данный момент. Партию игры должно завершать диагностическое сообщение, которое идентифицирует ее итоговый результат. При разработке программы необходимо реализовать производные классы игроков с виртуальной функцией хода, которые наследуют интерфейс игры и доступ к значению набранной суммы от абстрактного базового класса.

V5

---------------------------------------------------------------------------------------------------------------------

Разработать объектно-ориентированную программу для числовой игры, где 2 игрока должны поочередно наращивать сумму, достигнутую на предыдущем ходе противника, выбирая числовое приращение, которое не превышает заданной фиксированной величины N. Игра должна продолжаться, пока значение суммы, набранной обоими игроками, меньше заданной величины S>N. Победителем считается игрок, который на своем ходе смог первым набрать требуемую сумму M. Игра должна быть реализована в варианте, когда двумя противниками являются компьютер и человек, которому предоставлено право первого хода. Человек может делать любые допустимые ходы, сообщая величину приращения суммы через стандартный ввод. При любой ошибке ввода игра должна аварийно завершаться соответствующим диагностическим сообщением. Компьютер должен действовать по выигрышной стратегии, согласно которой остаток до предельной суммы S после каждого его хода должен быть кратен (N+1). Если выигрышный ход сделать невозможно, компьютер должен увеличивать текущую сумму на N. В любом случае приращение суммы на ходе компьютера должно отображаться через поток стандартного вывода. Исходными данными для любой партии игры являются значение суммы S, которую должны набрать игроки, и предельная величина N ее приращения за 1 ход. Эти параметры должны передаваться программе через аргументы командной строки ее вызова. Каждый ход должен сопровождать запрос, который отображает текущую величину суммы и идентифицирует игрока, чей ход ожидается в данный момент. Партию игры должно завершать диагностическое сообщение, которое идентифицирует ее итоговый результат. При разработке программы необходимо реализовать производные классы игроков с виртуальной функцией хода, которые наследуют интерфейс игры и доступ к значению набранной суммы от абстрактного базового класса.

V6

---------------------------------------------------------------------------------------------------------------------

Разработать объектно-ориентированную программу для числовой игры, где 2 игрока должны поочередно наращивать сумму, достигнутую на предыдущем ходе противника, выбирая числовое приращение, которое не превышает заданной фиксированной величины N. Игра должна продолжаться, пока значение суммы, набранной обоими игроками, меньше заданной величины S>N. Победителем считается игрок, который на своем ходе смог первым набрать требуемую сумму M. Игра должна быть реализована в варианте, когда двумя противниками являются компьютер и человек, которому предоставлено право первого хода. Человек может делать любые допустимые ходы, сообщая величину приращения суммы через стандартный ввод. При любой ошибке ввода ему должна предоставляться возможность повторить ход. Компьютер должен действовать по выигрышной стратегии, согласно которой остаток до предельной суммы S после каждого его хода должен быть кратен (N+1). Если выигрышный ход сделать невозможно, компьютер должен увеличивать текущую сумму на 1. В любом случае приращение суммы на ходе компьютера должно отображаться через поток стандартного вывода. Исходными данными для любой партии игры являются значение суммы S, которую должны набрать игроки, и предельная величина N ее приращения за 1 ход. Эти параметры должны передаваться программе через аргументы командной строки ее вызова. Каждый ход должен сопровождать запрос, который отображает текущую величину суммы и идентифицирует игрока, чей ход ожидается в данный момент. Партию игры должно завершать диагностическое сообщение, которое идентифицирует ее итоговый результат. При разработке программы необходимо реализовать производные классы игроков с виртуальной функцией хода, которые наследуют интерфейс игры и доступ к значению набранной суммы от абстрактного базового класса.

V7

---------------------------------------------------------------------------------------------------------------------

Разработать объектно-ориентированную программу для числовой игры, где 2 игрока должны поочередно наращивать сумму, достигнутую на предыдущем ходе противника, выбирая числовое приращение, которое не превышает заданной фиксированной величины N. Игра должна продолжаться, пока значение суммы, набранной обоими игроками, меньше заданной величины S>N. Победителем считается игрок, который на своем ходе смог первым набрать требуемую сумму M. Игра должна быть реализована в варианте, когда двумя противниками являются компьютер и человек, которому предоставлено право первого хода. Человек может делать любые допустимые ходы, сообщая величину приращения суммы через стандартный ввод. При любой ошибке ввода ему должна предоставляться возможность повторить ход. Компьютер должен действовать по выигрышной стратегии, согласно которой остаток до предельной суммы S после каждого его хода должен быть кратен (N+1). Если выигрышный ход сделать невозможно, компьютер должен увеличивать текущую сумму на N. В любом случае приращение суммы на ходе компьютера должно отображаться через поток стандартного вывода. Исходными данными для любой партии игры являются значение суммы S, которую должны набрать игроки, и предельная величина N ее приращения за 1 ход. Эти параметры должны передаваться программе через аргументы командной строки ее вызова. Каждый ход должен сопровождать запрос, который отображает текущую величину суммы и идентифицирует игрока, чей ход ожидается в данный момент. Партию игры должно завершать диагностическое сообщение, которое идентифицирует ее итоговый результат. При разработке программы необходимо реализовать производные классы игроков с виртуальной функцией хода, которые наследуют интерфейс игры и доступ к значению набранной суммы от абстрактного базового класса.

V8

---------------------------------------------------------------------------------------------------------------------

Разработать объектно-ориентированную программу для числовой игры, где 2 игрока должны поочередно наращивать сумму, достигнутую на предыдущем ходе противника, выбирая числовое приращение, которое не превышает заданной фиксированной величины N. Игра должна продолжаться, пока значение суммы, набранной обоими игроками, меньше заданной величины S>N. Победителем считается игрок, который на своем ходе смог первым набрать требуемую сумму M. Игра должна быть реализована в варианте, когда двумя противниками являются компьютер и человек, которому предоставлено право первого хода. Человек может делать любые допустимые ходы, сообщая величину приращения суммы через стандартный ввод. При любой ошибке ввода сумма автоматически увеличивается на 1, и ход передается компьютеру. Компьютер должен действовать по выигрышной стратегии, согласно которой остаток до предельной суммы S после каждого его хода должен быть кратен (N+1). Если выигрышный ход сделать невозможно, компьютер должен повторить ход человека. В любом случае величина приращения суммы на ходе компьютера должна отображаться через поток стандартного вывода. Исходными данными для любой партии игры являются значение суммы S, которую должны набрать игроки, и предельная величина N ее приращения за 1 ход. Эти параметры должны передаваться программе через аргументы командной строки ее вызова. Каждый ход должен сопровождать запрос, который отображает текущую величину суммы и идентифицирует игрока, чей ход ожидается в данный момент. Партию игры должно завершать диагностическое сообщение, которое идентифицирует ее итоговый результат. При разработке программы необходимо реализовать производные классы игроков с виртуальной функцией хода, которые наследуют интерфейс игры и доступ к значению набранной суммы от абстрактного базового класса.

V9

---------------------------------------------------------------------------------------------------------------------

Разработать объектно-ориентированную программу для числовой игры, где 2 игрока должны поочередно наращивать сумму, достигнутую на предыдущем ходе противника, выбирая числовое приращение, которое не превышает заданной фиксированной величины N. Игра должна продолжаться, пока значение суммы, набранной обоими игроками, меньше заданной величины S>N. Победителем считается игрок, который на своем ходе смог первым набрать требуемую сумму M. Игра должна быть реализована в варианте, когда двумя противниками являются компьютер и человек, которому предоставлено право первого хода. Человек может делать любые допустимые ходы, сообщая величину приращения суммы через стандартный ввод. При любой ошибке ввода сумма автоматически увеличивается на N, и ход передается компьютеру. Компьютер должен действовать по выигрышной стратегии, согласно которой остаток до предельной суммы S после каждого его хода должен быть кратен (N+1). Если выигрышный ход сделать невозможно, компьютер должен повторить ход человека. В любом случае величина приращения суммы на ходе компьютера должна отображаться через поток стандартного вывода. Исходными данными для любой партии игры являются значение суммы S, которую должны набрать игроки, и предельная величина N ее приращения за 1 ход. Эти параметры должны передаваться программе через аргументы командной строки ее вызова. Каждый ход должен сопровождать запрос, который отображает текущую величину суммы и идентифицирует игрока, чей ход ожидается в данный момент. Партию игры должно завершать диагностическое сообщение, которое идентифицирует ее итоговый результат. При разработке программы необходимо реализовать производные классы игроков с виртуальной функцией хода, которые наследуют интерфейс игры и доступ к значению набранной суммы от абстрактного базового класса.

V10

---------------------------------------------------------------------------------------------------------------------

Разработать объектно-ориентированную программу для числовой игры, где 2 игрока должны поочередно выбирать из кучи заданного размера S любое количество предметов, которое не превышает фиксированного значения N<S. Игра должна продолжаться, пока текущий размер кучи больше 0. Победителем считается игрок, который взял последний предмет кучи. Игра должна быть реализована в варианте, когда двумя противниками являются компьютер и человек, которому предоставляется право первого хода. Человек может делать любые допустимые ходы, сообщая число взятых им предметов через стандартный ввод. При любой ошибке ввода размер кучи автоматически уменьшается на 1, и ход передается компьютеру. Компьютер должен действовать по выигрышной стратегии, согласно которой остаток кучи после каждого его хода должен быть кратен (N+1). Если такой выигрышный ход сделать невозможно, компьютер должен взять из кучи 1 предмет. В любом случае число предметов, которое взял из кучи компьютер должно отображаться через поток стандартного вывода. Исходными данными для любой партии игры являются размер кучи S и предельное число предметов N, которое можно взять из кучи за 1 ход. Эти параметры должны передаваться программе через аргументы командной строки ее вызова. Каждый ход должен сопровождать информационный запрос, который отображает текущий размер кучи и идентифицирует игрока, чей ход ожидается в данный момент. Игра должна завершаться диагностическим сообщением, которое идентифицирует ее итоговый результат. При разработке программы необходимо реализовать производные классы игроков с виртуальной функцией хода, которые наследуют интерфейс игры и доступ к куче от абстрактного базового класса.

V11

---------------------------------------------------------------------------------------------------------------------

Разработать объектно-ориентированную программу для числовой игры, где 2 игрока должны поочередно выбирать из кучи заданного размера S любое количество предметов, которое не превышает фиксированного значения N<S. Игра должна продолжаться, пока текущий размер кучи больше 0. Победителем считается игрок, который взял последний предмет кучи. Игра должна быть реализована в варианте, когда двумя противниками являются компьютер и человек, которому предоставляется право первого хода. Человек может делать любые допустимые ходы, сообщая число взятых им предметов через стандартный ввод. При любой ошибке ввода размер кучи автоматически уменьшается на 1, и ход передается компьютеру. Компьютер должен действовать по выигрышной стратегии, согласно которой остаток кучи после каждого его хода должен быть кратен (N+1). Если такой выигрышный ход сделать нельзя, компьютер должен взять из кучи N предметов. В любом случае число предметов, которое взял из кучи компьютер должно отображаться через поток стандартного вывода. Исходными данными для любой партии игры являются размер кучи S и предельное число предметов N, которое можно взять из кучи за 1 ход. Эти параметры должны передаваться программе через аргументы командной строки ее вызова. Каждый ход должен сопровождать информационный запрос, который отображает текущий размер кучи и идентифицирует игрока, чей ход ожидается в данный момент. Игра должна завершаться диагностическим сообщением, которое идентифицирует ее итоговый результат. При разработке программы необходимо реализовать производные классы игроков с виртуальной функцией хода, которые наследуют интерфейс игры и доступ к куче от абстрактного базового класса.

V12

---------------------------------------------------------------------------------------------------------------------Разработать объектно-ориентированную программу для числовой игры, где 2 игрока должны поочередно выбирать из кучи заданного размера S любое количество предметов, которое не превышает фиксированного значения N<S. Игра должна продолжаться, пока текущий размер кучи больше 0. Победителем считается игрок, который взял последний предмет кучи. Игра должна быть реализована в варианте, когда двумя противниками являются компьютер и человек, которому предоставляется право первого хода. Человек может делать любые допустимые ходы, сообщая число взятых им предметов через стандартный ввод. При любой ошибке ввода размер кучи автоматически уменьшается на N, и ход передается компьютеру. Компьютер должен действовать по выигрышной стратегии, согласно которой остаток кучи после каждого его хода должен быть кратен (N+1). Если такой выигрышный ход сделать невозможно, компьютер должен взять из кучи 1 предмет. В любом случае число предметов, которое взял из кучи компьютер должно отображаться через поток стандартного вывода. Исходными данными для любой партии игры являются размер кучи S и предельное число предметов N, которое можно взять из кучи за 1 ход. Эти параметры должны передаваться программе через аргументы командной строки ее вызова. Каждый ход должен сопровождать информационный запрос, который отображает текущий размер кучи и идентифицирует игрока, чей ход ожидается в данный момент. Игра должна завершаться диагностическим сообщением, которое идентифицирует ее итоговый результат. При разработке программы необходимо реализовать производные классы игроков с виртуальной функцией хода, которые наследуют интерфейс игры и доступ к куче от абстрактного базового класса.

V13

---------------------------------------------------------------------------------------------------------------------Разработать объектно-ориентированную программу для числовой игры, где 2 игрока должны поочередно выбирать из кучи заданного размера S любое количество предметов, которое не превышает фиксированного значения N<S. Игра должна продолжаться, пока текущий размер кучи больше 0. Победителем считается игрок, который взял последний предмет кучи. Игра должна быть реализована в варианте, когда двумя противниками являются компьютер и человек, которому предоставляется право первого хода. Человек может делать любые допустимые ходы, сообщая число взятых им предметов через стандартный ввод. При любой ошибке ввода размер кучи автоматически уменьшается на N, и ход передается компьютеру. Компьютер должен действовать по выигрышной стратегии, согласно которой остаток кучи после каждого его хода должен быть кратен (N+1). Если такой выигрышный ход сделать нельзя, компьютер должен взять из кучи N предметов. В любом случае число предметов, которое взял из кучи компьютер должно отображаться через поток стандартного вывода. Исходными данными для любой партии игры являются размер кучи S и предельное число предметов N, которое можно взять из кучи за 1 ход. Эти параметры должны передаваться программе через аргументы командной строки ее вызова. Каждый ход должен сопровождать информационный запрос, который отображает текущий размер кучи и идентифицирует игрока, чей ход ожидается в данный момент. Игра должна завершаться диагностическим сообщением, которое идентифицирует ее итоговый результат. При разработке программы необходимо реализовать производные классы игроков с виртуальной функцией хода, которые наследуют интерфейс игры и доступ к куче от абстрактного базового класса.

V14

---------------------------------------------------------------------------------------------------------------------

Разработать объектно-ориентированную программу для числовой игры, где 2 игрока должны поочередно выбирать из кучи заданного размера S любое количество предметов, которое не превышает фиксированного значения N<S. Игра должна продолжаться, пока текущий размер кучи больше 0. Победителем считается игрок, который взял последний предмет кучи. Игра должна быть реализована в варианте, когда двумя противниками являются компьютер и человек, которому предоставляется право первого хода. Человек может делать любые допустимые ходы, сообщая число взятых им предметов через стандартный ввод. При любой ошибке ввода партия игры должна аварийно завершаться с соответствующей диагностикой. Компьютер должен действовать по выигрышной стратегии, согласно которой остаток кучи после каждого его хода должен быть кратен (N+1). Если такой выигрышный ход сделать невозможно, компьютер должен взять из кучи 1 предмет. В любом случае число предметов, которое взял из кучи компьютер должно отображаться через поток стандартного вывода. Исходными данными для любой партии игры являются размер кучи S и предельное число предметов N, которое можно взять из кучи за 1 ход. Эти параметры должны передаваться программе через аргументы командной строки ее вызова. Каждый ход должен сопровождать информационный запрос, который отображает текущий размер кучи и идентифицирует игрока, чей ход ожидается в данный момент. Игра должна завершаться диагностическим сообщением, которое идентифицирует ее итоговый результат. При разработке программы необходимо реализовать производные классы игроков с виртуальной функцией хода, которые наследуют интерфейс игры и доступ к куче от абстрактного базового класса.

V15

---------------------------------------------------------------------------------------------------------------------

Разработать объектно-ориентированную программу для числовой игры, где 2 игрока должны поочередно выбирать из кучи заданного размера S любое количество предметов, которое не превышает фиксированного значения N<S. Игра должна продолжаться, пока текущий размер кучи больше 0. Победителем считается игрок, который взял последний предмет кучи. Игра должна быть реализована в варианте, когда двумя противниками являются компьютер и человек, которому предоставляется право первого хода. Человек может делать любые допустимые ходы, сообщая число взятых им предметов через стандартный ввод. При любой ошибке ввода партия игры должна аварийно завершаться с соответствующей диагностикой. Компьютер должен действовать по выигрышной стратегии, согласно которой остаток кучи после каждого его хода должен быть кратен (N+1). Если такой выигрышный ход сделать нельзя, компьютер должен взять из кучи N предметов. В любом случае число предметов, которое взял из кучи компьютер должно отображаться через поток стандартного вывода. Исходными данными для любой партии игры являются размер кучи S и предельное число предметов N, которое можно взять из кучи за 1 ход. Эти параметры должны передаваться программе через аргументы командной строки ее вызова. Каждый ход должен сопровождать информационный запрос, который отображает текущий размер кучи и идентифицирует игрока, чей ход ожидается в данный момент. Игра должна завершаться диагностическим сообщением, которое идентифицирует ее итоговый результат. При разработке программы необходимо реализовать производные классы игроков с виртуальной функцией хода, которые наследуют интерфейс игры и доступ к куче от абстрактного базового класса.

V16

---------------------------------------------------------------------------------------------------------------------

Разработать объектно-ориентированную программу для числовой игры, где 2 игрока должны поочередно выбирать из кучи заданного размера S любое количество предметов, которое не превышает фиксированного значения N<S. Игра должна продолжаться, пока текущий размер кучи больше 0. Победителем считается игрок, который взял последний предмет кучи. Игра должна быть реализована в варианте, когда двумя противниками являются компьютер и человек, которому предоставляется право первого хода. Человек может делать любые допустимые ходы, сообщая число взятых им предметов через стандартный ввод. При любой ошибке ввода ему должна предоставляться возможность повторить ход. Компьютер должен действовать по выигрышной стратегии, согласно которой остаток кучи после каждого его хода должен быть кратен (N+1). Если такой выигрышный ход сделать невозможно, компьютер должен взять из кучи 1 предмет. В любом случае число предметов, которое взял из кучи компьютер должно отображаться через поток стандартного вывода. Исходными данными для любой партии игры являются размер кучи S и предельное число предметов N, которое можно взять из кучи за 1 ход. Эти параметры должны передаваться программе через аргументы командной строки ее вызова. Каждый ход партии игры должен сопровождать информационный запрос, который отображает текущий размер кучи и идентифицирует игрока, чей ход ожидается в данный момент. Игра должна завершаться диагностическим сообщением, которое идентифицирует ее итоговый результат. При разработке программы необходимо реализовать производные классы игроков с виртуальной функцией хода, которые наследуют интерфейс игры и доступ к куче от абстрактного базового класса.

V17

---------------------------------------------------------------------------------------------------------------------

Разработать объектно-ориентированную программу для числовой игры, где 2 игрока должны поочередно выбирать из кучи заданного размера S любое количество предметов, которое не превышает фиксированного значения N<S. Игра должна продолжаться, пока текущий размер кучи больше 0.