Question

我正在尝试通过编程来解决难题。我有6个数组，每个数组有6个数字。我必须从每个数字中选择一个数字得出419的总和。我几乎是Java的初学者。我尝试使用if（）elseif（）例如：if (lock1[i]+lock2[i]+lock4[i]+lock4[i]+lock5[i]+lock6[i] == 419) 但是代码太长了。我查看了Java API for Array和ArrayList类，但我无法弄清楚应该使用哪种方法

这是数组

 class Locks {
        public static void main(String[] args) {
            int [] lock1 = {39,6,75,88,15,57};
            int [] lock2 = {9,2,58,68,48,64};
            int [] lock3 = {29,55,16,67,8,91};
            int [] lock4 = {40,54,66,22,32,25};        
            int [] lock5 = {49,1,17,41,14,30};
            int [] lock6 = {44,63,10,83,46,3};
            int total = 419;
          }
    }

Answer 1

它打印：3,3,5,0,0,3指的是 88,68,91,40,49,83。

要理解的关键是我们需要查看6 ^ 6种组合。因此，我们生成从0到6 ^ 6 -1的数字。

public class Locks{
    public static void main(String[] args) {
        int [][] locks = {
            {39,6,75,88,15,57},
            {9,2,58,68,48,64},
            {29,55,16,67,8,91},
            {40,54,66,22,32,25},        
            {49,1,17,41,14,30},
            {44,63,10,83,46,3}};
        int i, j;
        int total = 419;
        int dims = 6;               // number of dimensions in array
        int loops = 1; 
        for(i = 0; i < dims; ++i)   // maximum number of elements to test 
             loops *= dims;
        for(i=0; i < loops; ++i) {  // loop over all possibilities
            int cTotal = 0;         // Total for this selection of 6 columns
            int rTotal = 1;
            for(j = 0; j < dims; ++j) {       // generate six array indexes
                cTotal += locks[j][i / rTotal % dims];
                rTotal *= dims;
            }
            rTotal = 1;
            if(cTotal == total) {
                for(j = 0; j < dims; ++j) {
                    System.out.println(i / rTotal % dims);
                    rTotal *= dims;
                }
                return;
            }
        }
    }
}

Answer 2

public class Tset {

static int [] lock1 = {39,6,75,88,15,57};
static int [] lock2 = {9,2,58,68,48,64};
static int [] lock3 = {29,55,16,67,8,91};
static int [] lock4 = {40,54,66,22,32,25};
static int [] lock5 = {49,1,17,41,14,30};
static int [] lock6 = {44,63,10,83,46,3};
static int [] index =  new int[6];
static int total = 419;

public static void main(String[] args) {
    if(Tset.getIndex()!=null){

    }

}


    public static int[] getIndex(){
        int total1 =0;
        for(int i1 :lock1){
              for(int i2 :lock2){
                  for(int i3 :lock3){
                      for(int i4 :lock4){
                          for(int i5 :lock5){
                              for(int i6 :lock6){
                                       total1=lock1[i1]+lock2[i2]+lock4[i3]+lock4[i4]+lock5[i5]+lock6[i6];
                                    if (total1==total) {
                                             index[0] = i1;
                                             index[1] = i2;
                                             index[2] = i3;
                                             index[3] = i4;
                                             index[4] = i5;
                                             index[5] = i6;
                                        return index;
                                    }

                              }

                          }

                      }

                  }

              }
        }
        return null;
    }

}

Answer 3

此解决方案可以使用任何数组，并且可以找到产生所需总和的所有组合

public static void main(String[] args) throws Exception {
    int[] lock1 = { 39, 6, 75, 88, 15, 57 };
    int[] lock2 = { 9, 2, 58, 68, 48, 64 };
    int[] lock3 = { 29, 55, 16, 67, 8, 91 };
    int[] lock4 = { 40, 54, 66, 22, 32, 25 };
    int[] lock5 = { 49, 1, 17, 41, 14, 30 };
    int[] lock6 = { 44, 63, 10, 83, 46, 3 };
    int[][] locks = { lock1, lock2, lock3, lock4, lock5, lock6 };
    int[] a = new int[6];
    find(locks, 0, a, 419);
}

static void find(int[][] locks, int i, int[] a, int x) {
    if (i < locks.length) {
        for (int j = 0; j < locks[i].length; j++) {
            a[i] = j;
            int n = 0;
            for (int k = 0; k < a.length; k++) {
                n += locks[k][a[k]];
            }
            if (n == x) {
                System.out.println(Arrays.toString(a));
            }
            find(locks, i + 1, a, x);
        }
    }
}

Answer 4

在编写这样的循环时，请注意通过保存工作总计可以进行一些小的优化。当然是相同的渐近时间，但操作肯定更少。

   int sum = lock1[0]+lock2[0]+lock4[0]+lock4[0]+lock5[0]+lock6[0];
   for(int i1 :lock1){
       sum += lock1[i1];
            ...
               ...
                   for(int i6 :lock6){
                       sum += lock6[i6];
                       //test total=sum  
                       sum -= lock6[i6];
                   }
               ...
            ...
       sum -= lock1[i1];
   }

比较java中的6个int数组

4 个答案: