rekursive Methode, um zu zählen, wie viele verschiedene Zahlen im Array? [java]

Question

Ich muss eine rekursive Funktion schreiben, um zu zählen, wie viele verschiedene Werte im Array sind, und die einzigen Werte, die darin erscheinen können, sind 0-9.

Zum Beispiel für das folgende Array:

{ { 1, 5, 4, 3 }, 
    { 4, 3, 2, 1 },  
    { 4, 5, 1, 4 }, 
    { 1, 4, 3, 2 } 
}; 

Die Funktion wird 5 zurück, weil die einzigen in diesem Array auftretenden Werte sind: 1,2,3,4,5

Das ist, was ich versucht habe, so weit ich weiß nicht verstehen, wie der Index zu fördern, ohne for

public static int numOfColors(int[][] map) { 
    int i=0; 
    int j=0; 
    int colors=0; 
    int contains=map[i][j]; 
    if (map == null) { 
     return 0; 
    } else if (map[i][j] != 0&&map[i][j]!=contains) { 
     colors ++; 
    } 
    return numOfColors(map) + 1; 
} 

Answer 1

Verwendung Wenn Sie einen Array haben wie: int Zahlen [] [] Können Sie so etwas wie

public int getNUnique(int[][] numbers) { 
    int usedNumbers[10]; 
    boolean found=false; 
    for(int i=0, i<numbers.lenght, i++) { 
     for(int j=0, i<numbers[].lenght, j++) { 
       for(int x=0, x<usedNumbers.lenght, X++) { 
        if(numbers[i][j]==usedNumbers[x]) { 
         found=true; 
        } 
        if(!found) { 
         usedNumbers[usedNumbers.lenght]=numbers[i][j]; 
        } 
       } 
     } 
     return usedNumbers.length 
    } 

Answer 2

Sie benötigen einen anderen Parameter für den rekursiven Aufruf tun: dass ein Satz von ganzen Zahlen, die Sie bereits gesehen haben. Oder Sie könnten ein BitSet oder gar eine Zeichenfolge verwenden, da Sie auf einzelne Ziffern beschränkt sind.

Zum Weiterleiten des Index können Sie entweder zwei Parameter übergeben, die Zeile und Spalte darstellen, oder Sie können eine div (/) und mod (%) Strategie verwenden, um Zeilen und Spalten aus einem einzigen Indexparameter zu berechnen.

Schließlich könnten Sie ganz von der Notwendigkeit Index loszuwerden, indem man einfach in einem Iterator anstelle eines Arrays vorbei (obwohl die Idee einen Iterator in einen rekursiven Aufruf von vorbei scheint ungerade):

public static int numColors(PrimitiveIterator.OfInt iter, BitSet seen) { 
    if(!iter.hasNext()) 
     return seen.cardinality(); 
    seen.set(iter.nextInt()); 
    return numColors(iter, seen); 
} 
public static void main(String[] args) { 
    int[][] arr = { 
     { 1, 5, 4, 3 }, 
     { 4, 3, 2, 1 },  
     { 4, 5, 1, 4 }, 
     { 1, 4, 3, 2 }}; 
    PrimitiveIterator.OfInt iter = Arrays.stream(arr).flatMapToInt(Arrays::stream).iterator(); 
    System.out.println(numColors(iter, new BitSet())); 
} 

Und wie gewünscht, hier ist eine „dumme“ -Ansatz:

public class SampleJava { 
private static final int MAX_COLORS = 10; 
public static int numColors(int[][] arr, int row, int column, int[] seen) { 
    if(row == arr.length) // end of rows 
     return 0; // done 
    if(column == arr[row].length) // end of column 
     return numColors(arr, row + 1, 0, seen); // advance to next row 
    seen[arr[row][column]]++; // increment the "seen" count for this color 
    if(seen[arr[row][column]] == 1) // are we seeing a new color? 
     return 1 + numColors(arr, row, column + 1, seen); // yes. next column 
    return 0 + numColors(arr, row, column + 1, seen); // no. next column 
} 
public static void main(String[] args) { 
    int[][] arr = { 
     { 1, 5, 4, 3 }, 
     { 4, 3, 2, 1 },  
     { 4, 5, 1, 4 }, 
     { 1, 4, 3, 2 }}; 
    System.out.println(numColors(arr, 0, 0, new int[MAX_COLORS])); 
} 
} 

Answer 3

wie andere Leute vorgeschlagen, benötigen Sie einen außerhalb des Bereichs Element, deren Lebenszyklus unabhängig von der rekursiven Funktion, die Sie verwenden, halten die Farben (Zahlen), die Sie besucht haben.