Простые Peg

Я новичок в кодировании, и этот код в значительной степени зависит от моих текущих знаний. Я ищу способы улучшить этот код. Этот код компилируется и работает отлично в Visual Studio 2013. Я также использую Windows 8.1 в качестве моей текущей ОС для компьютера, который я пишу и компилирую.

Я бы хотел просмотреть что-нибудь и любые ошибки с математикой, участвующей в игре, или ошибки в игре.

Что этот код должен делать и от моего тестирования. Является простой игрой, в которой есть два игрока, которые берут привязки с кольца, один игрок - пользователь (человек), другой игрок - компьютер. В зависимости от того, что движет пользователь, компьютер отвечает идеальным движением. Если нет идеального движения, компьютер делает случайный ход с 1-го кольца от случайного привязки, в основном пытающегося замедлить игру, давая больше шансов, чтобы пользователь-пользователь допустил ошибку.

Математика, участвующая в этом, в основном делает так, что игрок 1 всегда может побеждать. Компьютер должен знать каждый идеальный ход и реагировать на основе действий пользователя. Но поскольку компьютер может пойти вторым, он просто ждет ошибки, сделанной пользователем пользователя или пытается замедлить игру.

#include<iostream>
#include<string>
#include<stdlib.h>
#include<time.h>

using namespace std;

int main()
{
    char cAgain;
    do
    {
        //Variable Declartion
        int x, PegTotal, PegOne = 3, PegTwo = 5, PegThree = 7, Player, y;
        bool switchRepeat = true;
        cout << "Welcome to the 3 Peg game!!!" << endl;
        cout << "This is a 2 player game." << endl << endl;
        cout << "The game has 3 pegs and 15 rings." << endl
            << "The first peg has 3 rings, the second peg has 5, and the third peg has 7." << endl
            << "The object of the game is to get the other player to take off the last ring." << endl << endl;
        system("PAUSE");
        system("CLS");
        cout << "The rules of the game are as follow:" << endl
            << "1. You must take at least one ring off a peg per turn." << endl
            << "2. You can only take rings off a single peg in a given turn." << endl
            << "3. You can take as many rings off a single peg as you like." << endl
            << "4. You cannot skip a turn." << endl
            << "5. The player who takes the last ring off loses." << endl << endl;
        system("PAUSE");
        system("CLS");

        do
        {
            cout << "Would you like to go first or second?(Type 1 or 2)" << endl;
            cin >> Player;


            if (Player == 1)
            {
                cout << "You are player one!" << endl
                    << "You will go first." << endl << endl;
                goto check;
            }
            else if (Player == 2)
            {
                cout << "You are player 2!" << endl
                    << "You will go second" << endl << endl;
                cout << "Game Master takes 3 rings off peg 3" << endl;
                PegThree = 4;
                do
                {
                    check:
                    system("PAUSE");
                    system("CLS");
                    do
                    {
                        PegTotal = PegOne + PegTwo + PegThree;
                        if (PegTotal == 1)
                        {
                            cout << "Peg One has " << PegOne << " rings left." << endl
                                << "Peg Two has " << PegTwo << " rings left." << endl
                                << "Peg Three has " << PegThree << " rings left." << endl << endl;
                            cout << "You must take the last ring. Your Lose!!!" << endl;
                            system("PAUSE");
                            system("CLS");
                            goto end;
                        }
                        else if (PegTotal == 0)
                        {
                            break;
                        }
                        else
                            cout << "Peg One has " << PegOne << " rings left." << endl
                            << "Peg Two has " << PegTwo << " rings left." << endl
                            << "Peg Three has " << PegThree << " rings left." << endl << endl;
                        cout << "Which peg will you take rings from?" << endl;
                        cin >> x;
                        if ((x == 1) && (PegOne == 0) || (x == 2) && (PegTwo == 0) || (x == 3) && (PegThree == 0))
                        {
                            cout << "That peg is empty." << endl;
                            system("PAUSE");
                            system("CLS");
                        }
                        else if (x != 1 && x != 2 && x != 3)
                        {
                            cout << "That is not a peg." << endl;
                            system("PAUSE");
                            system("CLS");
                        }
                    } while ((x != 1 && x != 2 && x != 3) || ((x == 1) && (PegOne == 0) || (x == 2) && (PegTwo == 0) || (x == 3) && (PegThree == 0)));


                    do
                    {
                        switch (x)
                        {
                        case 1:
                            cout << "How many rings would you like to take from peg " << x << ". Max(" << PegOne << ")." << endl;
                            cin >> y;
                            if (y > PegOne)
                            {
                                cout << "There are not that many rings on that peg." << endl << endl;
                                system("PAUSE");
                                system("CLS");
                                break;
                            }
                            else
                            {
                                PegOne = PegOne - y;
                                y = 0;
                                switchRepeat = false;
                                break;
                            }
                        case 2:
                            cout << "How many rings would you like to take from peg " << x << ". Max(" << PegTwo << ")." << endl;
                            cin >> y;
                            if (y > PegTwo)
                            {
                                cout << "There are not that many rings on that peg." << endl << endl;
                                system("PAUSE");
                                system("CLS");
                                break;
                            }
                            else
                            {
                                PegTwo = PegTwo - y;
                                y = 0;
                                switchRepeat = false;
                                break;
                            }
                        case 3:
                            cout << "How many rings would you like to take from peg " << x << ". Max(" << PegThree << ")." << endl;
                            cin >> y;
                            if (y > PegThree)
                            {
                                cout << "There are not that many rings on that peg." << endl << endl;
                                system("PAUSE");
                                system("CLS");
                                break;
                            }
                            else
                            {
                                PegThree = PegThree - y;
                                y = 0;
                                switchRepeat = false;
                                break;
                            }
                        default:
                            switchRepeat = false;
                            break;
                        }
                    } while (switchRepeat == true);
                    PegTotal = PegOne + PegTwo + PegThree;

                    //----------------------------Peg Three Operations----------------------------
                    if ((PegThree > PegOne && PegThree> PegTwo) && PegThree > 1)
                    {
                        if (PegThree > PegOne && PegTwo > PegOne && PegOne != 0)
                        {
                            PegThree = PegThree - PegOne;
                            cout << "The Game Master takes " << PegOne << " rings from peg three." << endl;
                            //cout << "3-1" << endl;
                        }
                        else if ((PegTwo == 0 && PegOne == 1) || (PegOne == 0 && PegTwo == 1))
                        {
                            cout << "The Game Master takes " << PegThree << " rings from peg three." << endl;
                            PegThree = 0;
                            //cout << "3-2" << endl;
                        }
                        else if (PegThree > PegTwo && PegOne > PegTwo && PegTwo != 0)
                        {
                            PegThree = PegThree - PegTwo;
                            cout << "The Game Master takes " << PegTwo << " rings from peg three." << endl;
                            //cout << "3-3" << endl;
                        }
                        else if (PegTwo == 0 && PegOne == 0)
                        {
                            cout << "The Game Master takes " << (PegThree-1) << " rings from peg three." << endl;
                            PegThree = PegThree - (PegThree - 1);
                            //cout << "3-4" << endl;
                        }
                        else if ((PegThree > 3) > PegTwo >= (PegOne == 0) || ((PegThree > 3) > PegOne > (PegTwo == 0)))
                        {
                            PegThree--;
                            cout << "The Game Master takes 1 rings from peg three." << endl;
                            //cout << "3-5" << endl;
                        }
                    }
                    //-------------------------Peg Two Operations-------------------------------
                    else if ((PegTwo > PegOne && PegTwo > PegThree) && PegTwo > 1)
                    {
                        if (PegTwo > PegOne && PegThree > PegOne && PegOne != 0)
                        {
                            PegTwo = PegTwo - PegOne;
                            cout << "The Game Master takes " << PegOne << " rings from peg two." << endl;
                            //cout << "2-1" << endl;
                        }
                        else if ((PegThree == 0 && PegOne == 1) || (PegOne == 0 && PegThree == 1))
                        {
                            cout << "The Game Master takes " << PegTwo << " rings from peg three." << endl;
                            PegTwo = 0;
                            //cout << "2-2" << endl;
                        }
                        else if (PegTwo > PegThree && PegOne > PegThree && PegThree != 0)
                        {
                            PegTwo = PegTwo - PegThree;
                            cout << "The Game Master takes " << PegThree << " rings from peg two." << endl;
                            //cout << "2-3" << endl;
                        }
                        else if (PegThree == 0 && PegOne == 0)
                        {
                            cout << "The Game Master takes " << (PegTwo-1) << " rings from peg two." << endl;
                            PegTwo = PegTwo - (PegTwo - 1);
                            //cout << "2-4" << endl;
                        }
                        else if ((PegTwo > 3) > PegThree >= (PegOne == 0) || ((PegTwo > 3) > PegOne > (PegThree == 0)))
                        {
                            PegTwo--;
                            cout << "The Game Master takes 1 rings from peg two." << endl;
                            //cout << "2-5" << endl;
                        }
                    }
                    //----------------------Peg One Operations---------------------------------
                    else if ((PegOne > PegTwo && PegOne >> PegThree) && PegOne > 1)
                    {
                        if (PegOne > PegTwo && PegTwo > PegThree && PegThree != 0)
                        {
                            PegOne = PegOne - PegThree;
                            cout << "The Game Master takes " << PegThree << " rings from peg one." << endl;
                            //cout << "1-1" << endl;
                        }
                        else if ((PegTwo == 0 && PegThree == 1) || (PegThree == 0 && PegTwo == 1))
                        {
                            cout << "The Game Master takes " << PegOne << " rings from peg three." << endl;
                            PegOne = 0;
                            //cout << "1-2" << endl;
                        }
                        else if (PegOne > PegThree && PegThree > PegTwo && PegTwo != 0)
                        {
                            PegOne = PegOne - PegTwo;
                            cout << "The Game Master takes " << PegTwo << " rings from peg one." << endl;
                            //cout << "1-3" << endl;
                        }
                        else if (PegTwo == 0 && PegThree == 0)
                        {
                            cout << "The Game Master takes " << PegOne << " rings from peg one." << endl;
                            PegOne = PegOne - (PegOne - 1);
                            //cout << "1-4" << endl;
                        }
                        else if ((PegOne > 3) > PegTwo >= (PegThree == 0) || ((PegOne > 3) > PegThree > (PegTwo == 0)))
                        {
                            PegOne--;
                            cout << "The Game Master takes 1 rings from peg one." << endl;
                            //cout << "1-5" << endl;
                        }
                    }
                    //------------------Computer must take last ring------------------
                    else if (PegTotal == 1)
                    {
                        cout << "The Game Master takes the last ring." << endl
                            << "You Win!!!" << endl;
                        goto end;
                    }
                    //-------------------Computer has no winning scenarios-------------
                    else
                    {
                        do
                        {
                            srand(time(NULL));
                            x = rand() % 3 + 1;
                            if ((x == 1) && (PegOne == 0) || (x == 2) && (PegTwo == 0) || (x == 3) && (PegThree == 0))
                            {
                                //cout << "Error 01 x= " << x << endl;
                            }
                            else if (x != 1 && x != 2 && x != 3)
                            {
                                //cout << "Error 02 x= "<< x << endl;
                            }
                            else
                            {
                                cout << "The Game Master takes 1 ring from peg " << x << "." << endl;
                                break;
                            }
                        } while ((x != 1 && x != 2 && x != 3) || ((x == 1) && (PegOne == 0) || (x == 2) && (PegTwo == 0) || (x == 3) && (PegThree == 0)));

                        if ((x == 1 && PegOne != 0))
                        {
                            PegOne = PegOne - 1;
                            //cout << "PegOne-1" << endl;
                            goto check;
                        }
                        else if ((x == 2 && PegTwo != 0))
                        {
                            PegTwo = PegTwo - 1;
                            //cout << "PegTwo-1" << endl;
                            goto check;
                        }
                        else if ((x == 3 && PegThree != 0))
                        {
                            PegThree = PegThree - 1;
                            //cout << "PegThree-1" << endl;
                            goto check;
                        }
                    }
                } while (PegOne > 0 || PegTwo > 0 || PegThree > 0);
            }
            else
            {
                cout << "You must choose to be player 1 or 2." << endl;
                system("PAUSE");
                system("CLS");
            }
        } while (Player != 1 && Player != 2);
        end:
        cout << "Would you like to play again?(Y/N)" << endl;
            cin >> cAgain;
            system("CLS");
    } while (cAgain == 'Y' || cAgain == 'y');
return 0;
}

Здесь - это .cpp-файл.

11 голосов | спросил Styx 23 TueEurope/Moscow2014-12-23T16:25:38+03:00Europe/Moscow12bEurope/MoscowTue, 23 Dec 2014 16:25:38 +0300 2014, 16:25:38

2 ответа


18
using namespace std;

Это может быть плохой привычкой развиваться. См. Почему используется неправильная практика namespace std?

    //Variable Declartion

опечатка.

    //Variable Declarations
    int x, PegTotal, PegOne = 3, PegTwo = 5, PegThree = 7, Player, y;
    bool switchRepeat = true;

В C ++ вам не нужно объявлять свои переменные в начале. Вы можете объявить их перед тем, как начать их использовать. Это помогает отслеживать каждую переменную.

В этом случае вы, вероятно, должны объявить некоторые из них в классе. Однако это довольно большой скачок от текущего состояния кода.

Постарайтесь использовать заглавные буквы. Общие стандарты для имени переменной - это camelCase или snake_case. Переменная switchRepeat - camelCase, поэтому вы должны, вероятно, сделать Player и PegTotal в player и pegTotal соответственно.

Если вы видите, что вы указываете имена переменных с числами в них, подумайте об использовании коллекции, чтобы удерживать их.

    std::array<int, 3> pegs = { 3, 5, 7 };

Я делаю коллекции множественного числа. Теперь pegs[0] равен 3, просто как PegOne был.

    system("PAUSE");
    system("CLS");

Использование системных команд, подобных этому, может быть рискованным. Дополнительную информацию см. В ответе Эдварда здесь .

У вас невероятное количество гнездования и вы должны использовать функции для абстрагирования некоторых функций. Например.

void showHelp() {
    cout << "Welcome to the 3 Peg game!!!" << endl;
    cout << "This is a 2 player game." << endl << endl;
    cout << "The game has 3 pegs and 15 rings." << endl
         << "The first peg has 3 rings, the second peg has 5, and the third peg has 7." << endl
         << "The object of the game is to get the other player to take off the last ring." << endl << endl;
    system("PAUSE");
    system("CLS");
    cout << "The rules of the game are as follow:" << endl
         << "1. You must take at least one ring off a peg per turn." << endl
         << "2. You can only take rings off a single peg in a given turn." << endl
         << "3. You can take as many rings off a single peg as you like." << endl
         << "4. You cannot skip a turn." << endl
         << "5. The player who takes the last ring off loses." << endl << endl;
    system("PAUSE");
    system("CLS");
}

Теперь вы можете просто вызвать showHelp() всякий раз, когда вы хотите отобразить это.

        cout << "Would you like to go first or second?(Type 1 or 2)" << endl;
        cin >> Player;


        if (Player == 1)
        {
            cout << "You are player one!" << endl
                << "You will go first." << endl << endl;
            goto check;
        }
        else if (Player == 2)
        {
            cout << "You are player 2!" << endl
                << "You will go second" << endl << endl;
            cout << "Game Master takes 3 rings off peg 3" << endl;
            PegThree = 4;
            do
            {
                check:

В этом случае тривиально писать код таким образом, что не требуется код goto. Обратите внимание, что вам не нужно вставлять do с помощью check: в нем внутри предложения else.

    do
    {
        cout << "Would you like to go first or second?(Type 1 or 2)" << endl;
        cin >> player;
    } while ( player != 1 && player != 2 );


    if (player == 1)
    {
        cout << "You are player one!" << endl
             << "You will go first." << endl << endl;
    }
    else 
    {
        cout << "You are player 2!" << endl
             << "You will go second" << endl << endl;
        cout << "Game Master takes 3 rings off peg 3" << endl;
        pegs[2] = 4;
    }

    do
    {
        check:

Таким образом, вы избавляетесь от двух уровней вложенности, а также для исключения goto. Но мы, вероятно, хотим пойти вперед и сделать пару функций из этого тоже.

enum Turn { YOU, GAME_MASTER };

Но сначала объявим enum. При этом мы можем указать, кто делает то, что не использует целые числа.

void removeRings(std::array<int,3> & pegs, std::size_t peg, int quantity, Turn turn)
{
    switch ( turn )
    {
        case YOU:
            std::cout << "You take ";
            break;
        case GAME_MASTER:
            std::cout << "Game Master takes ";
            break;
    }

    std::cout << quantity << " rings off peg "
    std::cout << peg + 1 << endl;

    pegs[peg] -= quantity;
}

Эта функция просто предоставляет стандартный способ представления движения. Определив функцию, мы помещаем все экземпляры, где мы объявляем перемещение в одном и том же месте. В исходном коде, если вы хотите изменить способ вывода этого файла, вам придется делать изменения повсюду.

Введем идею параметров функции. Первый параметр, pegs, передается по ссылке. Вы можете сказать, потому что у него есть & между типом и именем переменной, которое будет использоваться в этой функции. Мы даем pegs одно и то же имя в функции, как это было в вызывающем, но нам не нужно было этого делать. Это было просто лучшее имя в обоих местах. Передано ссылкой означает, что нам не нужно создавать новую копию объекта и позволяет нам изменять исходный объект во время функции. Остальные три параметра передаются по значению.

В конце, pegs[peg] -= quantity; совпадает с записью pegs[peg] = pegs[peg] - quantity;. Он просто сохраняет повторяющийся pegs[peg].

Вы можете видеть, что он используется в следующей функции:

void chooseTurn(std::array<int,3> & pegs)
{
    int player = 0;

    while ( true )
    {
        cout << "Would you like to go first or second?(Type 1 or 2)" << endl;
        cin >> player;

        if ( 1 == player )
        {
            cout << "You are player one!" << endl
                 << "You will go first." << endl << endl;
            return;
        }
        else if ( 2 == player )
        {
            cout << "You are player 2!" << endl
                 << "You will go second" << endl << endl;
            removeRings(pegs, 2, 3, GAME_MASTER);
            return;
        }
        else
        {
            cout << "You must choose to be player 1 or 2." << endl;
            system("PAUSE");
            system("CLS");
        }
    }
}

Теперь у нас есть этот код в функции. Есть аргумент, что это должно быть две функции в том, что он считывает входное значение, и он отвечает, но я не сторонник чистоты. Выполнение этого способа означает, что нам не нужно player вне этой функции.

Мы также перемещаемelse гораздо ближе к другим предложениям. Я пропустил это полностью, когда впервые написал эту функцию. Я нашел его только потому, что проверял, где определен player.

Я перевернул порядок проверки равенства: 1 == player. Причина этого заключается в том, что в большинстве языков стиля C if ( player = 1 ) является допустимым оператором, но 1 = player нет. Последняя версия даст ошибку компилятора, если вы сделаете эту опечатку. Первая версия будет спокойно присваивать проигрывателю 1 и оценивать как true для if.

Примечание. Обычно я предпочитаю не использовать метод loop forever. Причина, по которой здесь требуется, - не повторять те же проверки, что и if.

        PegTotal = PegOne + PegTwo + PegThree;

Так как у нас есть pegs, мы можем записать это в более общем плане.

        pegTotal = std::accumulate(pegs.begin(), pegs.end(), 0);

Теперь, даже если мы добавим больше колышек, код будет содержать их все.

        if (PegTotal == 1)
        {
            cout << "Peg One has " << PegOne << " rings left." << endl
                << "Peg Two has " << PegTwo << " rings left." << endl
                << "Peg Three has " << PegThree << " rings left." << endl << endl;
            cout << "You must take the last ring. Your Lose!!!" << endl;
            system("PAUSE");
            system("CLS");
            goto end;
        }
        else if (PegTotal == 0)
        {
            break;
        }
        else
            cout << "Peg One has " << PegOne << " rings left." << endl
            << "Peg Two has " << PegTwo << " rings left." << endl
            << "Peg Three has " << PegThree << " rings left." << endl << endl;

Это можно записать проще:

        if ( 0 == PegTotal )
        {
            break;
        }

        displayPegs(pegs);

        if ( 1 == PegTotal )
        {
            cout << "You must take the last ring. You Lose!!!" << endl;
            system("PAUSE");
            system("CLS");
            goto end;
        }

Сначала проверьте код 0. Так как у него есть break, ему не нужен else.

Во-вторых, после этого мы показываем подсчеты пегаса в обоих дорожках. Поэтому сначала отобразите его. Используйте функцию для ее абстрагирования.

В-третьих, нам не нужен else для 1. Мы уже показывали подсчеты привязки, что и все else.

Наконец, переместите его перед циклом, где мы получим выбор привязки игрока. Пока игрок не сделает выбор, это не изменится.

void displayPegs(const std::array<int,3> & pegs)
{
    cout << "Peg One has " << pegs[0] << " rings left." << endl
         << "Peg Two has " << pegs[1] << " rings left." << endl
         << "Peg Three has " << pegs[2] << " rings left." << endl << endl;
}

Мы передаем pegs как const ссылка, короткая для постоянной ссылки. Это означает, что мы не изменяем pegs в этой функции. Мы читаем только это.

                do
                {
                    cout << "Which peg will you take rings from?" << endl;
                    cin >> x;
                    if ((x == 1) && (PegOne == 0) || (x == 2) && (PegTwo == 0) || (x == 3) && (PegThree == 0))
                    {
                        cout << "That peg is empty." << endl;
                        system("PAUSE");
                        system("CLS");
                    }
                    else if (x != 1 && x != 2 && x != 3)
                    {
                        cout << "That is not a peg." << endl;
                        system("PAUSE");
                        system("CLS");
                    }
                } while ((x != 1 && x != 2 && x != 3) || ((x == 1) && (PegOne == 0) || (x == 2) && (PegTwo == 0) || (x == 3) && (PegThree == 0)));

Мы можем переместить все это в функцию:

                x = choosePeg(pegs);

Что мы определяем следующим образом:

std::size_t choosePeg(const std::array<int,3> & pegs)
{
    std::size_t x;

    while ( true )
    {
        cout << "Which peg will you take rings from?" << endl;
        cin >> x;

        if ( 1 > x || pegs.size() < x )
        {
            cout << "That is not a peg." << endl;
            system("PAUSE");
            system("CLS");
        }
        else if ( 0 >= pegs(--x) )
        {
            cout << "That peg is empty." << endl;
            system("PAUSE");
            system("CLS");
        }
        else
        {
            return x;
        }

        displayPegs(pegs);
    }
}

Мы зацикливаемся навсегда, получая выбор привязки со стандартного ввода. Мы проверяем, находится ли выбор в диапазоне коллекции. Если нет, мы говорим пользователю, что это не привязка. Если это так, мы проверяем, есть ли какие-либо кольца на этом колышке. Если нет, мы предупреждаем пользователя. Если да, мы возвращаем это значение x вызывающему абоненту (который заканчивает цикл). Если мы не вернемся, мы снова покажем привязки и перезапустим цикл.

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

                        if (y > PegOne)
                        {
                            cout << "There are not that many rings on that peg." << endl << endl;
                            system("PAUSE");
                            system("CLS");
                            break;
                        }
                        else
                        {
                            PegOne = PegOne - y;
                            y = 0;
                            switchRepeat = false;
                            break;
                        }

Вам не нужно писать break; в обеих ветвях if здесь.

                        if (y > PegOne)
                        {
                            cout << "There are not that many rings on that peg." << endl << endl;
                            system("PAUSE");
                            system("CLS");
                        }
                        else
                        {
                            PegOne = PegOne - y;
                            y = 0;
                            switchRepeat = false;
                        }

                        break;

Как правило, старайтесь избегать повторения кода, если вам этого не нужно.

В этом случае, однако, мы можем полностью исключить оператор switch. Различные случаи можно упростить до одного и ввести в функцию.

void removeRings(std::array<int,3> & pegs, std::size_t peg)
{
    std::size_t display_peg = peg + 1;

    while ( true )
    {
        int ring_count = 0;

        cout << "How many rings would you like to take from peg " << display_peg << ". Max(" << pegs(peg) << ")." << endl;
        cin >> ring_count;

        if ( ring_count > pegs[peg] )
        {
            cout << "There are not that many rings on that peg." << endl << endl;
            system("PAUSE");
            system("CLS");
        }
        else
        {
            removeRings(pegs, peg, ring_count, YOU);
            return;
        }
    }
}

Мы сделали здесь что-то интересное. Мы перегрузили функцию, переопределив ее различными параметрами. Теперь компилятор определит, какую функцию вызывать по параметрам в вызове.

Я переименовал x и y чтобы лучше описать, что они собой представляют.

Я добавил новую переменную display_peg, так как я использую индекс на основе 0 для массива, но пользователь все еще работает с натуральными числами.

                        PegThree = PegThree - PegOne;
                        cout << "The Game Master takes " << PegOne << " rings from peg three." << endl;

Мы заменяем каждое вхождение таким образом вызовом removeRings.

                        removeRings(pegs, 2, pegs[0], GAME_MASTER);

Не забудьте настроить, потому что наш индекс массива отключен на дисплее.

                //------------------Computer must take last ring------------------
                else if (PegTotal == 1)

Это простая проверка, поэтому вы должны сделать это до других проверок.

                        srand(time(NULL));

Вы должны сделать это перед началом игры, вне всех петель. Обратите внимание, что это можно вызвать несколько раз за одну секунду. Каждый раз, когда вы это делаете, вы переставляете случайный счетчик с тем же значением. Это фактически повторяет результат.

                        x = rand() % 3 + 1;

Поскольку мы используем контейнер, вы можете заменить его на

                        x = rand() % pegs.size();

Теперь он будет масштабироваться автоматически, если будет добавлено больше привязок.

                        if ((x == 1) && (PegOne == 0) || (x == 2) && (PegTwo == 0) || (x == 3) && (PegThree == 0))

Это можно записать проще:

                        if ( 0 == pegs[x] )

Опять же, это будет масштабироваться, если будет добавлено больше привязок.

                        else if (x != 1 && x != 2 && x != 3)

Это не было нужно, и все еще нет. x всегда будет в правильном диапазоне, так как вы настраиваете рандомизацию.

                            cout << "The Game Master takes 1 ring from peg " << x << "." << endl;

Это может быть вызов removeRings.

                            removeRings(pegs, x, 1, GAME_MASTER);

Это также исключает следующий раздел, который удаляет кольцо из соответствующей привязки.

return 0;

Вам не нужно делать это в main. Компилятор сделает это за вас, если вы оставите это.

Этот обзор уже длинный, поэтому я не буду пытаться охватить больше. Если вы отправляете новый вопрос в виде итеративного обзора , вы можете получить больше предложений. В частности, я бы предпочел сделать это как класс, чтобы не пропускать pegs к каждой функции. Кто-то еще может критиковать некоторые из моих предложений.

#include <iostream>
#include <string>
#include <stdlib.h>
#include <time.h>
#include <array>
#include <numeric>

void showHelp()
{
    std::cout << "Welcome to the 3 Peg game!!!" << std::endl;
    std::cout << "This is a 2 player game." << std::endl << std::endl;
    std::cout << "The game has 3 pegs and 15 rings." << std::endl
              << "The first peg has 3 rings, the second peg has 5, and the third peg has 7." << std::endl
              << "The object of the game is to get the other player to take off the last ring." << std::endl << std::endl;
    system("PAUSE");
    system("CLS");
    std::cout << "The rules of the game are as follow:" << std::endl
              << "1. You must take at least one ring off a peg per turn." << std::endl
              << "2. You can only take rings off a single peg in a given turn." << std::endl
              << "3. You can take as many rings off a single peg as you like." << std::endl
              << "4. You cannot skip a turn." << std::endl
              << "5. The player who takes the last ring off loses." << std::endl << std::endl;
    system("PAUSE");
    system("CLS");
}

enum Turn { YOU, GAME_MASTER };

void removeRings(std::array<int,3> & pegs, std::size_t peg, int quantity, Turn turn)
{
    switch ( turn )
    {
        case YOU:
            std::cout << "You take ";
            break;
        case GAME_MASTER:
            std::cout << "Game Master takes ";
            break;
    }

    std::cout << quantity << " rings off peg ";
    std::cout << peg + 1 << std::endl;

    pegs[peg] -= quantity;
}

void removeRings(std::array<int,3> & pegs, std::size_t peg)
{
    std::size_t display_peg = peg + 1;

    while ( true )
    {
        int ring_count = 0;

        std::cout << "How many rings would you like to take from peg " << display_peg << ". Max(" << pegs[peg] << ")." << std::endl;
        std::cin >> ring_count;

        if ( ring_count > pegs[peg] )
        {
            std::cout << "There are not that many rings on that peg." << std::endl << std::endl;
            system("PAUSE");
            system("CLS");
        }
        else
        {
            removeRings(pegs, peg, ring_count, YOU);
            return;
        }
    }
}

void chooseTurn(std::array<int,3> & pegs)
{
    int player = 0;

    while ( true )
    {
        std::cout << "Would you like to go first or second?(Type 1 or 2)" << std::endl;
        std::cin >> player;

        if ( 1 == player )
        {
            std::cout << "You are player one!" << std::endl
                      << "You will go first." << std::endl << std::endl;
            return;
        }
        else if ( 2 == player )
        {
            std::cout << "You are player 2!" << std::endl
                      << "You will go second" << std::endl << std::endl;
            removeRings(pegs, 2, 3, GAME_MASTER);
            return;
        }
        else
        {
            std::cout << "You must choose to be player 1 or 2." << std::endl;
            system("PAUSE");
            system("CLS");
        }
    }
}

void displayPegs(const std::array<int,3> & pegs)
{
    std::cout << "Peg One has " << pegs[0] << " rings left." << std::endl
              << "Peg Two has " << pegs[1] << " rings left." << std::endl
              << "Peg Three has " << pegs[2] << " rings left." << std::endl << std::endl;
}

std::size_t choosePeg(const std::array<int,3> & pegs)
{
    std::size_t x;

    while ( true )
    {
        std::cout << "Which peg will you take rings from?" << std::endl;
        std::cin >> x;

        if ( 1 > x || pegs.size() < x )
        {
            std::cout << "That is not a peg." << std::endl;
            system("PAUSE");
            system("CLS");
        }
        else if ( 0 >= pegs[--x] )
        {
            std::cout << "That peg is empty." << std::endl;
            system("PAUSE");
            system("CLS");
        }
        else
        {
            return x;
        }

        displayPegs(pegs);
    }
}

int main()
{
    char cAgain;

    srand(time(NULL));

    do
    {
        //Variable Declarations
        std::array<int,3> pegs = { 3, 5, 7 };

        showHelp();
        chooseTurn(pegs);
        int pegTotal = std::accumulate(pegs.begin(), pegs.end(), 0);

        do
        {
            system("PAUSE");
            system("CLS");

            if ( 0 == pegTotal )
            {
                break;
            }

            displayPegs(pegs);

            if ( 1 == pegTotal )
            {
                std::cout << "You must take the last ring. You Lose!!!" << std::endl;
                system("PAUSE");
                system("CLS");
                break;
            }

            int x = choosePeg(pegs);
            removeRings(pegs, x);

            pegTotal = std::accumulate(pegs.begin(), pegs.end(), 0);

            if (pegTotal == 1)
            {
            //------------------Computer must take last ring------------------
                std::cout << "The Game Master takes the last ring." << std::endl
                          << "You Win!!!" << std::endl;
                break;
            }
            else if ( pegs[2] > pegs[0] &&  pegs[2] >  pegs[1] && pegs[2] > 1)
            {
            //----------------------------Peg Three Operations----------------------------
                if ( pegs[1] >  pegs[0] &&  pegs[0] != 0)
                {
                     removeRings(pegs, 2, pegs[0], GAME_MASTER);
                }
                else if ( pegs[1] + pegs[0] == 1 )
                {
                    removeRings(pegs, 2, pegs[2], GAME_MASTER);
                }
                else if ( pegs[0] >  pegs[1] &&  pegs[1] != 0)
                {
                    removeRings(pegs, 2, pegs[1], GAME_MASTER);
                }
                else if ( pegs[1] == 0 &&  pegs[0] == 0)
                {
                    removeRings(pegs, 2, pegs[2] - 1, GAME_MASTER);
                }
                else if (( pegs[2] > 3) >  pegs[1] >= ( pegs[0] == 0) || (( pegs[2] > 3) >  pegs[0] > ( pegs[1] == 0)))
                {
                    removeRings(pegs, 2, 1, GAME_MASTER);
                }
            }
            else if (( pegs[1] >  pegs[0] &&  pegs[1] >  pegs[2]) &&  pegs[1] > 1)
            {
            //-------------------------Peg Two Operations-------------------------------
                if ( pegs[2] >  pegs[0] &&  pegs[0] > 0)
                {
                    removeRings(pegs, 1, pegs[0], GAME_MASTER);
                }
                else if ( pegs[2] + pegs[0] == 1 )
                {
                    removeRings(pegs, 1, pegs[1], GAME_MASTER);
                }
                else if ( pegs[0] >  pegs[2] &&  pegs[2] > 0)
                {
                    removeRings(pegs, 1, pegs[2], GAME_MASTER);
                }
                else if ( pegs[2] == 0 &&  pegs[0] == 0)
                {
                    removeRings(pegs, 1, pegs[1] - 1, GAME_MASTER);
                }
                else if (( pegs[1] > 3) >  pegs[2] >= ( pegs[0] == 0) || (( pegs[1] > 3) >  pegs[0] > ( pegs[2] == 0)))
                {
                    removeRings(pegs, 1, 1, GAME_MASTER);
                }
            }
            else if (( pegs[0] >  pegs[1] &&  pegs[0] > pegs[2]) &&  pegs[0] > 1)
            {
            //----------------------Peg One Operations---------------------------------
                if ( pegs[1] >  pegs[2] &&  pegs[2] > 0)
                {
                    removeRings(pegs, 0, 2, GAME_MASTER);
                }
                else if ( pegs[1] + pegs[2] == 1 )
                {
                    removeRings(pegs, 0, pegs[0], GAME_MASTER);
                }
                else if ( pegs[2] >  pegs[1] && pegs[1] > 0 )
                {
                    removeRings(pegs, 0, pegs[1], GAME_MASTER);
                }
                else if ( pegs[1] == 0 &&  pegs[2] == 0)
                {
                    removeRings(pegs, 0, pegs[0] - 1, GAME_MASTER);
                }
                else if (( pegs[0] > 3) >  pegs[1] >= ( pegs[2] == 0) || (( pegs[0] > 3) >  pegs[2] > ( pegs[1] == 0)))
                {
                    removeRings(pegs, 0, 1, GAME_MASTER);
                }
            }
            else
            {
            //-------------------Computer has no winning scenarios-------------
                while ( true )
                {
                    x = rand() % 3;
                    if ( 0 < pegs[x] )
                    {
                        removeRings(pegs, x, 1, GAME_MASTER);
                        break;
                    }
                }

            }
            pegTotal = std::accumulate(pegs.begin(), pegs.end(), 0);
        } while ( pegTotal > 0);

        std::cout << "Would you like to play again?(Y/N)" << std::endl;
        std::cin >> cAgain;
        system("CLS");
    } while (cAgain == 'Y' || cAgain == 'y');
}

Я проверил, что это компилируется, но я не настроен для его запуска.

ответил Brythan 24 WedEurope/Moscow2014-12-24T15:01:08+03:00Europe/Moscow12bEurope/MoscowWed, 24 Dec 2014 15:01:08 +0300 2014, 15:01:08
4

Как я прокомментировал ниже @ обзор Brythan (с которым я согласен, BTW), я бы избегал вызовов system в настоящее время используется. Коды PAUSE и CLS относятся к конечно, для платформы, поэтому, пока ваш код выполняет компиляцию в системе * NIX, программа не будет вести себя так, как ожидалось.
По этой причине я предлагаю вам изменить system("PAUSE") на что-то в строках:

std::cin.ignore(80, '\n');
std::cin.sync();

Первый оператор считывает либо 80 символов из входного буфера (или меньше, если он сначала встречает \n), что фактически приводит к программа для ожидания ввода пользователем. Ввод, как следует из названия метода, игнорируется (как в отброшенном).
Может быть, входной буфер содержит гораздо больше 80 символов, поэтому, почему вызывается std::cin.sync();. Этот вызов заключается в очистке входного буфера или любого другого ввода, который там может быть оставлен, если пользовательский ввод выглядит примерно так:

  

Цель игры - заставить другого игрока снять последнее кольцо.

  некоторая действительно длинная строка пользовательского ввода, длиной более 80 символов. Вряд ли, но возможно. \ П

По моим подсчетам вход здесь составляет 87 символов, поэтому std::cin.ignore оставит последние 7 символов в буфере ( ". \ n" ), но вызов std::cin.sync удаляет их.

Что касается вызова system("CLS");, это немного сложнее, поскольку C /C ++ не имеют возможности ввода-вывода и, следовательно, на самом деле знать, что такое экран. Вы могли использовать заголовок, соответствующий окну, который содержит clrscr - который я считаю conio и используйте ncurses для * NIX-систем, используйте файл make, который связывает /строит все в зависимости от того, в какой системе вы компилируете, но для многих задач это сложная задача такая же простая. Есть некоторые платформы X-платформы C ++, которые также могут решить эту проблему, например Qt (C ++) или GTK (c), но опять же: я не собираюсь останавливать вас, если вы хотите потратить время и приложить усилия для изучения этих libs /frameworks, но вы пытаетесь очистить экран, задача, для которой должна быть легче.

Подход, который я предлагаю, заключается в определении макроса на основе ОС, на котором компилируется ваш код. Согласно MSDN, предопределенный макрос препроцессора __WIN32 должен выполнять cf список предопределенных макросов . Я протестировал его и получил ожидаемые результаты, добавив следующее:

#ifdef __WIN32
#define CLEAR_SCREEN "CLS"
#else
#define CLEAR_SCREEN "clear"
#endif

Затем я изменил system("CLS"); на system(CLEAR_SCREEN), и это было концом этого. Прежде всего, полный код, полный код ниже (только что скопированный с обзора @ Brythan's, и применил 2 изменения, которые я обсуждал здесь):

#include <iostream>
#include <string>
#include <stdlib.h>
#include <time.h>
#include <array>
#include <numeric>

#ifdef __WIN32
#define CLEAR_SCREEN "CLS"
#else
#define CLEAR_SCREEN "clear"
#endif

void showHelp()
{
    std::cout << "Welcome to the 3 Peg game!!!" << std::endl;
    std::cout << "This is a 2 player game." << std::endl << std::endl;
    std::cout << "The game has 3 pegs and 15 rings." << std::endl
              << "The first peg has 3 rings, the second peg has 5, and the third peg has 7." << std::endl
              << "The object of the game is to get the other player to take off the last ring." << std::endl << std::endl;
    std::cin.ignore(80, '\n');
    std::cin.sync();
    system(CLEAR_SCREEN);
    std::cout << "The rules of the game are as follow:" << std::endl
              << "1. You must take at least one ring off a peg per turn." << std::endl
              << "2. You can only take rings off a single peg in a given turn." << std::endl
              << "3. You can take as many rings off a single peg as you like." << std::endl
              << "4. You cannot skip a turn." << std::endl
              << "5. The player who takes the last ring off loses." << std::endl << std::endl;
    std::cin.ignore(80, '\n');
    std::cin.sync();
    system(CLEAR_SCREEN);
}

enum Turn { YOU, GAME_MASTER };

void removeRings(std::array<int,3> & pegs, std::size_t peg, int quantity, Turn turn)
{
    switch ( turn )
    {
        case YOU:
            std::cout << "You take ";
            break;
        case GAME_MASTER:
            std::cout << "Game Master takes ";
            break;
    }

    std::cout << quantity << " rings off peg ";
    std::cout << peg + 1 << std::endl;

    pegs[peg] -= quantity;
}

void removeRings(std::array<int,3> & pegs, std::size_t peg)
{
    std::size_t display_peg = peg + 1;

    while ( true )
    {
        int ring_count = 0;

        std::cout << "How many rings would you like to take from peg " << display_peg << ". Max(" << pegs[peg] << ")." << std::endl;
        std::cin >> ring_count;

        if ( ring_count > pegs[peg] )
        {
            std::cout << "There are not that many rings on that peg." << std::endl << std::endl;
            std::cin.ignore(80, '\n');
            std::cin.sync();
            system(CLEAR_SCREEN);
        }
        else
        {
            removeRings(pegs, peg, ring_count, YOU);
            return;
        }
    }
}

void chooseTurn(std::array<int,3> & pegs)
{
    int player = 0;

    while ( true )
    {
        std::cout << "Would you like to go first or second?(Type 1 or 2)" << std::endl;
        std::cin >> player;

        if ( 1 == player )
        {
            std::cout << "You are player one!" << std::endl
                      << "You will go first." << std::endl << std::endl;
            return;
        }
        else if ( 2 == player )
        {
            std::cout << "You are player 2!" << std::endl
                      << "You will go second" << std::endl << std::endl;
            removeRings(pegs, 2, 3, GAME_MASTER);
            return;
        }
        else
        {
            std::cout << "You must choose to be player 1 or 2." << std::endl;
            std::cin.ignore(80, '\n');
            std::cin.sync();
            system(CLEAR_SCREEN);
        }
    }
}

void displayPegs(const std::array<int,3> & pegs)
{
    std::cout << "Peg One has " << pegs[0] << " rings left." << std::endl
              << "Peg Two has " << pegs[1] << " rings left." << std::endl
              << "Peg Three has " << pegs[2] << " rings left." << std::endl << std::endl;
}

std::size_t choosePeg(const std::array<int,3> & pegs)
{
    std::size_t x;

    while ( true )
    {
        std::cout << "Which peg will you take rings from?" << std::endl;
        std::cin >> x;

        if ( 1 > x || pegs.size() < x )
        {
            std::cout << "That is not a peg." << std::endl;
            std::cin.ignore(80, '\n');
            std::cin.sync();
            system(CLEAR_SCREEN);
        }
        else if ( 0 >= pegs[--x] )
        {
            std::cout << "That peg is empty." << std::endl;
            std::cin.ignore(80, '\n');
            std::cin.sync();
            system(CLEAR_SCREEN);
        }
        else
        {
            return x;
        }

        displayPegs(pegs);
    }
}

int main()
{
    char cAgain;

    srand(time(NULL));

    do
    {
        //Variable Declarations
        std::array<int,3> pegs = { 3, 5, 7 };

        showHelp();
        chooseTurn(pegs);
        int pegTotal = std::accumulate(pegs.begin(), pegs.end(), 0);

        do
        {
            std::cin.ignore(80, '\n');
            std::cin.sync();
            system(CLEAR_SCREEN);

            if ( 0 == pegTotal )
            {
                break;
            }

            displayPegs(pegs);

            if ( 1 == pegTotal )
            {
                std::cout << "You must take the last ring. You Lose!!!" << std::endl;
                std::cin.ignore(80, '\n');
                std::cin.sync();
                system(CLEAR_SCREEN);
                break;
            }

            int x = choosePeg(pegs);
            removeRings(pegs, x);

            pegTotal = std::accumulate(pegs.begin(), pegs.end(), 0);

            if (pegTotal == 1)
            {
            //------------------Computer must take last ring------------------
                std::cout << "The Game Master takes the last ring." << std::endl
                          << "You Win!!!" << std::endl;
                break;
            }
            else if ( pegs[2] > pegs[0] &&  pegs[2] >  pegs[1] && pegs[2] > 1)
            {
            //----------------------------Peg Three Operations----------------------------
                if ( pegs[1] >  pegs[0] &&  pegs[0] != 0)
                {
                     removeRings(pegs, 2, pegs[0], GAME_MASTER);
                }
                else if ( pegs[1] + pegs[0] == 1 )
                {
                    removeRings(pegs, 2, pegs[2], GAME_MASTER);
                }
                else if ( pegs[0] >  pegs[1] &&  pegs[1] != 0)
                {
                    removeRings(pegs, 2, pegs[1], GAME_MASTER);
                }
                else if ( pegs[1] == 0 &&  pegs[0] == 0)
                {
                    removeRings(pegs, 2, pegs[2] - 1, GAME_MASTER);
                }
                else if (( pegs[2] > 3) >  pegs[1] >= ( pegs[0] == 0) || (( pegs[2] > 3) >  pegs[0] > ( pegs[1] == 0)))
                {
                    removeRings(pegs, 2, 1, GAME_MASTER);
                }
            }
            else if (( pegs[1] >  pegs[0] &&  pegs[1] >  pegs[2]) &&  pegs[1] > 1)
            {
            //-------------------------Peg Two Operations-------------------------------
                if ( pegs[2] >  pegs[0] &&  pegs[0] > 0)
                {
                    removeRings(pegs, 1, pegs[0], GAME_MASTER);
                }
                else if ( pegs[2] + pegs[0] == 1 )
                {
                    removeRings(pegs, 1, pegs[1], GAME_MASTER);
                }
                else if ( pegs[0] >  pegs[2] &&  pegs[2] > 0)
                {
                    removeRings(pegs, 1, pegs[2], GAME_MASTER);
                }
                else if ( pegs[2] == 0 &&  pegs[0] == 0)
                {
                    removeRings(pegs, 1, pegs[1] - 1, GAME_MASTER);
                }
                else if (( pegs[1] > 3) >  pegs[2] >= ( pegs[0] == 0) || (( pegs[1] > 3) >  pegs[0] > ( pegs[2] == 0)))
                {
                    removeRings(pegs, 1, 1, GAME_MASTER);
                }
            }
            else if (( pegs[0] >  pegs[1] &&  pegs[0] > pegs[2]) &&  pegs[0] > 1)
            {
            //----------------------Peg One Operations---------------------------------
                if ( pegs[1] >  pegs[2] &&  pegs[2] > 0)
                {
                    removeRings(pegs, 0, 2, GAME_MASTER);
                }
                else if ( pegs[1] + pegs[2] == 1 )
                {
                    removeRings(pegs, 0, pegs[0], GAME_MASTER);
                }
                else if ( pegs[2] >  pegs[1] && pegs[1] > 0 )
                {
                    removeRings(pegs, 0, pegs[1], GAME_MASTER);
                }
                else if ( pegs[1] == 0 &&  pegs[2] == 0)
                {
                    removeRings(pegs, 0, pegs[0] - 1, GAME_MASTER);
                }
                else if (( pegs[0] > 3) >  pegs[1] >= ( pegs[2] == 0) || (( pegs[0] > 3) >  pegs[2] > ( pegs[1] == 0)))
                {
                    removeRings(pegs, 0, 1, GAME_MASTER);
                }
            }
            else
            {
            //-------------------Computer has no winning scenarios-------------
                while ( true )
                {
                    x = rand() % 3;
                    if ( 0 < pegs[x] )
                    {
                        removeRings(pegs, x, 1, GAME_MASTER);
                        break;
                    }
                }

            }
            pegTotal = std::accumulate(pegs.begin(), pegs.end(), 0);
        } while ( pegTotal > 0);

        std::cout << "Would you like to play again?(Y/N)" << std::endl;
        std::cin >> cAgain;
        system(CLEAR_SCREEN);
    } while (cAgain == 'Y' || cAgain == 'y');
}

Он скомпилирован с помощью этой команды просто отлично:

g++ -std=c11 peg.cpp -o peg

Я видел некоторые предупреждения, когда добавлял некоторую оптимизацию, и сказал компилятору предупредить меня о возможных проблемах:

g++ -std=c11 peg.cpp -o peg -O3 -Wall

В случае, если вы хотите узнать, разбивка команды:

  • g++ - это компилятор
  • -std=c++11 - это стандарт C ++, используемый для компиляции кода (C ++ 11 является верным стандарту C ++ 11, gnu ++ 11 будучи тем же + расширением GNU, поэтому уже не является чистым стандартным C ++).
  • peg.cpp ссылается на исходный файл (очевидно)
  • -o peg - скомпилированный двоичный файл.
  • -O3 - уровень оптимизации ( подробности здесь )
  • -Wall просто просит компилятор предупредить меня о все потенциальные проблемы.

Проблемы, о которых сообщалось компилятором, были следующими:

  • Игнорирование возвращаемого значения system(CLEAR_SCREEN); (очень низкий приоритет для исправления)
  • Возможные несанкционированные сравнения (читаемость - проблема, я исправлю ее)

Предупреждения о сравнении включали:

  

peg.cpp: 268: 94: предупреждение: сравнения, подобные «X <= Y <= Z», не имеют своего математического значения [-Wparentheses]
                       else if ((pegs [0]> 3)> pegs [1]> = (pegs [2] == 0) || ((pegs [0]> 3)> привязки [2]> (pegs [1] == 0)))

Что действительно не самый простой код для чтения, возможно, подумайте о рефакторинге условий if-elseif в формате, который легче читать /поддерживать

else if (( pegs[1] > 3) >  pegs[2] >= ( pegs[0] == 0) || (( pegs[1] > 3) >  pegs[0] > ( pegs[2] == 0)))

На первый взгляд, это в основном то же самое, что и запись:

else if ( pegs[1] > 3 && ((!pegs[0] && !pegs[2]) || (!pegs[2] && pegs[0])))

Но, AFAIK, вы могли бы просто написать else if (pegs[1] > 3) или просто else ... в любом случае, эти условия могут быть легко упрощены

Как бы то ни было, код (после моих незначительных изменений) работал как часы. Начало игры было так же просто:

./peg
ответил Elias Van Ootegem 22 Jpm1000000pmThu, 22 Jan 2015 16:07:22 +030015 2015, 16:07:22

Похожие вопросы

Популярные теги

security × 330linux × 316macos × 2827 × 268performance × 244command-line × 241sql-server × 235joomla-3.x × 222java × 189c++ × 186windows × 180cisco × 168bash × 158c# × 142gmail × 139arduino-uno × 139javascript × 134ssh × 133seo × 132mysql × 132