Как суммировать размеры массива, заданного во время выполнения?

Это может иметь приложения. Допустим, вы реализовали игру жизни Конвея 2D (которая определяет плоскость 2D, 1 для 'alive', 0 для 'dead'), и вы сохранили историю игр для каждой итерации (которая затем определяет куб 3D). Если бы вы хотели знать, сколько бактерий было живым за всю историю, вы бы использовали приведенный выше алгоритм. Вы можете использовать тот же алгоритм для A 3D, (и 4D, 5D и т. д.) версия Game of Life grid.

Я бы сказал, что это был вопрос для рекурсии, я еще не программист C, но я знаю, что это возможно в C. В python,

def iter_arr(array):
  sum = 0
  for i in array:
    if type(i) == type(list()):
      sum = sum + iter_arr(i)
    else:
      sum = sum + i
  return sum 

1. Перебирать каждый элемент в массиве
2. Если элемент является другим массивом, вызовите функцию еще раз
3. Если элемент не является массивом, добавьте его в сумму
4. Возврат суммы

Затем вы примените это к каждому элементу в измерении 'cared about'.

Это проще в python из-за утиной печати, хотя ...

@Jeff

Я действительно думаю, что это интересный вопрос. Я не уверен, насколько это полезно, но это правильный вопрос.

@Ed

Можете ли вы предоставить немного больше информации по этому вопросу? Вы сказали, что размер массива является динамическим, но является ли число элементов динамическим?

EDIT: я все равно попытаюсь ответить на этот вопрос. Я не могу дать вам код с моей головы (это займет некоторое время, чтобы получить его правильно без какого-либо компилятора здесь на этом PC), но я могу указать вам в правильном направлении ...

В качестве примера возьмем 8 измерений (0-7) с индексами от 0 до 3. Вы заботитесь только о 1,2 и 6. Это означает, что у вас есть два массива. Во-первых, array_care[4][4][4] для 1,2 и 6. array_care[4][4][4] будет содержать конечный результат.

Далее, мы хотим сделать итерацию очень специфическим способом. У нас есть массив input[4][4][4][4][4][4][4][4] для разбора, и мы заботимся о размерах 1, 2 и 6.

Нам нужно определить некоторые временные индексы:

int dim[8] = {0,0,0,0,0,0,0,0};

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

int increase_index_order[8] = {7,5,4,3,0,6,2,1};
int i = 0;

Этот заказ важен для выполнения того, что вы просили.

Определение флага завершения:

bool terminate=false;

Теперь мы можем создать наш цикл:

while (terminate)
{
array_care[dim[1]][dim[2]][dim[6]] += input[dim[0]][dim[1]][dim[2]][dim[3]][dim[4]][dim[5]][dim[6]][dim[7]];

while ((dim[increase_index_order[i]] = 3) && (i < 8))
{
dim[increase_index_order[i]]=0;
i++;
}

if (i < 8) {
dim[increase_index_order[i]]++; i=0;
} else {
terminate=true;
}
}

Это должно работать для 8 измерений, заботясь о 3 измерениях. Это займет немного больше времени, чтобы сделать его динамичным, и у меня нет времени. Надеюсь, это поможет. Прошу прощения, но я еще не выучил кодовые накладки. :(

Это намного проще, если вы используете контейнеры STL или, возможно, Boost.MultiArray . Но если вы должны использовать массив:

#include <iostream>
#include <boost/foreach.hpp>
#include <vector>

int sum(int x) {
    return x;
}

template <class T, unsigned N>
int sum(const T (&x)[N]) {
    int r = 0;
    for(int i = 0; i < N; ++i) {
        r += sum(x[i]);
    }
    return r;
}

template <class T, unsigned N>
std::vector<int> reduce(const T (&x)[N]) {
    std::vector<int> result;
    for(int i = 0; i < N; ++i) {
        result.push_back(sum(x[i]));
    }
    return result;
}

int main() {
    int x[][2][2] = {
        { { 1, 2 }, { 3, 4 } },
        { { 5, 6 }, { 7, 8 } }
    };

    BOOST_FOREACH(int v, reduce(x)) {
        std::cout<<v<<"\n";
    }
}

На самом деле, свернув столбцы, вы уже суммировали их, поэтому размерность не имеет никакого значения для вашего примера. Я что-то пропустил или ты?

Я думаю, что лучше всего было бы сделать здесь одну / обе из двух вещей:

1. Переосмыслите дизайн, если он слишком сложный, найдите менее сложный способ.
2. Перестаньте пытаться визуализировать это.. :P просто сохраните соответствующие измерения, которые вам нужно суммировать,а затем выполняйте их по одному. После того, как у вас есть базовый код, а затем посмотреть на повышение эффективности вашего алгоритма.

Я позволю себе не согласиться, есть ALWAYS другой способ..

И если вы действительно не можете рефакторинг, то вам нужно разбить проблему на более мелкие части.. Как я уже сказал, определите, какие измерения вам нужно суммировать,а затем ударяйте по ним по одному..

Кроме того, прекратите изменять правки, они исправляют ваши орфографические ошибки, они пытаются помочь вам ;)

Когда вы говорите, что не знаете, сколько существует измерений, как именно вы определяете структуры данных?

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

Если только речь не идет о том, чтобы определить такую структуру данных...

Вы делаете это в c/c++..., так что у вас есть массив массива массива... вам не нужно визуализировать 20 измерений, так как это не так, как данные выложены в памяти, для 2-мерного:

[1] --> [1,2,3,4,5,6,...]
[2] --> [1,2,3,4,5,6,...]
[3] --> [1,2,3,4,5,6,...]
[4] --> [1,2,3,4,5,6,...]
[5] --> [1,2,3,4,5,6,...]
 .           .
 .           .
 .           .

Итак, почему вы не можете перебрать первый, суммируя его содержимое? Если вы пытаетесь найти размер, то sizeof(array)/sizeof(int) -это рискованный подход. Вы должны знать измерение, чтобы иметь возможность обрабатывать эти данные и настраивать память, поэтому вы знаете глубину рекурсии для суммирования. Вот некоторые псевдо-код того, что, кажется, вы должны сделать,

sum( n_matrix, depth )
  running_total = 0
  if depth = 0 then
    foreach element in the array
      running_total += elm
  else 
     foreach element in the array
       running_total += sum( elm , depth-1 )
  return running_total

x = number_of_dimensions;
while (x > 1)
{
  switch (x)
  {
    case 20:
      reduce20DimensionArray();
      x--;
    break;
    case 19:
      .....
  }
}

(Извините, не удержался.)

Если я правильно понимаю, вы хотите суммировать все значения в поперечном сечении, определенном в каждом "bin" вдоль 1 измерения. Я предлагаю сделать 1D массив для вашего назначения, а затем перебирать каждый элемент в вашем массиве, добавляя значение в пункт назначения с индексом интересующего измерения.

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