在Java中比較6個int數組

我試圖通過編程來解決一個難題。我有int 6數組，每個數字都有6個數字。我必須從每一箇中選擇一個數字，以得出419的總和。我幾乎是Java的初學者。我嘗試使用if（）elseif（） ex：if (lock1[i]+lock2[i]+lock4[i]+lock4[i]+lock5[i]+lock6[i] == 419) 但它代碼太長。我擡頭看着數組和ArrayList類的Java API，但我想不出我應該用哪一種方法在Java中比較6個int數組

這裏是陣列

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; 
      } 
    }

來源

2013-09-22 Franko T

另一方法（未如此高效）是蠻力），並嘗試所有組合 –

將數組放在一個ArrayList中，使用增強for循環遍歷它並進行添加 – Ragavan

手中沒有太多高數... @Ragavan或for（int [] a：/* int [] [] */locks） – clwhisk

它打印： 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; 
      } 
     } 
    } 
}

來源

2013-09-22 04:31:36 dcaswell

不錯的一個！它找到了答案，工作得很好..作爲一個業餘愛好者，這對我來說有點複雜..我試圖解決難題以學習。 –

酷！想想這是一個有趣的問題！ – dcaswell

@ user814064您能否指出此解決方案的複雜性？ – Prateek

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; 
    }

}

來源

2013-09-22 04:15:13 Ragavan

這是一種做法。我只是好奇它是唯一的方法嗎？ – Prateek

我覺得唯一的辦法就是在上面的代碼中處理的bruteforce方法。你可以在這裏移動代碼，但代碼略有不同，但想法相同 – Ragavan

沒有理由不寫它，因爲它只有47000個案例。作爲一個普遍的問題，'k'數字不能超過1000，這可能很有趣。 – clwhisk

在編寫這樣一個循環時，請注意，通過保存工作總量可以實現一個小的優化。當然是漸近時間，但肯定更少的操作。

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]; 
    }

來源

2013-09-22 04:45:30 clwhisk

該溶液可以與任何組陣列的工作，並且可以找到超過全部組合用6環（或遞歸產生所需的總和

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); 
     } 
    } 
}

來源

2013-09-22 05:45:50

在Java中比較6個int數組

回答

相關問題