# Abfrage ob Wert im Array liegt



## Kirby.exe (23. Nov 2019)

Gibt es eine Funktion um einen Wert mit einem Array zu vergleichen und zuschauen ob dieser im Array liegt? Es gibt so etwas ja für Strings mit indexOf welcher bei keiner Übereinstimmung ja den Wert -1 liefert. Gibt es so eine ähnliche Funktion auch für Arrays?

Ich liefer mal folgendes Beispiel:


```
int array [] = {1,2,3,4};
int input = 2
```

Ich hatte da an eine If Else gedacht, welche bei einer Übereinstimmung, also wenn es im Array bereits vorkommt mit einer Counter Variable Counter und wenn der Wert noch nicht im Array liegt ihn hineinspeichert.


```
if(input in array){
counter += i;
}else{
füge input zum array hinzu
}
```


----------



## httpdigest (23. Nov 2019)

Arrays.binarySearch für den Fall eines aufsteigend sortierten Arrays.


----------



## Kirby.exe (23. Nov 2019)

Danke


----------



## Kirby.exe (23. Nov 2019)

Also ich glaube ich habe das einlesen der Zahlen für das Array etwas falsch gemacht hier mein Code: 


```
import java.util.Scanner;
import java.util.Arrays;

public class Statistik {

    public static void main(String[] args) {
        Scanner sc  = new Scanner(System.in);
        System.out.println("Enter the Size of your Array: ");
        int numbersLong = sc.nextInt();
        int numbers [] = new int[numbersLong];
        int counter = 0;
         for(int i = 0;  i < numbers.length; i++) {
            System.out.println("Enter your Number, which you like to add to the Array: ");
             int inputForArray = sc.nextInt();
            
            if(Arrays.binarySearch(numbers,inputForArray) == 0) {
                counter += 1;
            }else {
                numbers[i] = inputForArray;
             }
        }
        sc.close();
        System.out.println(numbers);
        //System.out.println(counter);
    }

}
```


----------



## abc66 (23. Nov 2019)

```
@SuppressWarnings("resource")
	public static void main(String[] args) {
		System.out.println("Enter the Size of your Array:");
		final int n = new Scanner(System.in).nextInt();
		int[] a = new int[n];
		int c = 0;
		for (int i = 0; i < n; i++) {
			System.out.println("Enter your Number, which you like to add to the Array:");
			int x = new Scanner(System.in).nextInt();
			if (Arrays.stream(a).filter(j -> j == x).findFirst().isPresent()) {
				System.out.println("Array already contains " + x + ".");
				c++;
				i--;
			} else {
				a[i] = x;
			}
		}
		System.out.println("The value of c is " + c + ".");
	}
```

Nur bei `0` musst aufpassen


----------



## Kirby.exe (23. Nov 2019)

Könntest du mir erklären was 





> (Arrays.stream(a).filter(j -> j == x).findFirst().isPresent())


 diese Zeile macht? ist es wie 





> (Arrays.binarySearch(numbers,inputForArray) == 0)


?


----------



## abc66 (23. Nov 2019)

Kirby_Sike hat gesagt.:


> ist es wie ?


Genau, aber das Array muss nicht sortiert sein.

Allerdings... sind Arrays ja anfangs immer mit 0en gefüllt.


----------



## Kirby.exe (23. Nov 2019)

Oh stimmt daran hatte ich nicht gedacht  mal noch eine Frage, wenn ich jetzt für jede Zahl die doppelt eingegeben wird speichern möchte wie oft sie doppelt ist, wie mache ich dass, da ja die Größe des Arrays und die Anzahl der Zahlen frei wählbar sind, dann müsste ich ja eine Menge Variablen vorher definen oder gibt es da einen simpleren Weg?


----------



## abc66 (23. Nov 2019)

Ja gibt es.... Aber ich würde einen objektorientierten Ansatz verfolgen dabei.


----------



## Kirby.exe (23. Nov 2019)

Also ich hatte die Idee die doppelten in ein separates Array zu speichern und dann die Zahlen welche doppelt im Array sind zu Zählen und auszugeben das Problem was ich nur habe ist erstmal die geforderte Formatierung und wie ich die 1 für die Zahlen ausgebe die nur 1 mal vorkommen. Ich schicke einfach ein Beispiel das mir gegeben wurde:


----------



## abc66 (23. Nov 2019)

Wo kommt diese 3 denn her:



3 wird doch nicht doppelt eingegeben?


----------



## Kirby.exe (23. Nov 2019)

Die 3 steht für die 1, also dass die 1 drei mal eingegeben wurde


----------



## abc66 (23. Nov 2019)

aa, jetzt kapiere ich das. 

Ok, versuch erst mal selber...


----------



## Kirby.exe (23. Nov 2019)

Also ich habe es so probiert, das Problem was ich versuche zu lösen ist , dass er die doppelte Zahl ja nicht mit zählt da sie nicht ins Array gespeichert werden, jedoch wenn ich es so mache dass sie ins Array gespeichert werden, möchte ich nicht dass diese Eingabe als Eingabe gezählt wird. Ich hoffe du verstehst was ich versuche zu sagen 


```
import java.util.Scanner;
import java.util.Arrays;

public class Statistik {

    @SuppressWarnings("resource")
    public static void main(String[] args) {
        System.out.println("Enter the Size of your Array:");
        final int n = new Scanner(System.in).nextInt();
        int[] numbers = new int[n];
        //int [] counter = new int[20];
        
        Arrays.sort(numbers);
        
        for (int i = 0; i < n; i++) {
            System.out.println("Enter your Number, which you like to add to the Array:");
            int inputToArray = new Scanner(System.in).nextInt();
            int c = 0;
            if (Arrays.stream(numbers).filter(j -> j == inputToArray).findFirst().isPresent()) {
                numbers[i] = inputToArray;
                //c += 1;
                i--;
            } else {
                numbers[i] = inputToArray;
                //c+= 1;
            }
        }
        System.out.println(Arrays.toString(numbers));
        int occurences = 1;
        
        for (int i = 0; i < numbers.length; i++) {
            if (i < numbers.length - 1) {
                if (numbers[i] == numbers[i + 1]) {
                    occurences++;
                }
            } else {
                System.out.println(numbers[i] + " occurs " + occurences
                        + " time(s)"); //end of array
            }

            if (i < numbers.length - 1 && numbers[i] != numbers[i + 1]) {
                System.out.println(numbers[i] + " occurs " + occurences
                        + " time(s)"); //moving to new element in array
                occurences = 1;
            }

        }
        //System.out.println("The value of c is " + c + ".");
        
        //System.out.println(Arrays.toString(numbers));
        //System.out.println(Arrays.toString(counter));
    }


}
```


----------



## dirk1970 (23. Nov 2019)

am einfachsten wäre es eine List<Integer> zu nehmen, die hat eine Methode contains...

wäre dann ungefähr so:
        System.out.println("Enter the Size of your Array:");
        final int n = new Scanner(System.in).nextInt();
        List<Integer>a=new ArrayList<>();
        int c = 0;
        int i=0;
        while (i<n) {
            System.out.println("Enter your Number, which you like to add to the Array:");
            Integer x = new Integer(new Scanner(System.in).nextInt());
            if (a.contains(x)) {
                System.out.println("Array already contains " + x + ".");
                c++;                
            } else {
                a.add(x);
                i++;
            }
        }
        System.out.println("The value of c is " + c + ".");


----------



## Kirby.exe (23. Nov 2019)

Ja das stimmt, jedoch löst das trotzdem nicht das eigentliche Problem nicht


----------



## dirk1970 (23. Nov 2019)

nicht?  dann habe ich das Problem nicht verstanden, 
ich dachte Du wolltest doppelte Eingaben finden


----------



## Kirby.exe (23. Nov 2019)

Naja das stimmt ja auch nur möchte ich gerne ausgeben wie oft die einzelnen Zahlen eingegeben wurden nicht nur wie oft generell eine Zahl doppelt eingegeben wurde


----------



## mihe7 (23. Nov 2019)

Ich gehe mal davon aus, dass Arrays verwendet werden müssen. Insofern würde ich empfehlen, das Problem auf zwei Arrays aufzuteilen:
a) ein Array mit bereits behandelten Zahlen (jede Zahl taucht nur einmal dort auf)
b) ein Array, das zu jeder behandelten Zahl die Anzahl enthält


----------



## dirk1970 (23. Nov 2019)

ach so, dann ist Array nicht unbedingt die beste Wahl,  ich würde an deiner Stelle eine Map verwenden key wäre von Typ Integer die eingegebene Zahl, Value auch Integer die Anzahl wie oft eingegeben

und der Code wäre im etwa so (bei Eingabe von -1 wird die Eingabe beendet, und derzeit mitgezählt, bei Bedarf kannst Du das ja wieder an Deine Bedürfnisse anpassen)

public static void main(String[] args) {        
        Map<Integer,Integer> eingaben=new HashMap<>();        
        Integer x=0;
        while (!x.equals(-1)) {
            System.out.println("Enter your Number, which you like to add to the Array:");
            x = new Integer(new Scanner(System.in).nextInt());
            Integer count = eingaben.get(x);
            if(count==null) {
                count=1;                
            }else {
                count++;
            }
            eingaben.put(x, count);            
        }
        for(Integer key:eingaben.keySet()) {
            System.out.println("Wert: "+key+" Anzahl: "+eingaben.get(key));
        }        
    }


----------



## dirk1970 (23. Nov 2019)

ups habe gerade gelesen, dass Arraya verwendet werden müssen

dann vergesst meinen Beitrag einfach


----------



## Kirby.exe (23. Nov 2019)

Wie wäre so etwas: 

```
import java.util.Scanner;
import java.util.Arrays;

public class Statistik {

    @SuppressWarnings("resource")
    public static void main(String[] args) {
        System.out.println("Enter the Size of your Array:");
        final int n = new Scanner(System.in).nextInt();
        int[] numbers = new int[n];
        int [] counter = new int[n];
        
        Arrays.sort(numbers);
        
        for (int i = 0; i < n; i++) {
            System.out.println("Enter your Number, which you like to add to the Array:");
            int inputToArray = new Scanner(System.in).nextInt();
            if (Arrays.stream(numbers).filter(j -> j == inputToArray).findFirst().isPresent()) {
                counter[i] = inputToArray;
                
                i--;
            } else {
                numbers[i] = inputToArray;
                counter[i] = 1; //für jede Zahl die nur 1 mal vorkommt eine 1 ins Counter Array
            }
        }
        System.out.println(Arrays.toString(numbers));
        System.out.println(Arrays.toString(counter));
        
        //System.out.println("The value of c is " + c + ".");
        
        //System.out.println(Arrays.toString(numbers));
        //System.out.println(Arrays.toString(counter));
    }


}
```


----------



## mihe7 (23. Nov 2019)

Es reicht nicht festzustellen, *ob* die Zahl in numbers vorkommt, sondern *wo*, denn an dieser Stelle findet sich im Array counter der dazugehörige Zähler.


----------



## Kirby.exe (23. Nov 2019)

Ich glaube ich kann noch nicht ganz nachvollziehen, wie ich dass umsetzen könnte. Soll ich mit dem Index von numbers array arbeiten?


----------



## mihe7 (23. Nov 2019)

Ja. Beispiel: 

```
numbers[] = {}
counter[] = {}
uniqueNumbers = 0

Eingabe: 3 -> nicht in numbers enthalten -> {
    numbers[uniqueNumbers] = 3; 
    counter[uniqueNumbers] = 1;
    uniqueNumbers++;
}
Eingabe: 1 -> nicht in numbers enthalten -> {
    numbers[uniqueNumbers] = 1; 
    counter[uniqueNumbers] = 1;
    uniqueNumbers++;
}
Eingabe: 3 -> an Position pos=0 in numbers enthalten -> counter[pos]++
Eingabe: 3 -> an Position pos=0 in numbers enthalten -> counter[pos]++
Eingabe: 1 -> an Position pos=1 in numbers enthalten -> counter[pos]++
```


----------



## Kirby.exe (23. Nov 2019)

Soweit hab ich es jetzt verstanden, nur was wenn die Zahl zwei mal eingegeben wird, dann müsste der Wert an der Stelle ja ersetzt werden


----------



## Kirby.exe (23. Nov 2019)

Also das mit dem Ersetzen ist noch etwas provisorisch, überlege gerade wie ich das mit einer Variable Regel:


```
import java.util.Scanner;
import java.util.Arrays;

public class Statistik {

    @SuppressWarnings("resource")
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("Enter the Size of your Array:");
        final int n = sc.nextInt();
        int[] numbers = new int[n];
        int [] counter = new int[n];
        
        //Arrays.sort(numbers);
        int t = 0;
        for (int i = 0; i < n; i++) {
            System.out.println("Enter your Number, which you like to add to the Array:");
            int inputToArray = sc.nextInt();
            if (Arrays.stream(numbers).filter(j -> j == inputToArray).findFirst().isPresent()) {
                int find = findIndex(numbers, inputToArray);
                counter[find] = 2;
                
                //i--;
            } else {
                numbers[t] = inputToArray;
                counter[t] = 1; //für jede Zahl die nur 1 mal vorkommt eine 1 ins Counter Array
                t++;
            }
        }
        System.out.println(Arrays.toString(numbers));
        System.out.println(Arrays.toString(counter));
        
        //System.out.println("The value of c is " + c + ".");
        
        //System.out.println(Arrays.toString(numbers));
        //System.out.println(Arrays.toString(counter));
    }
    
    // Function to find the index of an element
    public static int findIndex(int arr[], int t)
    {
 
        int index = Arrays.binarySearch(arr, t);
        return (index < 0) ? -1 : index;
    }


}
```


----------



## mihe7 (23. Nov 2019)

1. Such den Index in findIndex selbst raus, denn numbers ist nicht sortiert. 
2. Dein if kannst Du ersetzen, wenn nämlich find < 0 gilt, dann wurde die Zahl noch nicht behandelt.


----------



## Kirby.exe (23. Nov 2019)

Meintest du es so?


```
import java.util.Scanner;
import java.util.Arrays;

public class Statistik {

    @SuppressWarnings("resource")
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("Enter the Size of your Array:");
        final int n = sc.nextInt();
        int[] numbers = new int[n];
        int [] counter = new int[n];
        

        int t = 0;
        for (int i = 0; i < n; i++) {
            System.out.println("Enter your Number, which you like to add to the Array:");
            int inputToArray = sc.nextInt();
            if (findIndex(numbers, inputToArray) > 0) {
                int find = findIndex(numbers, inputToArray);
                counter[find] = 2;
                
                //i--;
            } else {
                numbers[t] = inputToArray;
                counter[t] = 1; //für jede Zahl die nur 1 mal vorkommt eine 1 ins Counter Array
                t++;
            }
            Arrays.sort(numbers);

        }
        System.out.println(Arrays.toString(numbers));
        System.out.println(Arrays.toString(counter));
    }
    
    // Function to find the index of an element
    public static int findIndex(int arr[], int t)
    {
 
        int index = Arrays.binarySearch(arr, t);
        return (index < 0) ? -1 : index;
    }


}
```


----------



## mihe7 (23. Nov 2019)

Nicht ganz:

```
int t = 0;
        for (int i = 0; i < n; i++) {
            System.out.println("Enter your Number, which you like to add to the Array:");
            int inputToArray = sc.nextInt();
            int find = findIndex(numbers, inputToArray);
            if (find >= 0) {
```


----------



## Kirby.exe (23. Nov 2019)

Bei mir wird als letzter Parameter immer eine 0 ausgegeben also beim Array, da ja numbers[2] bei einer Array länge von 3 und bei einer doppelten Eingabe 0 sein muss. Kann ich das durch eine simple if Else abfangen?


----------



## mihe7 (23. Nov 2019)

Da `t` die Anzahl der Zahlen enthält:

```
numbers = Arrays.copyOf(numbers, t);
counter = Arrays.copyOf(counter, t);
```
vor der Ausgabe einfügen.


----------



## mihe7 (23. Nov 2019)

Nochmal der Hinweis: schreib Deine findIndex-Methode selber und verzichte auf das Sortieren von numbers (das Problem ist, dass die Reihenfolge von numbers sich ggf. ändert, während die Reihenfolge von counter gleich bleibt).


----------



## Kirby.exe (23. Nov 2019)

Oke ich überlege mir was  geht das mit dem ändern der Anzahl so oder ist das falsch? 

```
if (find >= 0) {
                int c = counter[find];
                counter[find] = c+1;
            }
```


----------



## mihe7 (23. Nov 2019)

Das ist nicht falsch aber etwas ungeschickt. Die Variable bräuchtest Du schon mal gar nicht:

```
counter[find] = counter[find] + 1;
```

Kürzer:

```
counter[find]++;
```


----------



## Kirby.exe (23. Nov 2019)

Ohh wusste nicht, dass das geht


----------



## Kirby.exe (24. Nov 2019)

Also ich muss ehrlich sagen ich wüsste nicht wie man den Index abruft  ich denke mal so einfach wie getIndex() bei ArrayList gibt es nicht


----------



## Kirby.exe (24. Nov 2019)

Also ich muss ehrlich sagen ich wüsste nicht wie man den Index abruft  ich denke mal so einfach wie getIndex() bei ArrayList gibt es nicht


----------



## mihe7 (24. Nov 2019)

Kirby_Sike hat gesagt.:


> Also ich muss ehrlich sagen ich wüsste nicht wie man den Index abruft



Funktioniert wie Deine for-Schleife im Code:

```
public static int findIndex(int arr[], int t) [
    for (int i = 0; i < arr.length; i++) {
        if (arr[i] == t) { // ist das (i+1)-te Element aus arr gleich t?
            return i;      // dann gib den Index i zurück
        }
    }
    return -1; // t nicht gefunden -> -1 zurück.
}
```


----------



## Kirby.exe (24. Nov 2019)

Mir ist gerade aufgefallen dass er bei einem Test den letzten Wert nicht einließt:

Arraylänge ist 5:
Werte sind: 11,11,12,13,12,11

Woran könnte das liegen?


----------



## mihe7 (24. Nov 2019)

Dass es 6 und nicht 5 Werte sind?


----------



## Kirby.exe (24. Nov 2019)

ja aber die doppelten werte sollen von der Zählung ignoriert werden, also wenn die Array länge 3 ist und es 6 Werte gibt dann sind die alle 3 werte doppelt


----------



## mihe7 (24. Nov 2019)

Zeig mal Deinen Code. Dann schreib mal, was Du eingibst und was Du als Ausgabe erwartest.


----------



## Kirby.exe (24. Nov 2019)

Also ich schicke einfach mal alle 3 Tests rein.

Test 1:



Test 2:



Test 3:


----------



## mihe7 (24. Nov 2019)

Wenn ich es richtig sehe, dann bekommst Du zwei Argumente übergeben, liest aber nur eines ein.


----------



## Kirby.exe (24. Nov 2019)

Das wäre das nächste Problem, in der Aufgabenstellung steht, dass die eingaben per Kommandozeilenparameter eingelesen werden, jedoch sind nicht gegeben welche, ist jedoch erstmal nicht so relevant, da es ja einfach eine andere quelle des Input ist oder?


----------



## mihe7 (24. Nov 2019)

Die Kommandozeilenparameter erhälst Du in Form eines String-Arrays als Parameter der main-Methode.

Und relevant ist das natürlich schon: wenn ich es richtig sehe, ist der erste Parameter die Feldgröße und der zweite Paramter der Anzahl der Eingaben. Da hilft es Dir wenig, wenn Du in Deinem Programm sagst: mir doch egal, ich lass mir die Anzahl der Eingaben vom Benutzer mitteilen.


----------



## Kirby.exe (25. Nov 2019)

ich glaube du hast mich etwas falsch verstanden  ich meinte zum jetzigen Zeitpunkt ist es doch erstmal egal ob in Eclipse die Werte per Tastatur oder per Kommandozeilenparameter eingelesen werden, ich werde dies dann ändern wenn alles geht  woran könnte es denn liegen dass das Programm eine Eingabe zu wenig einließt?


----------



## mihe7 (25. Nov 2019)

Kirby_Sike hat gesagt.:


> ich glaube du hast mich etwas falsch verstanden


Das ist durchaus möglich  



Kirby_Sike hat gesagt.:


> ich meinte zum jetzigen Zeitpunkt ist es doch erstmal egal ob in Eclipse die Werte per Tastatur oder per Kommandozeilenparameter eingelesen werden


So lange Du den Code nicht Tests unterziehst, die etwas anderes erwarten.



Kirby_Sike hat gesagt.:


> woran könnte es denn liegen dass das Programm eine Eingabe zu wenig einließt?



Ich wiederhole mich:



mihe7 hat gesagt.:


> Zeig mal Deinen Code. Dann schreib mal, was Du eingibst und was Du als Ausgabe erwartest.


----------



## Kirby.exe (25. Nov 2019)

Oh sorry war heute morgen noch nicht ganz wach, ich dachte ich hatte ihn direkt mitgeschickt 


```
import java.util.Scanner;
import java.util.Arrays;

public class Statistik {

    @SuppressWarnings("resource")
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("Enter the Size of your Array:");
        final int n = sc.nextInt();
        int[] numbers = new int[n];
        int [] counter = new int[n];
        
        //Arrays.sort(numbers);
        int t = 0;
        for (int i = 0; i < n; i++) {
            System.out.println("Enter your Number, which you like to add to the Array:");
            int inputToArray = sc.nextInt();
            int find = findIndex(numbers, inputToArray);
            
            if (find >= 0) {
                counter[find]++;
                i--;
            } else {
                numbers[t] = inputToArray;
                counter[t] = 1; //für jede Zahl die nur 1 mal vorkommt eine 1 ins Counter Array
                t++;
            }
        }
        numbers = Arrays.copyOf(numbers, t);
        counter = Arrays.copyOf(counter, t);
        System.out.println(Arrays.toString(numbers));
        System.out.println(Arrays.toString(counter));
    }
    
    // Function to find the index of an element
    public static int findIndex(int arr[], int t)
    {
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == t) { // ist das (i+1)-te Element aus arr gleich t?
                return i;      // dann gib den Index i zurück
            }
        }
        return -1; // t nicht gefunden -> -1 zurück.
    }


}
```


----------



## mihe7 (25. Nov 2019)

Und nochmal:


mihe7 hat gesagt.:


> Dann schreib mal, was Du eingibst und was Du als Ausgabe erwartest.


----------



## Kirby.exe (25. Nov 2019)

Also es gibt 3 Tests:


Test 1:
  Eingabe: 11,11,12,13,12,11
  Array-Größe: 5
  Ausgabe: 11 kommt 3 mal vor, 12 kommt 2 mal vor und 13 kommt einmal vor

Test 2: 
  Eingabe: 1,3,1,2,1
  Array-Größe: 3
  Ausgabe: 1 kommt 3 mal vor, 3 kommt 1 mal vor und 2 kommt 1 mal vor

Test 3:
  Eingabe: 13, 13, 11, 43, 2, 13, -2, -2, -2, 53, 11, 29, 7, 13, 19, 29, 0, 13
  Array-Größe: 21
  Ausgabe: 13(5 mal), 11(2 mal), 43(1mal), 2(1mal), -2(3mal), 53(1mal), 29(2mal), 7(1mal), 19(1mal),0(1mal)


----------



## mihe7 (25. Nov 2019)

Du gibst also beim ersten Test auf die Frage: "Enter the Size of your Array:" die Zahl 5 ein. Danach liest Du eben 5 Werte ein. Wo soll denn der sechste herkommen? In den Tests, die Du in #44 gepostet hast, gibt es einen zweiten Parameter: 6; der taucht bei Dir im Code nirgends auf.


----------



## Kirby.exe (25. Nov 2019)

6 steht für die Anzahl der Werte welche eingelesen werden


----------



## mihe7 (25. Nov 2019)

Kirby_Sike hat gesagt.:


> 6 steht für die Anzahl der Werte welche eingelesen werden


Nochmal: in Deinem Code kommt diese Variable nirgends vor. Du fragst nach der Größe des Arrays und liest genau so viele Werte ein. Du brauchst noch eine Abfrage, wie viele Werte eingelesen werden sollen und musst die for-Schleife dann entsprechend anpassen (also bis zu dem dort eingegebenen Wert laufen).


----------



## Kirby.exe (25. Nov 2019)

Ach so meintest du dass  hab dich etwas missverstanden


----------



## Kirby.exe (25. Nov 2019)

So ok?: 
Wenn amount die Anzahl der Werte ist? 



```
for (int i = 0; i < amount; i++) {
```


----------



## mihe7 (25. Nov 2019)

Probiers aus


----------



## Kirby.exe (25. Nov 2019)

Jo funktioniert  jetzt muss ich nur noch das Problem mit den Kommandozeilenparametern lösen


----------



## mihe7 (25. Nov 2019)

Die bekommst Du in main im Array args geliefert.


----------



## Kirby.exe (25. Nov 2019)

Naja ich muss ehrlich zugeben, dass ich mit Kommandozeilenparametern nicht so viel Erfahrung habe, aber in vorherigen Aufgaben hatten wir die meistens gegeben, so etwas wie args[0] und args[1]


----------



## Kirby.exe (25. Nov 2019)

Ok ich hab einfach mal args[0] und args[1] ausprobiert und eigentlich kommt auch das richtige raus, nur erwartet der Test irgendwie ein (,) ?


----------



## mihe7 (25. Nov 2019)

Nein, der Test erwartet kein Komma, sondern keine eckigen Klammern. Du hast aktuell Arrays.toString() verwendet und das sollst Du offensichtlich nicht tun


----------



## Kirby.exe (25. Nov 2019)

Welche anderen Methoden gibt es?


----------



## mihe7 (25. Nov 2019)

Zum Beispiel eigene


----------



## Kirby.exe (25. Nov 2019)

Ok habe die Print Method mit einer For Schleife gemacht anstatt mit Array.toString  Wie könnte ich es abfangen, dass eine 0 als eingäbe nicht gelöscht wird von 





> numbers = Arrays.copyOf(numbers, t);


 ich überlege schon die ganze Zeit ob man das anders machen kann, weil irgendwie müssen ja die Leerstellen im Array gelöst werden, aber die Methode kann ja nicht einfach so zwischen einer Leerstelle im Array und der eingabe 0 unterscheiden


----------



## mihe7 (25. Nov 2019)

Von welchen Leerstellen sprichst Du?


----------



## Kirby.exe (25. Nov 2019)

Naja also ohne die Funktion sähe das Array ja so aus 3,1,2,0,0,0,0,0 und die Funktion copyOf schneidet die 0 weg, jedoch gibt es beim 3. Test eine 0 als eingäbe


----------



## mihe7 (25. Nov 2019)

Die Funktion copyOf schneidet nichts weg, sondern liefert ein Array der Länge t als Kopie der ersten t Elemente des gegebenen Arrays. Ob in der Eingabe eine 0 vorkommt, oder nicht, spielt doch im Programm gar keine Rolle.


----------



## Kirby.exe (25. Nov 2019)

Ja gut dann hab ich die Methode etwas falsch verstanden  welche anderen Gründe könnte dass haben, dass die 0 wegfällt?


----------



## mihe7 (25. Nov 2019)

Gründe... also im Code von vorhin kann ich auf die Schnelle keinen Fehler sehen. Vielleicht ist Deine Ausgabefunktion falsch?


----------



## Kirby.exe (25. Nov 2019)

```
for(int i=0; i < numbers.length-1; i++) {
            System.out.print(numbers[i] + ", ");
        }
        System.out.print(numbers[numbers.length-1] + "\n");
        
        for(int i=0; i < counter.length-1; i++) {
            System.out.print(counter[i] + ", ");
        }
        System.out.print(counter[counter.length-1]);
```


----------



## mihe7 (25. Nov 2019)

Das ist zwar etwas kompliziert geschrieben, dürfte aber passen. Wie kommst Du darauf, dass die 0 weggelassen wird?


----------



## mihe7 (25. Nov 2019)

Ach so, jetzt sehe ich das erst: in dem Test geht es darum, dass mehr Elemente in der Ausgabe gefordert werden, als eigentlich notwendig sind  

Du musst also nicht Arrays.copyOf(numbers, t) sondern Arrays.copyOf(numbers, anzahlGeforderterElemente) verwenden, analog für counter.


----------



## Kirby.exe (25. Nov 2019)

Naja also aus irgendeinem Grund wir die 0 bei der Ausgabe nicht ausgegeben


----------



## mihe7 (25. Nov 2019)

OK, Problem erkannt. findIndex durchsucht das komplette Array und findet daher die 0, obwohl die noch gar nicht erfasst wurde.


```
import java.util.Scanner;
import java.util.Arrays;

public class Statistik {

    @SuppressWarnings("resource")
    public static void main(String[] args) {
        int n = Integer.parseInt(args[0]);
        int m = Integer.parseInt(args[1]);

        int[] numbers = new int[n];
        int [] counter = new int[n];

        Scanner sc = new Scanner(System.in);        
        //Arrays.sort(numbers);
        int t = 0;
        for (int i = 0; i < m; i++) {
            int inputToArray = sc.nextInt();
            int find = findIndex(numbers, inputToArray, t);

            if (find >= 0) {
                counter[find]++;
            } else {
                numbers[t] = inputToArray;
                counter[t] = 1; //für jede Zahl die nur 1 mal vorkommt eine 1 ins Counter Array
                t++;
            }
        }
        numbers = Arrays.copyOf(numbers, t);
        counter = Arrays.copyOf(counter, t);
        System.out.println(Arrays.toString(numbers));
        System.out.println(Arrays.toString(counter));
    }
    
    // Function to find the index of an element
    public static int findIndex(int arr[], int t, int n)
    {
        for (int i = 0; i < n; i++) {
            if (arr[i] == t) { // ist das (i+1)-te Element aus arr gleich t?
                return i;      // dann gib den Index i zurück
            }
        }
        return -1; // t nicht gefunden -> -1 zurück.
    }


}
```


----------



## Kirby.exe (25. Nov 2019)

Funktioniert alles Danke  Könntest du mir trotzdem nochmal erklären warum es an der 0 gescheitert ist, nur damit ich mir den Fehler einpräge  Nevermind habe verstanden warum


----------



## mihe7 (25. Nov 2019)

Klar: Wenn Du ein neues Array initialisierst, sind die Werte erstmal alle 0. 

Jetzt gibst Du erstmals eine 0 ein und suchst in dem Array danach. Nachdem die Werte alle 0 sind, wirst Du auch fündig, obwohl die 0 noch nie verarbeitet wurde.

Abhilfe schafft man dadurch, dass man der Suchmethode mitgibt, wie viele Elemente man tatsächlich schon in das Array gesteckt hat. Das ist der neue, dritte Parameter von findIndex.


----------



## Kirby.exe (25. Nov 2019)

Job hatte es auch gecheckt kurz bevor du geantwortet hast  Dankeschön


----------

