Сумма строк с использованием двумерного массива

Question

Я хочу создать функцию, которая получает данные [3] [4] и получает сумму каждой строки. Возвращаемый массив должен быть создан с помощью (new) и возвращен (int *). Но я не знаю, как я могу использовать новые и int *.

#include <iostream>

using namespace std;

int sum(int arr[][4], int size);

int main()
{
    int data[][4] = {
        {1, 2, 3, 4},
        {9, 2, 4, 6},
        {4, 2, 6, 8}
        };

    cout << "sum of row0: " << sum(data, 0) << endl;
    cout << "sum of row1: " << sum(data, 1) << endl;
    cout << "sum of row2: " << sum(data, 2) << endl;
    return 0;
}

int sum(int arr[][4], int size)
{

    int total = 0;

    for (int c = 0; c < 4; c++)
    {
        total += arr[size][c];
    }

    return total;
}

Answer 1

#include <iostream>

using namespace std;

int *sum(int arr[][4], int size);

int main()
{
    int data[][4] = {
         {1,2,3,4}
        ,{9,2,4,6}
        ,{4,2,6,8}
    };

    int* sum1 = sum(data, 0);
    int* sum2 = sum(data, 1);
    int* sum3 = sum(data, 2);

    cout << "sum of row0: " << *sum1 << endl;
    cout << "sum of row1: " << *sum2 << endl;
    cout << "sum of row2: " << *sum3 << endl;

    delete sum1;
    delete sum2;
    delete sum3;

    return 0;
}

int* sum(int arr[][4], int size)
{

    int* total = new int(0);

    for (int c = 0; c < 4; c++)
    {
        *total += arr[size][c];
    }

    return total;
}

Если вы хотите вернуть массив сумм, вы можете сделать что-то вроде этого.

#include <iostream>

using namespace std;

int *sum(int arr[][4]);

int main()
{
    int data[][4] = {
         {1,2,3,4}
        ,{9,2,4,6}
        ,{4,2,6,8}
    };

    int* sumArray = sum(data);

    cout << "sum of row0: " << sumArray[0] << endl;
    cout << "sum of row1: " << sumArray[1] << endl;
    cout << "sum of row2: " << sumArray[2] << endl;

    // remember to free the allocated memory.
    delete[] sumArray;

    return 0;
}

int* sum(int arr[][4])
{

    int* total = new int[3]{ 0 };

    for (int i = 0; i < 3; i++)
        for (int c = 0; c < 4; c++)
        {
            total[i] += arr[i][c];
        }

    return total;
}

Но я предлагаю вам использовать std::vector insted и не использовать ключевое слово new.

Answer 2

Прежде всего, я думаю, что вы принимаете этот вопрос неправильно. Если мы отправляем один di git взамен, нам не нужен массив указателей. Поскольку мы не можем вернуть массив из функции C ++, мы используем массив указателей для возврата массива.

вы передаете двумерный массив функции, а затем он должен вернуть массив суммы для каждой строки. Например,

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

Теперь вызывающая функция sum (data, numOfRows) должна возвращать массив суммы для каждой строки, например

result = [6, 15, 24]

Где по 0-му индексу результата мы имеем сумму 0-го строка. по первому индексу результата мы имеем сумму 1-й строки, а по второму индексу результата - сумму 2-й строки.

Если это так, то теперь возвращаемым типом вашей функции будет указатель

int * sum(int arr[][3], int size){

}

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

int * sum(int arr[][4], int rows, int cols){
    int* total = new int[size];
    for (int i = 0; i < size; i++){
        for (int j = 0; j < cols; j++){
            total[i] += arr[i][j];
        }
    }
    return total;
}

Теперь в основной функции вы можете использовать этот результат.

int rows = 3;
int cols = 3;
int* result = sum(data, rows, cols);
for(int i=0; i<rows; i++{
    cout << "sum of row "<<i<< ": " << result[i] << endl;

}

Дальнейшие улучшения могут сделать эту программу более динамичной c для обработки всех видов двумерных массивов.

Answer 3

Вы можете написать эту функцию, используя STL, например:

int* sum(const int a[][4])
{
    int *result = new int[3];

    std::transform(a, a + 3, result, [](auto row) {
                     return std::accumulate(row, row + 4, 0);
                   }); 

    return result;
}

Конечно, не забудьте удалить память на сайте вызовов.

Answer 4

Вам нужно следующее:

#include <iostream>

const size_t N = 4;

int * sum( const int a[][N], size_t n )
{
    int *result = new int[n];

    for ( size_t i = 0; i < n; i++ )
    {
        result[i] = 0;
        for ( const int &item : a[i] ) result[i] += item;
    }

    return result;
}

int main() 
{
    int data[][N] = 
    {
        { 1, 2, 3, 4 },
        { 9, 2, 4, 6 },
        { 4, 2, 6, 8 }
    };

    const size_t M = sizeof( data ) / sizeof( *data );  

    auto result = sum( data, M );

    for ( size_t i = 0; i < M; i++ ) std::cout << i << ": " << result[i] << '\n';

    delete [] result;

    return 0;
}

Выход программы:

0: 10
1: 21
2: 20

То есть в функции sum вам нужно динамически выделить массив с номером элементов, равных количеству строк в двумерном массиве, переданных функции в качестве аргумента.

Не забудьте освободить его, когда он больше не нужен.

Вы можете написать более обобщенную c функцию, которая способна обрабатывать двумерные массивы различных размеров. Например,

#include <iostream>

template <size_t M, size_t N>
int * sum( const int ( &a )[M][N] )
{
    int *result = new int[M];

    for ( size_t i = 0; i < M; i++ )
    {
        result[i] = 0;
        for ( const int &item : a[i] ) result[i] += item;
    }

    return result;
}

int main() 
{
    const size_t N = 4;
    int data[][N] = 
    {
        { 1, 2, 3, 4 },
        { 9, 2, 4, 6 },
        { 4, 2, 6, 8 }
    };
    const size_t M = sizeof( data ) / sizeof( *data );

    auto result = sum( data );

    for ( size_t i = 0; i < M; i++ ) std::cout << i << ": " << result[i] << '\n';

    delete [] result;

    return 0;
}

Вывод программы будет таким же, как показано выше.

0: 10
1: 21
2: 20

Также было бы лучше определить тип возвращаемого значения как long long int.

long long int * sum( const int a[][N], size_t n )
{
    long long int *result = new long long int[n];

    for ( size_t i = 0; i < n; i++ )
    {
        result[i] = 0;
        for ( const int &item : a[i] ) result[i] += item;
    }

    return result;
}

В этом случае риск переполнения рассчитанных сумм можно минимизировать.