Блог

Привет, мне нужна следующая логика для реализации в n массивах (двумерных).Здесь я рассмотрел 3 одномерных массива

 #include<stdio.h>
main()
{
    int a[4]={2,1,4,7},b[4]={3,-3,-8,0},c[4]={-1,-4,-7,6},sum,i,j,k,val=0;
    for(i=0;i<4;i  ) {
        for(j=0;j<4;j  ) {
            for(k=0;k<4;k  ) {
                sum = a[i] b[j] c[k];
                if(sum == val)
                printf("%d  %d  %dn", a[i], b[j], c[k]);
            }
        }
    }
  

}

Результат: 2-8 6 ; 13-4 ; 10 -1 ; 4 3-7 ; 4 -3 -1 ; 4 0-4 ; 7-3 -4 ; 7 0-7 ;

Пожалуйста, смотрите синтаксис C в Википедии для получения информации о синтаксисе.

На практике вам нужно использовать int array[3] [4] = … для создания массива с 3 строками и 4 столбцами. Далее в коде замените обращения к текущим массивам a, b и c фиксированным индексом строки для каждого случая.

Остальная часть реализации оставлена в качестве упражнения, поскольку для меня это звучит как домашнее задание.

Хорошая проблема 🙂
Я не буду публиковать свое полное решение, потому что проблема, похоже, является домашней работой. Всего несколько указателей …

Я решил это с помощью рекурсии: процесс упрощения, который я использовал, заключался в том, что нахождение суммы target в n массивах совпадает с нахождением суммы target - ONE_ELEMENT в n-1 массивах.

Пример использования ваших 3 массивов и нулевого целевого значения

 find 3 elements with sum 0           in {2, 1, 4, 7}, {3, -3, -8, 0}, {-1, -4, -7, 6}
find 2 elements with sum 0 - 2 (-2)  in {3, -3, -8, 0}, {-1, -4, -7, 6}
find 1 elements with sum -2 - 3 (-5) in {-1, -4, -7, 6}              NOT FOUND
find 1 elements with sum -2 - -3 (1) in {-1, -4, -7, 6}              NOT FOUND
find 1 elements with sum -2 - -8 (6) in {-1, -4, -7, 6}              YAY! FOUND
...
  

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

Структура массивов была

 struct sizedarray {
  int *data;
  size_t nelems;
};
  

и прототипы для рекурсивных и вспомогательных функций были

 findtarget(int target, struct sizedarray *arrays, size_t narrays);
findtarget_recursive(int target, struct sizedarray *arrays, size_t narrays, size_t level, int *saved);
  

Отредактировано для добавления рабочего решения

 #include <stdio.h>
#include <stdlib.h>

/* struct to hold arrays with varying sizes */
struct sizedarray {
  int *data;
  size_t nelems;
};

void findtarget_recursive(int target,
                         struct sizedarray *arrays,
                         size_t narrays,
                         size_t level,
                         int *saved) {
  size_t k, j;
  struct sizedarray *curarray = arrays   level;

  /* if no arrays left to search return */
  if (level == narrays) {
    return;
  }
  /* if only 1 arrays do not recurse */
  if (level   1 == narrays) {
    for (k = 0; k < curarray->nelems; k  ) {
      if (curarray->data[k] == target) {
        /* print saved elements from previous arrays */
        for (j = 0; j < level; j  ) {
          printf("%d ", saved[j]);
        }
        /* print current element from current array */
        printf("%dn", curarray->data[k]);
      }
    }
    return;
  } else {
    /* when 2 or more arrays left, recurse */
    for (k = 0; k < curarray->nelems; k  ) {
      saved[level] = curarray->data[k];
      findtarget_recursive(target - curarray->data[k],
                           arrays,
                           narrays,
                           level   1,
                           saved);
    }
  }
}

int findtarget(int target, struct sizedarray *arrays, size_t narrays) {
  int *saved = NULL;
  saved = malloc(narrays * sizeof *saved);
  /* assume it worked, needs something when it fails */
  if (saved) {
    findtarget_recursive(target, arrays, narrays, 0, saved);
    free(saved);
  }
  return 0;
}

int main(void) {
  int a0[] = {2, 1, 4, 7};
  int a1[] = {3, -3, -8, 0};
  int a2[] = {-1, -4, -7, 6};
  int a3[] = {1, 5, 6, 7};
  int a4[] = {-10, -4, -1, 3, 8};
  int a5[] = {17, 18, 19, 20, 21, 22, 23, 24, 25};
  struct sizedarray arrays[6];
  int target = 0;

  arrays[0].data = a0; arrays[0].nelems = sizeof a0/sizeof *a0;
  arrays[1].data = a1; arrays[1].nelems = sizeof a1/sizeof *a1;
  arrays[2].data = a2; arrays[2].nelems = sizeof a2/sizeof *a2;

  findtarget(target, arrays, 3);

  arrays[3].data = a3; arrays[3].nelems = sizeof a3/sizeof *a3;
  arrays[4].data = a4; arrays[4].nelems = sizeof a4/sizeof *a4;
  arrays[5].data = a5; arrays[5].nelems = sizeof a5/sizeof *a5;

  puts("nnwith 6 arrays ...");
  findtarget(target, arrays, 6);

  return 0;
}