Попытка сравнить символы из матрицы C

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

так вот мой код:

#include <stdio.h>
#include <math.h>
#include <assert.h>
#include <limits.h>
#include <string.h>
#include <stdlib.h>

#define MAX_LINES 1000
#define MAX_LINE_LENGTH 1000

//---------------------
//READING & WRITING
//---------------------

char *ints_new(int n)
{
    return (char *) malloc(n * sizeof(char));
} 

char **ints2_new(int rows, int cols)
{
    char **result = (char **) malloc(rows * sizeof(char *));
    char *p = ints_new(rows * cols);
    for (int i = 0; i < rows; i++, p += cols)
        result[i] = p;
    return result;
} 


int str_readline(FILE *f, char *s) 
{   
    int result = EOF; 
    char *p = fgets(s, INT_MAX, f); 
    if (p != NULL) 
    { 
        result = (int) strlen(s); 
        if (result > 0 && s[result-1] == '\n') 
            s[--result] = '\0'; 
    } 
    return result; 
} 

char *str_dup(const char *s) 
{ 
    char *result = (char *) malloc(strlen(s) + 1); 
    strcpy(result, s); 
    return result; 
} 

int strings_read(FILE *f, char **a) 
{ 
    int result = 0; 
    char line[MAX_LINE_LENGTH + 2]; 
    while (str_readline(f, line) != EOF) 
        a[result++] = str_dup(line); 
    return result; 
}  
// --------------------
//    Problema A
// --------------------

void values_to_m(char **m, int rows, int cols, char **readings)
{
    int i;
    int j;
    int k = 0;
    int l = 0;
    for(i = 0; i < rows; i++)
    {
        for(j = 0; j < cols; j++)
        {
            m[i][j] = readings[k][l];
            l++;
        }
        k++;
        l = 0;
    }
}

int count_points(char **m, int i, int j, int rows, int cols)
{
    int result = 0;
    if(i < rows-2)
    {
        if(m[i][j] == m[i+1][j] == m[i+2][j])
            result++;
        if(j < cols-2)
        {
            if(m[i][j] == m[i][j+1] == m[i][j+2])
                result++;
            if(m[i][j] == m[i+1][j+1] == m[i+2][j+2])
                result++;
        }
        if(j > 1)
        {
            if(m[i][j] == m[i+1][j-1] == m[i+2][j-2])
                result++;
        }
    }
    else
    {
        if(j < cols-2)
        {
            if(m[i][j] == m[i][j+1] == m[i][j+2])
                result++;
        }
    }
    printf("%d\n", result);
    return result;
}

void points(char **m, int rows, int cols)
{
    int i;
    int j;
    int player1 = 0; //O's
    int player2 = 0; //X's
    for(i = 0; i < rows; i++)
    {
        for(j = 0; j < cols; j++)
        {
            int count;
            count = count_points(m, i, j, rows, cols); //counts points
            if (m[i][j] == 'X') //if values i'm couning are X, points go to player 2
                player2 += count;
            else if(m[i][j] == 'O') //if O go to player 1
                player1 += count;
        }
    }
    printf("%d %d\n", player1, player2);
}

// --------------------
// --------------------

void test_problem_A()
{
    char **readings = malloc((MAX_LINES * MAX_LINE_LENGTH) * sizeof(char) + 1);
    int rows = strings_read(stdin, readings); //to read from console
    int cols = strlen(readings[0]);

    printf("%d\n%d\n", rows, cols); //just to make sure nr of rows and cols is right
    char **m = ints2_new(rows, cols); //create matrix

    values_to_m(m, rows, cols, readings); //put the values to matrix
    points(m, rows, cols); //calculate points

    ints2_printf(m, rows, cols, "%c");
}

// --------------------
// --------------------

int main(int argc, char **argv)
{
    test_problem_A();
    return 0;
}

Моя программа должна читать кучу 'X', 'O' и '.'.

Если в ряду 3 "Х" (вертикальный, горизонтальный или диагональный), игрок 2 получает 1 очко, если то же самое происходит с "О", игрок 1 получает 1 очко. '' не считайте никаких очков.

моя матрица должна была иметь минимум 3 строки и столбцы и максимум 1000 строк и столбцов.

пример: если я положу в консоль

XXO
OXO
OXO

игрок 1 и 2 каждый получает 1 очко

если я положу:

XXXXXO  //(int this line Player 2 get 3 points because there are 3 times 3 X in a row)
OXOXOO
OXOOXO
OXOXOO

игрок 1 получает 5 очков, а игрок 2 получает 6 очков

Так что моя проблема в том, что функция count_points не учитывает баллы, когда я печатаю "result", она всегда дает мне 0 баллов.

Могу ли я сравнить 2 символа, если они принадлежат матрице?

Спасибо

2 ответа

Решение

В count_points, вы пытаетесь сравнить три значения с такими выражениями, как

if (a == b == c) ...

Это не делает то, что вы думаете, что делает. Вы рассматриваете это как сравнение в математической записи, но C интерпретирует это как:

if ((a == b) == c) ...

Сравнение a == b дает либо 0, либо 1. Этот результат затем сравнивается с c,

Вы можете переписать желаемое выражение как

if (a == b && b == c) ...

Учитывая, что ваш a, b а также c являются составными выражениями, для этого можно написать небольшую функцию:

static int eq3(int a, int b, int c)
{
    return (a == b && b == c);
}

int count_points(char **m, int i, int j, int rows, int cols)
{
    int result = 0;

    if (i < rows-2) {
        if (eq3(m[i][j], m[i+1][j], m[i+2][j]))
            result++;

        if (j < cols - 2) {
            if (eq3(m[i][j], m[i][j+1], m[i][j+2]))
                result++;
            if (eq3(m[i][j], m[i+1][j+1], m[i+2][j+2]))
                result++;
        }

        if (j > 1) {
            if (eq3(m[i][j], m[i+1][j-1], m[i+2][j-2]))
                result++;
        }
    } else {
        if (j < cols-2) {
            if (eq3(m[i][j], m[i][j+1], m[i][j+2]))
                result++;
        }
    }

    return result;
}

Что касается распределения вашей матрицы, смотрите ответ алка. Ваш способ размещения - один char ** для строк, а затем дублирование строк для данных строк, может оставить вас с рваным массивом, и вы не можете безопасно получить доступ m[j + 1][i] для некоторых случаев, когда i действительный индекс для строки j, но не для ряда j + 1,

Для начала, здесь вы хотите выделить указатели на char:

char **readings = malloc((MAX_LINES * MAX_LINE_LENGTH) * sizeof(char) + 1);

Так что сделайте так:

char **readings = malloc((MAX_LINES * MAX_LINE_LENGTH) * sizeof(char*) + 1);

или даже лучше:

char **readings = malloc((MAX_LINES * MAX_LINE_LENGTH) * sizeof *readings + 1);
Другие вопросы по тегам