1

Тема: Випадкове заповнення двовимірного char масиву конкретними даними

Всім привіт. Вирішив трохи побавитись і написав прогу недо-"Хрестики-нолики". Завдання полягає в тому, що є заданий фіксований двовимірний масив char, який складається з ноликів "0", хрестиків "Х" і пробіла " ", замість якого користувач згодом вводить 0 або Х.

char board[ROW][COLUMN] = { { '0', 'X', '0' },
                                { ' ', 'X', 'X' },
                                { 'X', '0', '0' } };

Програма на підставі введеного символа визначає хто переміг - Х, 0 чи нічия. Визначення проводиться тільки по вертикалі і горизонталі.

Питання: чи можливо якось заповнити даний вище масив рандомно, наприклад, за допомогою функції rand чи якимось іншим способом? Причому заповнити іксами "Х", нулями "0" і тільки одним пробілом, а "Х" має бути на 1 більше або менше "0".

P.S. Знаю, що можна все це реалізувати за допомогою одновимірного масиву і не паритись. Але хочу саме так.

Власне програма
#include <iostream>
#include <cstdlib>
#include <ctime>

using namespace std;

int main()
{
    srand(static_cast<unsigned int>(time(NULL)));
    const int ROW = 3;
    const int COLUMN = 3;
    char arr[] = { '0', 'X', ' '};

    char board[ROW][COLUMN] = { { '0', 'X', '0' },
                                { ' ', 'X', 'X' },
                                { 'X', '0', '0' } };
    
    int i, j;
    char newItem;
    bool winner1, winner2, exit;

    cout << "\tTic-Tac-Toe\nBoard:" << endl;
    for (i = 0; i < ROW; i++)
    {
        for (j = 0; j < COLUMN; j++)
        {
            cout << board[i][j];
        }
        cout << endl;
    }
    
    //заміна пробілу введеним значенням Х або 0
    cout << "Input 0 or X instead space (0/X) - ";
    cin >> newItem;
    if (newItem == '0' || newItem == 'X') 
    {
        for (i = 0; i < ROW; i++)
        {
            for (j = 0; j < COLUMN; j++)
            {
                if (board[i][j] == ' ')
                {
                    board[i][j] = newItem;
                }
            }
        }
    }
    else
        cout << "Wrong Symbol." << endl;

    //перевірка X по горизонталі
    for (i = 0; i < ROW; i++) 
    {
        for (j = 0; j < COLUMN; j++)
        {
            if (board[i][j] == 'X')
            {
                winner1 = true;
                winner2 = false;
                if (j == COLUMN-1)
                {
                    exit = true;
                }
            }
            else
            {
                winner1 = false;
                break;
            }
        }
        if (exit == true)
            break;
    }
    
    //перевірка X по вертикалі
    if (winner1 == false)
    {
        for (i = 0; i < ROW; i++) 
        {
            for (j = 0; j < COLUMN; j++)
            {
                if (board[j][i] == 'X')
                {
                    winner1 = true;
                    winner2 = false;
                    if (j == COLUMN - 1)
                    {
                        exit = true;
                    }
                }
                else
                {
                    winner1 = false;
                    break;
                }
            }
            if (exit == true)
                break;
        }
    }
    
    //перевірка 0 по горизонталі
    if (winner1 == false)
    {
        for (i = 0; i < ROW; i++) 
        {
            for (j = 0; j < COLUMN; j++)
            {
                if (board[i][j] == '0')
                {
                    winner1 = false;
                    winner2 = true;
                    if (j == COLUMN - 1)
                    {
                        exit = true;
                    }
                }
                else
                {
                    winner2 = false;
                    break;
                }
            }
            if (exit == true)
                break;
        }
    }
    
    //перевірка 0 по вертикалі
    if (winner1 == false && winner2 == false)
    {
        for (i = 0; i < ROW; i++) 
        {
            for (j = 0; j < COLUMN; j++)
            {
                if (board[j][i] == '0')
                {
                    winner1 = false;
                    winner2 = true;
                    if (j == COLUMN - 1)
                    {
                        exit = true;
                    }
                }
                else
                {
                    winner2 = false;
                    break;
                }
            }
            if (exit == true)
                break;
        }
    }
    
    //вивід виграшу
    if (winner1 == true) 
    {
        cout << "X wins!" << endl;
    }
    else if (winner2 == true)
    {
        cout << "0 wins!" << endl;
    }
    else
    {
        cout << "Nobody's win!" << endl;
    }

    //таблиця хрестики-нолики після маніпуляцій
    cout << "Board now:" << endl; 
    for (i = 0; i < ROW; i++)
    {
        for (j = 0; j < COLUMN; j++)
        {
            cout << board[i][j];
        }
        cout << endl;
    }
    return 0;
}

2 Востаннє редагувалося 0x9111A (24.02.2017 17:19:21)

Re: Випадкове заповнення двовимірного char масиву конкретними даними

LoganRoss написав:

Питання: чи можливо якось заповнити даний вище масив рандомно, наприклад, за допомогою функції rand чи якимось іншим способом? Причому заповнити іксами "Х", нулями "0" і тільки одним пробілом, а "Х" має бути на 1 більше або менше "0".

А як це у вас в полі наприклад 3х3 вийде один пробіл і "Х" на один більше чи менше ніж "0"?
9 - 1 = 8 Не поділиш його так як вам хочетсья
Поки не докінця розумію нащо воно вам але рекомендую наступний підхід
Створюєте масив значень які вам треба випадково розпихати в сітку
Наприклад для 2х2 - Х Х 0 " "
"Тасуєтете" його отак і потім просто результат по черзі в клітинки записуйте

Подякували: LoganRoss1

3

Re: Випадкове заповнення двовимірного char масиву конкретними даними

Можна заповнити масив потрібною кількістю хрестиків і нуликів, після чого випадковим чином попереставляти їх усередині масиву необхідну кількість разів. Якщо вважати, що пробіл має бути або один, або жодного (тобто, чотири нулики й чотири чи п'ять хрестиків), то можна перед початком перемішування замінити чи не замінювати (в залежності від випадкового вибору) перший хрестик на пробіл.

Подякували: LoganRoss1

4

Re: Випадкове заповнення двовимірного char масиву конкретними даними

0x9111A написав:

Поки не докінця розумію нащо воно вам

Та воно мені без потреби, вирішив трохи поекспериментувати.

0x9111A написав:

А як це у вас в полі наприклад 3х3 вийде один пробіл і "Х" на один більше чи менше ніж "0"?
9 - 1 = 8 Не поділиш його так як вам хочетсья

Не подумав про це. Тепер вирішив нехай буде "Х" і "0" порівно або брати масив кратний 2.

Дякую за поради.
От що вийшло.

Код
#include <iostream>
#include <cstdlib>
#include <ctime>

using namespace std;

int main()
{
    srand(static_cast<int>(time(0)));
    int randNum;
    int i, j;
    char newItem;
    bool winnerX, winner0, exit;
    const int ROW = 3;
    const int COLUMN = 3;
    char arr[] = { '0', 'X', '0', 'X', 'X', '0', 'X', '0', ' '};
    char board[ROW][COLUMN];

    //тасування елементів і запис у двовимірний масив
    randNum = rand() % sizeof arr;
    for (j = 0; j < sizeof arr; j++) //тасування
    {
        swap(arr[randNum], arr[j]);
    }
    for (i = 0; i < ROW*COLUMN; i++)//заповнення двовимірного масиву
        board[i / ROW][i%COLUMN] = arr[i];

    cout << "\tTic-Tac-Toe\nBoard:" << endl;//вивід двовимірного масиву
    for (i = 0; i < ROW; i++)
    {
        for (j = 0; j < COLUMN; j++)
        {
            cout << board[i][j];
        }
        cout << endl;
    }
    
    //заміна пробілу введеним значенням Х або 0
    cout << "Input 0 or X instead space (0/X) - ";
    cin >> newItem;
    if (newItem == '0' || newItem == 'X') 
    {
        for (i = 0; i < ROW; i++)
        {
            for (j = 0; j < COLUMN; j++)
            {
                if (board[i][j] == ' ')
                {
                    board[i][j] = newItem;
                }
            }
        }
    }
    else
        cout << "Wrong Symbol." << endl;

    //перевірка X по горизонталі
    for (i = 0; i < ROW; i++) 
    {
        for (j = 0; j < COLUMN; j++)
        {
            if (board[i][j] == 'X')
            {
                winnerX = true;
                winner0 = false;
                if (j == COLUMN-1)
                {
                    exit = true;
                }
            }
            else
            {
                winnerX = false;
                break;
            }
        }
        if (exit == true)
            break;
    }
    
    //перевірка X по вертикалі
    if (winnerX == false)
    {
        for (i = 0; i < ROW; i++) 
        {
            for (j = 0; j < COLUMN; j++)
            {
                if (board[j][i] == 'X')
                {
                    winnerX = true;
                    winner0 = false;
                    if (j == COLUMN - 1)
                    {
                        exit = true;
                    }
                }
                else
                {
                    winnerX = false;
                    break;
                }
            }
            if (exit == true)
                break;
        }
    }
    
    //перевірка 0 по горизонталі
    if (winnerX == false)
    {
        for (i = 0; i < ROW; i++) 
        {
            for (j = 0; j < COLUMN; j++)
            {
                if (board[i][j] == '0')
                {
                    winnerX = false;
                    winner0 = true;
                    if (j == COLUMN - 1)
                    {
                        exit = true;
                    }
                }
                else
                {
                    winner0 = false;
                    break;
                }
            }
            if (exit == true)
                break;
        }
    }
    
    //перевірка 0 по вертикалі
    if (winnerX == false && winner0 == false)
    {
        for (i = 0; i < ROW; i++) 
        {
            for (j = 0; j < COLUMN; j++)
            {
                if (board[j][i] == '0')
                {
                    winnerX = false;
                    winner0 = true;
                    if (j == COLUMN - 1)
                    {
                        exit = true;
                    }
                }
                else
                {
                    winner0 = false;
                    break;
                }
            }
            if (exit == true)
                break;
        }
    }
    
    //вивід виграшу
    if (winnerX == true) 
    {
        cout << "X wins!" << endl;
    }
    else if (winner0 == true)
    {
        cout << "0 wins!" << endl;
    }
    else
    {
        cout << "Nobody wins!" << endl;
    }

    //таблиця хрестики-нолики після маніпуляцій
    cout << "Board now:" << endl; 
    for (i = 0; i < ROW; i++)
    {
        for (j = 0; j < COLUMN; j++)
        {
            cout << board[i][j];
        }
        cout << endl;
    }
    return 0;
}

5

Re: Випадкове заповнення двовимірного char масиву конкретними даними

1. Хто сказав, що до останнього ходу не було переможця? Можливо, останній хід не потрібен?
2. А якщо у вас перемогли обидві сторони одночасно? Наприклад, ситуація

XXX
0 X
000

Як тоді?
3. У вас великі шматки коду повторюються. Не хочете винести їх у функції?
4. Дві змінні winner0 і winnerX не потрібні - потрібна одна змінна char winner, що зберігатиме '0' чи 'X' (або ж ' ').

6

Re: Випадкове заповнення двовимірного char масиву конкретними даними

koala написав:

1. Хто сказав, що до останнього ходу не було переможця? Можливо, останній хід не потрібен?
2. А якщо у вас перемогли обидві сторони одночасно? Наприклад, ситуація

XXX
0 X
000

Як тоді?
3. У вас великі шматки коду повторюються. Не хочете винести їх у функції?
4. Дві змінні winner0 і winnerX не потрібні - потрібна одна змінна char winner, що зберігатиме '0' чи 'X' (або ж ' ').

Так, тут треба ще посидіти і врахувати всі можливі варіанти. Але я знаю як це реалізувати, так що нічого нового не навчусь. І це займе трохи часу, якого в мене не так багато і цей проект мені без потреби, так, для власного розвитку - дізнався як заповнювати масиви даним способом.

Спочатку теж використовував одну змінну char winner, але якось воно мені не вдалося нормально зробити.

Код
#include <iostream>
#include <cstdlib>
#include <ctime>

using namespace std;

int i, j;
char newItem, winner;
bool winner1, winner2;
const int ROW = 3;
const int COLUMN = 3;

char arrStatic[] = { '0', 'X', '0', 'X', 'X', '0', 'X', '0', ' ' };
char board[ROW][COLUMN];

////////////////////////////////////////////////////////////////////////////
//ФУНКЦІЯ ТАСУВАННЯ І ЗАПОВНЕННЯ МАСИВУ/////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
void generation(int k)
{
    srand(static_cast<int>(time(0)));
    int randNum;

    //тасування елементів і запис у двовимірний масив
    randNum = rand() % sizeof arrStatic;
    for (int j = k; j < sizeof arrStatic; j++) //тасування
    {
        swap(arrStatic[randNum], arrStatic[j]);
    }
    for (i = 0; i < ROW*COLUMN; i++)//заповнення двовимірного масиву
        board[i / ROW][i%COLUMN] = arrStatic[i];

    cout << "\tTic-Tac-Toe\nBoard:" << endl;//вивід двовимірного масиву
    for (i = 0; i < ROW; i++)
    {
        for (j = 0; j < COLUMN; j++)
        {
            cout << board[i][j];
        }
        cout << endl;
    }
    //заміна пробілу введеним значенням Х або 0
    cout << "Input 0 or X instead space (0/X) - ";
    cin >> newItem;
    if (newItem == '0' || newItem == 'X')
    {
        for (i = 0; i < ROW; i++)
        {
            for (j = 0; j < COLUMN; j++)
            {
                if (board[i][j] == ' ')
                {
                    board[i][j] = newItem;
                }
            }
        }
    }
    else
        cout << "Wrong Symbol." << endl;
    
}

void whoWin();

int main()
{
    whoWin();

    //таблиця хрестики-нолики після маніпуляцій
    cout << "Board now:" << endl; 
    for (i = 0; i < ROW; i++)
    {
        for (j = 0; j < COLUMN; j++)
        {
            cout << board[i][j];
        }
        cout << endl;
    }
    return 0;
}

////////////////////////////////////////////////////////////////////////////
//ФУНКЦІЯ ПЕРЕВІРКИ ПЕРЕМОЖЦЯ///////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
bool winners(char arr[ROW][COLUMN])
{
    bool exit = false;
    generation(0);
    //перевірка X по горизонталі
for (i = 0; i < ROW; i++)
{
    for (j = 0; j < COLUMN; j++)
    {
        if (board[i][j] == 'X')
        {
            winner1 = true;
            winner2 = false;
            if (j == COLUMN - 1)
            {
                exit = true;
            }
        }
        else
        {
            winner1 = false;
            break;
        }
    }
    if (exit == true)
        break;
}

//перевірка X по вертикалі
if (winner1 == false)
{
    for (i = 0; i < ROW; i++)
    {
        for (j = 0; j < COLUMN; j++)
        {
            if (board[j][i] == 'X')
            {
                winner1 = true;
                winner2 = false;
                if (j == COLUMN - 1)
                {
                    exit = true;
                }
            }
            else
            {
                winner1 = false;
                break;
            }
        }
        if (exit == true)
            break;
    }
}

//перевірка 0 по горизонталі
if (winner1 == false)
{
    for (i = 0; i < ROW; i++)
    {
        for (j = 0; j < COLUMN; j++)
        {
            if (board[i][j] == '0')
            {
                winner1 = false;
                winner2 = true;
                if (j == COLUMN - 1)
                {
                    exit = true;
                }
            }
            else
            {
                winner2 = false;
                break;
            }
        }
        if (exit == true)
            break;
    }
}

//перевірка 0 по вертикалі
if (winner1 == false && winner2 == false)
{
    for (i = 0; i < ROW; i++)
    {
        for (j = 0; j < COLUMN; j++)
        {
            if (board[j][i] == '0')
            {
                winner1 = false;
                winner2 = true;
                if (j == COLUMN - 1)
                {
                    exit = true;
                }
            }
            else
            {
                winner2 = false;
                break;
            }
        }
        if (exit == true)
            break;
    }
}
return winner1, winner2;
}

////////////////////////////////////////////////////////////////////////////
//ФУНКЦІЯ ВИВОДУ ПЕРЕМОЖЦЯ//////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
void whoWin()
{
    //виклик функцій перевірки
    winners(board);

    //вивід виграшу
    if (winner1 == true && winner2 == true)
    {
        cout << "Both win!" << endl;
    }
     if (winner1 == true && winner2 == false)
    {
        cout << "X wins!" << endl;
    }
    else if (winner1 == false && winner2 == true)
    {
        cout << "0 wins!" << endl;
    }
    else if (winner1 == false && winner2 == false)
    {
        cout << "Nobody wins!" << endl;
    }
}

7

Re: Випадкове заповнення двовимірного char масиву конкретними даними

А нащо параметр k в generation?

Ну і лишилося це все у клас загнати :)

8 Востаннє редагувалося LoganRoss (27.02.2017 21:36:39)

Re: Випадкове заповнення двовимірного char масиву конкретними даними

koala написав:

А нащо параметр k в generation?

просто *DONT_KNOW*

Ну і лишилося це все у клас загнати

Вирішили мені челендж влаштувати? :D

Клас TicTacToe.h
#include <iostream>
#include <cstdlib>
#include <ctime>

using namespace std;

char arrStatic[] = { '0', 'X', '0', 'X', 'X', '0', 'X', '0', ' '};

class TicTacToe
{
private:
    int i, j;
    char newItem, winner;
    bool winner1, winner2;
    int ROW;
    int COLUMN;
    char board[3][3];

public:
    TicTacToe(const int set_row, const int set_column) // конструктор класа
    {
        setSize(set_row, set_column);
    }

    void setSize(int set_row, int set_column)
    {
        ROW = set_row;
        COLUMN = set_column;
    }

    ////////////////////////////////////////////////////////////////////////////
    //ФУНКЦІЯ ТАСУВАННЯ І ЗАПОВНЕННЯ МАСИВУ/////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////
    void generation()
    {
        srand(static_cast<int>(time(0)));
        int randNum;

        //тасування елементів і запис у двовимірний масив
        randNum = rand() % sizeof arrStatic;
        for (int j = 0; j < sizeof arrStatic; j++) //тасування
        {
            swap(arrStatic[randNum], arrStatic[j]);
        }
        for (i = 0; i < ROW*COLUMN; i++)//заповнення двовимірного масиву
            board[i / ROW][i%COLUMN] = arrStatic[i];

        cout << "\tTic-Tac-Toe\nBoard:" << endl;//вивід двовимірного масиву
        for (i = 0; i < ROW; i++)
        {
            for (j = 0; j < COLUMN; j++)
            {
                cout << board[i][j];
            }
            cout << endl;
        }
        //заміна пробілу введеним значенням Х або 0
        cout << "Input 0 or X instead space (0/X) - ";
        cin >> newItem;
        if (newItem == '0' || newItem == 'X')
        {
            for (i = 0; i < ROW; i++)
            {
                for (j = 0; j < COLUMN; j++)
                {
                    if (board[i][j] == ' ')
                    {
                        board[i][j] = newItem;
                    }
                }
            }
        }
        else
            cout << "Wrong Symbol." << endl;

    }

    ////////////////////////////////////////////////////////////////////////////
    //ФУНКЦІЯ ПЕРЕВІРКИ ПЕРЕМОЖЦЯ///////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////
    bool winners(char arr[3][3])
    {
        bool exit = false;
        generation();

        for (i = 0; i < ROW; i++)
        {
            for (j = 0; j < COLUMN; j++)
            {
                if (board[i][j] == 'X')
                {
                    winner1 = true;
                    winner2 = false;
                    if (j == COLUMN - 1)
                    {
                        exit = true;
                    }
                }
                else
                {
                    winner1 = false;
                    break;
                }
            }
            if (exit == true)
                break;
        }

        //перевірка X по вертикалі
        if (winner1 == false)
        {
            for (i = 0; i < ROW; i++)
            {
                for (j = 0; j < COLUMN; j++)
                {
                    if (board[j][i] == 'X')
                    {
                        winner1 = true;
                        winner2 = false;
                        if (j == COLUMN - 1)
                        {
                            exit = true;
                        }
                    }
                    else
                    {
                        winner1 = false;
                        break;
                    }
                }
                if (exit == true)
                    break;
            }
        }

        //перевірка 0 по горизонталі
        if (winner1 == false)
        {
            for (i = 0; i < ROW; i++)
            {
                for (j = 0; j < COLUMN; j++)
                {
                    if (board[i][j] == '0')
                    {
                        winner1 = false;
                        winner2 = true;
                        if (j == COLUMN - 1)
                        {
                            exit = true;
                        }
                    }
                    else
                    {
                        winner2 = false;
                        break;
                    }
                }
                if (exit == true)
                    break;
            }
        }

        //перевірка 0 по вертикалі
        if (winner1 == false && winner2 == false)
        {
            for (i = 0; i < ROW; i++)
            {
                for (j = 0; j < COLUMN; j++)
                {
                    if (board[j][i] == '0')
                    {
                        winner1 = false;
                        winner2 = true;
                        if (j == COLUMN - 1)
                        {
                            exit = true;
                        }
                    }
                    else
                    {
                        winner2 = false;
                        break;
                    }
                }
                if (exit == true)
                    break;
            }
        }
        return winner1, winner2;
    }

    ////////////////////////////////////////////////////////////////////////////
    //ФУНКЦІЯ ВИВОДУ ПЕРЕМОЖЦЯ//////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////
    void whoWin()
    {
        //виклик функцій перевірки
        winners(board);

        //вивід виграшу
        if (winner1 == true && winner2 == true)
        {
            cout << "Both win!" << endl;
        }
        if (winner1 == true && winner2 == false)
        {
            cout << "X wins!" << endl;
        }
        else if (winner1 == false && winner2 == true)
        {
            cout << "0 wins!" << endl;
        }
        else if (winner1 == false && winner2 == false)
        {
            cout << "Nobody wins!" << endl;
        }
        cout << "Board now:" << endl;
        for (i = 0; i < ROW; i++)
        {
            for (j = 0; j < COLUMN; j++)
            {
                cout << board[i][j];
            }
            cout << endl;
        }
    }
};
Головний файл
#include <iostream>
#include "TicTacToe.h"

using namespace std;

int main()
{
    TicTacToe objTicTacToe(3,3);
    objTicTacToe.whoWin();

    return 0;
}