Код C++ необходимо укоротить

Question

как можно я могу сократить это?

if(moves[1] == moves[4] && moves[4] == moves[7]) { return 1;} 
else if(moves[1] == moves[2] && moves[2] == moves[3]) { return 1;} 
else if(moves[4] == moves[5] && moves[5] == moves[6]) { return 1;} 
else if(moves[7] == moves[8] && moves[8] == moves[9]) { return 1;} 
else if(moves[1] == moves[5] && moves[5] == moves[9]) { return 1;} 
else if(moves[3] == moves[5] && moves[5] == moves[7]) { return 1;} 
else if(moves[2] == moves[5] && moves[5] == moves[8]) { return 1;} 
else if(moves[3] == moves[6] && moves[6] == moves[9]) { return 1;} 
else if (moves[1] != '1' && moves[2] != '2' && moves[3] != '3' && moves[4] != '4' && moves[5] != '5' && moves[6] != '6' && moves[7] != '7' && moves[8] != '8' && moves[9] != '9') { 
return 2;} 

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

я не могу думать ни о каком пути другого способе чтобы сделать это из-за случайных комбинаций чисел

Приведенный выше код является функцией называется CheckWinner, которая проходит над входом пользователь выбрал с массивом, какие позиции были заполнены

код проверяет ход [ позиции] против других комбинаций выигрышного хода и возвращает 1, если обнаружен выигрышный ход.

Последний бит кода проверяет все пробелы на сетке и, если нет пробелов, возвращает 2, чтобы вызвать ничью.

Надеется, что это помогает

Answer 1

Я не уверен, что это поможет, но я дам ему попробовать: то, что я вижу в вашем коде Теперь на первом взгляде является то, что большинство вашего условных вернуть 1, только в одном в случае, если вы вернетесь 2. Поэтому я бы просто написал условие if для возвращения 2, и в все остальные случаи return 1, не так ли?

например.

if (moves[1] != '1' && moves[2] != '2' && moves[3] != '3' && moves[4] != '4' && moves[5] != '5' && moves[6] != '6' && moves[7] != '7' && moves[8] != '8' && moves[9] != '9') { 
return 2;} 
else 
{ 
// return 1 probably 
} 

хмм ... нет, я беру свои слова обратно в коде выше всех остальных случаях будет возвращать 1, а в вашем случае может быть ситуации, когда вы не хотите, 1 должны быть возвращены ...

Answer 2

Не все номера являются случайными ... Для строк формула: N*3+1, N*3+2, N*3+3, для столбцов N+1, N+4, N+7 и т. Д., Где 0 <= N <= 2. Много других способов представить это. Вы можете создавать отдельные функции для проверки строк, столбцов и диагоналей.

Answer 3

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

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

Answer 4

template <typename T> bool equal(T a, T b, T c) { return (a==b) && (b==c); } 

int foo(char (&moves)[10]) 
{ 
    auto eqset = [&](int i1, int i2, int i3) { return equal(moves[i1], moves[i2], moves[i3]); }; 
    if (eqset(1,4,7) || eqset(1,2,3) || eqset(4,5,6) || eqset(7,8,9) || eqset(1,5,9) || eqset(3,5,7) || eqset(2,5,8) || eqset(3,6,9)) 
     return 1; 
    else if (moves[1] != '1' && moves[2] != '2' && moves[3] != '3' && moves[4] != '4' && moves[5] != '5' && moves[6] != '6' && moves[7] != '7' && moves[8] != '8' && moves[9] != '9') { 
     return 2; 
    } 
} 

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

В противном случае, вы можете продолжить что-то вроде:

for (int i = 1; i<10; i++) 
    if (moves[i] == ('0'+i)) 
     return 0; // ??? 

return 2; 

Answer 5

Как о чем-то вроде этого:

#include <stdio.h> 

int winners[8][3] = { {1, 2, 3}, 
      {4, 5, 6}, 
      {7, 8, 9}, 
      {1, 4, 7}, 
      {2, 5, 8}, 
      {7, 8, 9}, 
      {1, 5, 9}, 
      {3, 5, 7}}; 

int moves[10] = { 0, 
      1, 2, 0, 
      0, 2, 0, 
      0, 2, 1}; 

int main() 
{ 
    int i; 
    for (i=0;i<8;++i) 
    { 
     if (moves[winners[i][0]] == moves[winners[i][1]] && 
      moves[winners[i][1]] == moves[winners[i][2]]) 
      printf("Player %d wins!\n",moves[winners[i][0]]); 
    } 
    return 0; 
} 

Победители массива описывает различные выигрышные комбинации и цикл проверяет каждый из них.

Answer 6

Это проверка на победу ... Вероятно, вы можете сказать, что это «короче».

// Check rows and columns 
for(int i = 0; i < 3; i++) { 
    char *row = &moves[3*i+1]; 
    char *col = &moves[i+1]; 
    if(row[0] == row[1] && row[0] == row[2]) return 1; 
    if(col[0] == col[3] && col[0] == col[6]) return 1; 
} 

// Check diagonals 
if(moves[1] == moves[5] && moves[1] == moves[9]) return 1; 
if(moves[3] == moves[5] && moves[3] == moves[7]) return 1; 

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

Answer 7

Вы можете просто сократить свой код, используя макрос:

#define comp(i,j,k) (moves[i]==moves[j] && moves[j]==moves[k]) 
return comp(1,2,3) || comp(4,5,6) || comp(7,8,9) 
    || comp(1,5,9) || comp(3,5,7) || comp(2,5,8); 

В противном случае, вы можете вращать доску:

#define comp(i,j,k) (moves[i]==moves[j] && moves[j]==moves[k]) 

int rot[6][2] = { {1, 3}, {7, 9}, {9, 1}, {2, 6}, {4, 8}, {2, 8} }; 
for (int x = 0; x < 4; x++) { 
    if (comp(1,2,3) || comp(4,5,6) || comp(1,5,9))) 
     return 1; 
    for (int i = 0; i < 6; i++) 
     std::swap(moves[rot[i][0]], moves[rot[i][1]]); 
} 
return 0; 

Вот код полный C++, с объяснением (она легко может быть простым C, а не C++, но мне нравится std::swap). Плата содержит бессмысленные цифры, так что вы можете увидеть вращение:

#include <iostream> 

void print_tic(int moves[]) { 
    for (int i = 1; i < 10; i += 3) 
     std::cout << moves[i] << moves[i + 1] << moves[i + 2] << std::endl; 
    std::cout << std::endl; 
} 

void rotate(int moves[]) { 
    static const int rot[6][2] = {{1, 3}, {7, 9}, {9, 1}, {2, 6}, {4, 8}, {2, 8} }; 
    for (int i = 0; i < 6; i++) 
     std::swap(moves[rot[i][0]], moves[rot[i][1]]); 
} 

int comp(int moves[], int i, int j, int k) { 
    return moves[i]==moves[j] && moves[j]==moves[k]; 
} 

int main() { 
    int moves[10] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; //meaningless. 

    print_tic(moves); 
    for (int x = 0; x < 4; x++) { 
     rotate(moves); 
     print_tic(moves); 
     if (comp(moves, 1,2,3) // first row 
      || comp(moves, 4,5,6) // second row - forget that earlier 
      || comp(moves, 1,5,9)) // main diagon 
      return 1; 
    } 
    return 0; 
} 

с распечаток, вы можете увидеть ротацию:

123 
456 
789 

741 
852 
963 

987 
654 
321 

369 
258 
147 

123 
456 
789 

Вы можете повернуть только один раз, в expnse более comp() один для третья строка.