Различные значения в массиве

Question

Я использую Java, я пытаюсь получить все разные значения из массива 2d только с рекурсивной функцией и без использования HashSet ArrayList и т. Д., Значения будут только [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); 

Если вы намеренно использовать рекурсию в этом случае единственное, что я могу рекомендовать это Test Driven Development. Напишите алгоритм и тесты одновременно.

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