配列の値が異なる

Question

私はJavaを使用していますが、再帰関数のみを使用し、HashSet ArrayListなどを使用しないで2d配列からすべての異なる値を取得しようとしています。 値は[0-9] すなわち：

私が試した何

{{4,2,2,1,4},{4,4,3,1,4},{1,1,4,2,1},{1,4,0,2,2},{4,1,4,1,1}}; -> Returns 5 (Because 4,2,3,1,0) 
{{4,6,2,1,4},{4,4,3,1,4},{1,1,4,2,1},{1,4,0,2,2},{4,1,4,1,1}}; -> Returns 6 (Because 4,2,3,1,0,6) 
{{4,4,4,4,4}}; -> Returns 1 (4) 

：

public static int numOfColors(int[][] map) { 
    int colors = 0; 
    if (map == null || map.length == 0) { 
     return colors; 
    } else { 
     int[] subArr = map[map.length - 1]; 

     for (int i = 0; i < subArr.length; i++) { 
      int j = i + 1; 
      for (; j < subArr.length; j++) { 
       if (subArr[i] == subArr[j]) { 
        break; 
       } 
      } 
      if (j == subArr.length) { 
       int k = 0; 
       for (; k < map.length - 1; k++) { 
        for (int l = 0; l < map[k].length; l++) { 
         if (subArr[i] == map[k][l]) { 
          continue; 
         } 
        } 
       } 
       if (k == map.length - 1) { 
        colors++; 
       } 
      } 
     } 
     int[][] dest = new int[map.length - 1][]; 
     System.arraycopy(map, 0, dest, 0, map.length - 1); 
     colors += numOfColors(dest); 

     return colors; 
    } 
} 

しかしmiskateである場合、これは、私のために働いていませんか？

Answer 1

すでに@Cash Loに言及されているように、何らかのストレージが必要です。アルゴリズムは次のようになります：

@Test 
public void numOfColorsTest() { 
    int[][] map = new int[][] {{4,2,2,1,4},{4,4,3,1,4},{1,1,4,2,1},{1,4,0,2,2},{4,1,4,1,1}}; 
    System.out.println(String.format("numOfColors: %s", numOfColors(map, new int[0], map.length-1))); 

    map = new int[][] {{4,6,2,1,4},{4,4,3,1,4},{1,1,4,2,1},{1,4,0,2,2},{4,1,4,1,1}}; 
    System.out.println(String.format("numOfColors: %s", numOfColors(map, new int[0], map.length-1))); 

    map = new int[][] {{4,4,4,4,4}}; 
    System.out.println(String.format("numOfColors: %s", numOfColors(map, new int[0], map.length-1))); 
} 

public static int numOfColors(int[][] map, int[] collector, int currentPosition) { 
    int[] result = collector; 
    if (currentPosition < 0) { 
     return collector.length; 
    } 
    for (int color : map[currentPosition]) { 
     boolean found = false; 
     for (int aResult : result) { 
      if (aResult == color) { 
       found = true; 
       break; 
      } 
     } 
     if (!found) { 
      int[] newResult = new int[result.length + 1]; 
      System.arraycopy(result, 0, newResult, 0, result.length); 
      newResult[newResult.length - 1] = color; 
      result = newResult; 
     } 
    } 
    return numOfColors(map, result, currentPosition-1); 
} 

Answer 2

私はこれが答えではないことを知っていますが、あなたの解が理にかなっていると常に考えるべきです。コードは、私はそれをチェックしていないが、私はそれが

再帰がより効率的だ疑いすべて

で読めない

• ：ので、ここでは再帰を使用して、私の意見では

  は非常に悪い考えですあなたは本当に簡単な問題を作っている

• をデバッグするのは難しいが、次のコードを考えてみましょう

を複雑。

Integer[][] array = {{4,2,2,1,4},{4,4,3,1,4},{1,1,4,2,1},{1,4,0,2,2},{4,1,4,1,1}}; 
int size = Arrays.stream(array) 
     .flatMap(Arrays::stream) 
     .collect(Collectors.toSet()) 
     .size(); 
System.out.println("size = " + size); 

このケースで意図的に再帰を使用する場合は、テスト駆動型開発のみをおすすめします。アルゴリズムとテストを同時に書く。

Answer 3

再帰はあまり意味がありません。単純な配列をストレージとして使用し、範囲（0-9）が分かり、単純なint []で十分なら、異なる値のインスタンスを数えます。再帰を使用する理由

public static int numOfColors(int[][] map){ 

    int[] storage = new int[10]; 

    //iterate through all the values 
    for(int i = 0; i<map.length; i++){ 
     for(int j = 0; j<map[0].length; j++){ 

      //will throw an Exception if an entry in map is not 0-9 
      //you might want to check for that 
      storage[map[i][j]]++; 

     } 
    } 

    int colors = 0; 
    //now check which values exist. 
    for(int i = 0; i<storage.length; i++){ 
     if(storage[i] != 0) colors++; 
    } 

    return colors; 
}