# Mehrfach auftretende Zahlen in einem Array



## Trueone (7. Jan 2012)

Hallo Leute

In einem vorgegebenen Array mit Zufallszahlen sollen Werte bestimmt werden, die mindestens zweimal vorkommen. Diese Anzahl an mehrfachen Zahlen sollen als ein Int - Wert zurückgegeben werden.

Hier ist mein Ansatz: 


```
public int mehrfach() {

  int anz = 0;            //Zähler, der mehrfach vorkommenden Zahlen zählt

        for (int i = 0; i < array.length; i++) {
            for (int j = i + 1; j < array.length; j++) {
                if (array[i] == array[j]) {
                    anz++; }
                    
                   
                }
            }
             return anz;
        }
```

Das Problem ist aber, dass es nur bei doppelten Zahlen funktioniert. Sind plötzlich drei gleiche Zahlen oder mehr enthalten, funktioniert es nicht!

Wäre dankbar für euere Hilfe!


----------



## HimBromBeere (7. Jan 2012)

Du musst wissen, welchen Datentyp die Elemente deines Feldes haben, denn nicht bei allen funktioniert der == Operator. Probier alternativ mal ein .equals (z.B. für Zeichenketten)...


Edit: Ups... beim zweiten Lesen hab ich erst gesehen, dass du ja ein int-Feld verwendest... in dem Fall...


----------



## Schandro (7. Jan 2012)

wie wärs hiermit?

```
List<Integer> multipleNumbers = new ArrayList<Integer>();
		for(int i=0;i<numbers.length;++i){
			if(!multipleNumbers.contains(numbers[i])){
				for(int e=i+1;e<numbers.length;++e){
					if(numbers[i]==numbers[e]){
						multipleNumbers.add(numbers[i]);
						break;
					}
				}
			}
		}
		System.out.println(multipleNumbers.size());
```


----------



## HimBromBeere (7. Jan 2012)

`ne Liste geht natürlich auch... hab´s nochmal als Feld probiert, versuch mal das:


```
int anz = 1;            //Zähler, der mehrfach vorkommenden Zahlen zählt
		int a[] = {1, 2, 4, 2, 2, 4, 1, 2};
        for (int i = 0; i < a.length; i++) {
            for (int j = i + 1; j < a.length; j++) {
                if (a[i] == a[j]) anz++;
            }
        	System.out.println(a[i] + ": " + anz);
        	anz = 0;
        	
        }
```

Du musst den Zähler ab und zu mal auf 0 setzen, denn sonst gibt die nur das Vorkommen aller Zahlen aus... aber du willst ja das Vorkommen je Zahl, oder? Also kannst du nicht mitten inder Schleife ein return setzen... kannst ja ein Feld zurückgeben, wo für jede Zahl die Häufigkeit drin steht

EDIT: Da jede Zahl ja min. ein mal vorkommt, musst du den Zähler am Anfang auch auf 1 setzen...  oder willst du nur die überzähligen Elemente wissen, dann kannste natürlich 0 lassen...


----------



## fibeline (7. Jan 2012)

Hi,
das Problem ist, dass bei 3 oder mehr gleichen Zahlen bei jedem Durchlauf die Anzahl für jede(!) bereits vorgekommene Zahl der Zähler erhöht wird. Hat Dein Array beispielsweise die Werte 
1,4,5,4,3,3,5,1
funktioniert es. Bei
1,4,5,4,3,3,5,1,1
findet Deine Schleife die 1 zwei Mal, und der Zähler wird erhöht. Jetzt wird das Array nochmal von vorne durchlaufen. Wieder findet er die 1 und erhöht den Zähler nochmal, obwohl es sich um dieselbe Zahl handelt. Hoffe, das ist einigermassen verständlich, besser kann ichs nicht erklären, ist spät 

Beispielsweise überprüfen, ob für eine Zahl der Zähler bereits erhöht wurde bzw. ob die Zahl bereits gefunden ist.  

Gruß,
Fibeline


----------



## Chumax (7. Jan 2012)

Würde das Array sortieren und dann liegen die Doppelten/Mehrfachen alle schön hintereinander.


----------



## Trueone (8. Jan 2012)

Ich habe das Array sortiert.

Z.B bei einem Array {1,1,1,2,2,3,4,4,4,4,4,5,6,6}

soll der Zähler den Wert 4 anzeigen.

4 Zahlen kommen mindestens doppelt darin vor.

Danke für die Tipps! Ich werde versuchen sie anzuwenden.


Arraylist ist leider keine Option, die Aufgabe soll ohne gelöst werden.


----------



## codechaos (8. Jan 2012)

Würde man bei Schandros Lösung ein Set und keine List verwenden, wäre das eine gültige Lösung des Problems, da man ein Element einem Set nicht mehrfach hinzufügen kann.
Ansonsten hier eine Lösung, die das Array vorher sortiert.


```
int[] numbers = new int[] {1,1,1,2,2,6,6,7,3,4,4,4,4,4,5,6,6};
		int multipleCount = 0;
	
		Arrays.sort(numbers);
		for(int i = 0; i < numbers.length-1; i++) {
			// Falls die Zahl ihrem Vorgänger entspricht, überspringe sie
			if(i > 0 && numbers[i] == numbers[i-1]) {
				continue;
			}
			// Ansonsten prüfe, ob ihr Nachfolger den gleichen Wert hat
			if(numbers[i] == numbers[i+1]) {
				multipleCount++;
			}
		}
		
		System.out.println(multipleCount);
```


----------



## Schandro (8. Jan 2012)

> Würde man bei Schandros Lösung ein Set und keine List verwenden, wäre das eine gültige Lösung des Problems, da man ein Element einem Set nicht mehrfach hinzufügen kann.


Und wie würdest du das mit einem Set machen? Einfach die Länge des Set's abfragen nach hinzufügen aller Elemente würde das falsche Ergebnis liefern :bae:


----------



## jag726 (8. Jan 2012)

Schandro hat gesagt.:


> Und wie würdest du das mit einem Set machen? Einfach die Länge des Set's abfragen nach hinzufügen aller Elemente würde das falsche Ergebnis liefern :bae:


Vielleicht einfach die Differenz aus der ursprünglichen Arraygröße und der Größe des Sets berechnen?

Aber da hätte man durch 5 Sekunden Nachdenken sicherlich auch selbst drauf kommen können ... :reflect:


----------



## bERt0r (8. Jan 2012)

> Vielleicht einfach die Differenz aus der ursprünglichen Arraygröße und der Größe des Sets berechnen?


Stimmt nicht:
{1,1,1,1}.length=4
4-1=3, rauskommen soll aber 1


----------



## codechaos (8. Jan 2012)

Da habe ich den Wald vor lauter Bäumen nicht gesehen und verdammten Schwachsinn geschrieben, tut mir leid! 

Hatte eher an so was gedacht:


```
Integer[] numbersArray = new Integer[] {1,1,1,2,2,6,6,7,3,4,4,4,4,4,5,6,6};
		
		Set<Integer> multibleNumbers = new HashSet<Integer>();		
		List<Integer> numbersList = Arrays.asList(numbersArray);
		
		for(Integer n : numbersList) {
			if(Collections.frequency(numbersList, n) > 1) {
				multibleNumbers.add(n);
			}
		}
		
		System.out.println(multibleNumbers.size());
```


----------



## Schandro (8. Jan 2012)

> Vielleicht einfach die Differenz aus der ursprünglichen Arraygröße und der Größe des Sets berechnen? Aber da hätte man durch 5 Sekunden Nachdenken sicherlich auch selbst drauf kommen können ...


Falsch. Denk das nächste mal lieber 5 Sekunden nach bevor du Schwachsinn postest.


----------



## ARadauer (9. Jan 2012)

Falls das ein Anfängerbeispiel ist, wird der Lehrer nicht froh sein wenn du Set und List verwendest.


----------

