8rainhas.cpp

#include <iostream>
#include <fstream>
#include <string>
#include "8rainhas.hpp"

using namespace std;

/**
 * @brief Converts the file content into an 8x8 integer matrix.
 *
 * This function reads a file and creates a dynamically allocated 8x8 integer matrix based on the file content. 
 * Each line in the file represents a row in the matrix, and each character (0 or 1) represents a column entry.
 *
 * @param filename The name of the file to read.
 * @return A pointer to a dynamically allocated integer matrix.
 *         Returns nullptr if the file is invalid or if there are errors in reading the file content.
 */
int** convert(const char* filename) {
    ifstream file(filename);
    string current;
    // create the pointer for matrix
    int** matrix = new int*[8];
    for (int i = 0; i < 8; ++i) {
        matrix[i] = new int[8];
    }
    int i = 0;
    while (getline(file, current)) {
        string line = "";
        int counter = 0;

        for (char ch : current) {
            // take just the numbers of the file reading
            if (ch == '0' || ch == '1') {
                line += ch;
                if (ch == '1') {
                    counter++;
                }
            }
        }
        if (i >= 8 || line.length() != 8 || counter < 1) {
            // clean up the memory if invalid case: (row or column)
            for (int k = 0; k < 8; ++k) {
                delete[] matrix[k];
            }
            delete[] matrix;
            return nullptr;
        }
        int j = 0;
        for (char ch : line) {
            // adding a equivalent int to pointer
            matrix[i][j] = ch - '0';
            ++j;
        }
        ++i;
    } return matrix;
}
/**
 * @brief Finds horizontal attacks in the matrix.
 *
 * This function identifies and returns the locations of queens that can attack horizontally.
 *
 * @param matrix Pointer to the 8x8 integer matrix.
 * @return A string representing the positions of attacking queens in horizontal direction.
 */
string horizontal(int** matrix) {
    string loc = "";
    for (int i = 0; i < 8; ++i) {
        string add = "";
        int counter = 0;

        for (int j = 0; j < 8; ++j) {
            if (matrix[i][j] == 1) {
                add += to_string(i+1) + "," + to_string(j+1) + " ";
                counter++;
            }
            if (j == 7 && counter == 1) {
                add = "";
            }
            if (j == 7 && add != "") {
                if (loc != "") {
                    loc += "\n";
                }
                loc += add;
            }
        }
    }
    return loc;
}
/**
 * @brief Finds vertical attacks in the matrix.
 *
 * This function identifies and returns the locations of queens that can attack vertically.
 *
 * @param matrix Pointer to the 8x8 integer matrix.
 * @return A string representing the positions of attacking queens in vertical direction.
 */
string vertical(int** matrix) {
    string loc = "";
    for (int j = 0; j < 8; ++j) {
        string add = "";
        int counter = 0;

        for (int i = 0; i < 8; ++i) {
            if (matrix[i][j] == 1) {
                add += to_string(i+1) + "," + to_string(j+1) + " ";
                counter++;
            }
            if (i == 7 && counter == 1) {
                add = "";
            }
            if (i == 7 && add != "") {
                if (loc != "") {
                    loc += "\n";
                }
                loc += add;
            }
        }
    }
    return loc;
}
/**
 * @brief Finds diagonal attacks in the matrix.
 *
 * This function identifies and returns the locations of queens that can attack diagonally.
 *
 * @param matrix Pointer to the 8x8 integer matrix.
 * @return A string representing the positions of attacking queens in diagonal direction.
 */
string diagonal(int** matrix) {
    string loc;
    for (int j = 0; j < 8; ++j) {
        string add = "";
        int i = 0, counter = 0, k = j;

        while (i < 8 && k >= 0) {
            if (matrix[i][k] == 1) {
                add += to_string(i+1) + "," + to_string(k+1) + " ";
                counter++;
            }
            if (k == 0 && counter == 1) {
                add = "";
            }
            if (k == 0 && add != "") {
                if (loc != "") {
                    loc += "\n";
                }
                loc += add;
            }
            i++, k--;
        }
    }
    return loc;
}
/**
 * @brief Finds opposite diagonal attacks in the matrix.
 *
 * This function identifies and returns the locations of queens that can attack along the opposite diagonal.
 *
 * @param matrix Pointer to the 8x8 integer matrix.
 * @return A string representing the positions of attacking queens in opposite diagonal direction.
 */
string di_opo(int** matrix) {
    string loc;
    for (int j = 0; j < 8; ++j) {
        string add = "";
        int i = 0, counter = 0, k = j;

            while (i < 8 && k < 8) {
            if (matrix[i][k] == 1) {
                add += to_string(i+1) + "," + to_string(k+1) + " ";
                counter++;
            }
            if (k == 0 && counter == 1) {
                add = "";
            }
            if (k == 0 && add != "") {
                if (loc != "") {
                    loc += "\n";
                }
                loc += add;
            }
            i++, k++;
        }
    }
    return loc;
}
/**
 * @brief Combines all attack directions.
 *
 * This function combines the results of horizontal, vertical, diagonal, and opposite diagonal attack detections.
 *
 * @param matrix Pointer to the 8x8 integer matrix.
 * @return A string representing the combined positions of attacking queens in all directions.
 */
string attack(int** matrix) {
    string h = horizontal(matrix);
    string v = vertical(matrix);
    string d = diagonal(matrix);
    string o = di_opo(matrix);
    string sum;
    if (h != "") {
        sum = h;
    }
    if (v != "") {
        if (sum != "") {
            sum += "\n" + v;
        } else {
            sum = v;
        }
    }
    if (d != "") {
        if (sum != "") {
            sum += "\n" + d;
        } else {
            sum = d;
        }
    }
    if (o != "") {
        if (sum != "") {
            sum += "\n" + o;
        } else {
            sum = o;
        }
    }
    return sum;
}
/**
 * @brief Main function in charge of the execution of the program.
 *
 * This function calls the convert function to read the file and process its content.
 * It also deallocates memory used by the matrix returned by convert and writes the output to "ataques.txt".
 *
 * @param filename The name of the file to read.
 * @return 0 if the program executes successfully, -1 if an error occurs.
 */
int body(const char* filename) {
    int output = 0;
    int** matrix = convert(filename);
    if (matrix != nullptr) {
        string loc = attack(matrix);
        if (loc == "") {
            output = 1;
        } else {
            ofstream outfile("ataques.txt");
            outfile << loc << endl;
            outfile.close();
        }
        for (int j = 0; j < 8; ++j) {
            delete[] matrix[j];
        }
        delete[] matrix;
    } else {
        output = -1;
    }
    return output;
}