在N 2维阵列

Question

搜索您好 我需要以下逻辑来实现上的n阵列（2维）。这里我已考虑的一维

#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 %d\n", a[i], b[j], c[k]); 
      } 
     } 
    } 

3个阵列}

输出： 2 -8 6 ; 1 3 -4 ; 1 0 -1 ; 4 3 -7 ; 4 -3 -1 ; 4 0 -4 ; 7 -3 -4 ; 7 0 -7 ;

Answer 1

有关语法信息，请参见C syntax in Wikipedia。

实际上，您需要使用int array [3] [4] = ...创建一个3行4列的数组。在后面的代码中，用每个案例的固定行索引替换对当前a，b和c数组的访问。

其余部分的实施留作练习，因为这听起来像是对我的功课。

Answer 2

不错的问题:-)
我不会发布我的完整解决方案，因为问题似乎是功课。就在几个三分球......

我用递归解决它：我使用的简化过程是发现target在n阵列的总和一样n-1阵列发现的target - ONE_ELEMENT的总和。

使用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("%d\n", 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("\n\nwith 6 arrays ..."); 
    findtarget(target, arrays, 6); 

    return 0; 
}