Добавление строк в 2D массив

Question

Пользователь вводит желаемый массив желаемых rows и columns. Код должен просмотреть массив и найти все строки с хотя бы одним отрицательным числом. Если найден, то код добавляет новую строку zeros ниже найденной строки.

Код

#include <pch.h>
#include <iostream>

using namespace std;

int main()
{
int rows, columns;
std::cout << "Enter the number of rows: ";
std::cin >> rows;
std::cout << "Enter the number of columns: ";
std::cin >> columns;


int **array = new int*[rows];                  //Generating a 2-D array
for (int i = 0; i < rows; i++)
    array[i] = new int[columns];

std::cout << "Enter the elements" << std::endl;
for (int i = 0; i < columns; i++)              //loop for input array 
    for (int j = 0; j < rows; j++)             //elements
        std::cin >> array[i][j];

for (int i = 0; i < columns; i++) {            //print the array
    for (int j = 0; j < rows; j++) {
        std::cout << array[i][j] << " ";
    }
    std::cout << "\n";
}
for (int i = 0; i < columns; i++) {             //finding rows with negative
    for (int j = 0; j < rows; j++) {            //numbers and adding a new 
        if (array[i] < 0) {                     // row of zeros below
            array[i + 1][j] = 0;
            std::cout << array[i][j] << " ";
        }
    }
    std::cout << "\n";
}

return 0;
}

Например,
Если мы введем массив, как
1 1 1 1 1<br> 2 -2 2 -2 2<br> 3 3 3 3 3<br> 4 -4 -4 4 4<br> 5 5 5 5 5
Ответ должен быть
1 1 1 1 1<br> 2 -2 2 -2 2<br> 0 0 0 0 0 -----> new rows added<br> 3 3 3 3 3<br> 4 -4 -4 4 4 ------> new rows added<br> 0 0 0 0 0<br> 5 5 5 5 5
Но мой код не делает этого?

Answer 1

Этот main.cpp производит желаемый вывод плюс некоторый мониторинг.

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

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

В противном случае программа оставлена ​​как есть, для этого будет достаточно половины размера массива (1x строк на 1x столбцов).

#include <iostream>

int main() {
    // The **wished for** array dimensions.
    int rows{0}, columns{0};

    std::cout << "Enter the number of rows: ";
    std::cin  >>  rows;

    std::cout << "Enter the number of columns: ";
    std::cin  >>  columns;

    // ------------------------------------------------- ALLOCATION START ----

    // Generating 2-D array.
    int ** array = new int* [2 * rows];  // (*)

    // (*) Suppose all the rows are bad, i. e., with some negative number(s),
    //     then **each and every** single row had to be followd by zeroes.

    // Allocating the columns.
    for (int i = 0; i < 2 * rows; i++) {
        array[i] = new int[columns];
    }


    // NEW --- NEW ---- NEW

    // Allocate bool array indicating that row[i] must be followed by zeroes. 
    bool* want_zeroes = new bool[rows];

    for (int i = 0; i < rows; i++) want_zeroes[i] = false;     // Initialize

    // ----------------------------------------------- ALLOCATION END -----

    std::cout << "-- -- -- -- \n";

    // --------------------------------------------------- INTAKE START ---

    std::cout << "Enter the elements" << std::endl;

    for (int i = 0; i < rows; i++)              //loop for input array 
        for (int j = 0; j < columns; j++)             //elements
            std::cin >> array[i][j];

    std::cout << "-- -- -- -- \n";

    std::cout << "Print the elements" << std::endl;

    // Monitor original array.
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < columns; j++) {
            std::cout << array[i][j] << " ";
        }

        std::cout << "\n";
    }

    // -------------------------------------------------- INTAKE END -------

    std::cout << "-- -- -- -- \n";

    // --------------------------------------------------- CHECK START ----

    std::cout << "Print want_zeroes" << std::endl;

    for (int i = 0; i < rows; i++) {             //finding rows with negative
        for (int j = 0; j < columns; j++) {            //numbers and adding a new 

            // Check for negative element.
            if (array[i][j] < 0) {

                // Boom, found a bad row!
                // So, this is row so-and-so,
                // which needs to be followed
                // by a row of zeroes later.

                want_zeroes[i] = true;
            }
        }

        // Monitor.
        std::cout << std::boolalpha << want_zeroes[i] << '\n';
    }

    // -------------------------------------------------- CHECK END ------

    std::cout << "-- -- -- -- \n";

    // -------------------------------------- CONSTRUCT OUTPUT START -----

    // We use the quick-and-dirty solution, not modifying the original
    // array, but just outputting the solution to stdout, see if it's ok.

    std::cout << "Print resulting array" << std::endl;

    for (int i = 0; i < rows; i++) {

        // Output current original row anyway. 
        for (int j = 0; j < columns; j++) {
            std::cout << array[i][j] << ' ';
        }

        std::cout << '\n';

        // Was this a bad row?
        if (want_zeroes[i]) {

            // Yes! -- Output a row of zeroes.
            for (int j = 0; j < columns; j++) {
                std::cout << 0 << ' ';
            }

            std::cout << '\n';
        }
     }

    // -------------------------------------- CONSTRUCT OUTPUT END -------


    // ------------------------------------------ DEALLOCATION START -----

    // Dealocate want_zerores.
    if (want_zeroes != nullptr) {
        delete[] want_zeroes;
        want_zeroes  = nullptr;
    }


    // Deallocate the array's columns.
    for (int i = 0; i < 2 * rows; i++) {
        if (array[i] != nullptr) {
            delete[] array[i];
            array[i]  = nullptr;
        }
    }

    // Dealocate array.
    if (array != nullptr) {
        delete[] array;
        array  = nullptr;
    }

    // ------------------------------------------- DEALLOCATION END -------

    return 0;
}

С уважением, Миха