# Wie kann ich herausfinden ob doppelte Zahlen in einem Array sind



## atots (8. Feb 2021)

Weiß zufällig jemand wie man doppelte Zahlen in einem array erkennt bzw auslesen lassen kann.
Danke für die Antwort im Vorraus.


----------



## Flown (8. Feb 2021)

Die Antwort auf deine Frage: Ja. 

Spaß beiseite, wie würdest du es auf dem Papier machen?


----------



## atots (8. Feb 2021)

Leider keine Ahnung hab gerade erst Angefangen zu programmieren und das ist eine unsere Hausaufgaben und ich hab keinen plan wie  das gehen soll


----------



## M.L. (8. Feb 2021)

Die Frage lässt aber auch Interpretationsspielraum: gilt z.B. die Folge 3333 als doppelt (da die 3 vierfach erscheint) ?   Müssen die Zahlen zwingend aufeinander folgen oder reicht irgendwo im Zielstring ?


----------



## mrBrown (8. Feb 2021)

atots hat gesagt.:


> Leider keine Ahnung hab gerade erst Angefangen zu programmieren und das ist eine unsere Hausaufgaben und ich hab keinen plan wie das gehen soll


Deshalb die Aufgabe ganz unabhängig vom Programmieren erstmal "von Hand" lösen 

Stell dir vor, ich gebe dir eine Blatt Papier, auf dem ein paar hundert Zahlen stehen, und du sollst alle raussuchen, die doppelt sind: wie machst du das?



M.L. hat gesagt.:


> Die Frage lässt aber auch Interpretationsspielraum: gilt z.B. die Folge 3333 als doppelt (da die 3 vierfach erscheint) ? Müssen die Zahlen zwingend aufeinander folgen oder reicht irgendwo im Zielstring ?


Man muss aber schon zwanghaft bemüht sein, die Aufgabe irgendwie möglichst kreativ auszulegen, um auf solche Ideen zu kommen


----------



## temi (8. Feb 2021)

M.L. hat gesagt.:


> Die Frage lässt aber auch Interpretationsspielraum


Das ist richtig, aber die spontan einfachste Interpretation von 


atots hat gesagt.:


> doppelte Zahlen in einem array


wäre ein Array von Integerwerten.


----------



## krgewb (8. Feb 2021)

```
List<String> meineListe = new ArrayList<String>();
        // Diese Liste muss nun irgendwie gefüllt werden. Ich habe das in diesem Beispiel weggelassen.

		if (meineListe.size() == 0) {
			System.out.println("Die Liste ist leer.");
			return;
		}

		// Ein Set enthält keine Duplikate.
		Set<String> meinSet = new HashSet<String>();

		for (int i = 0; i < meineListe.size(); i++) {
			meinSet.add(meineListe.get(i));
		}

		if (meineListe.size() == meinSet.size()) {
			System.out.println("Jedes kommt nur einmal vor.");
			return;
		} else {
			System.out.println("Es gibt Doppelte:\n");

			Hashtable<String, Integer> zuordnung_String_AnzahlWieOftErVorkommt = new Hashtable<String, Integer>();

			for (String s : meinSet) {

				int anzahlWieOftEsVorkommt = 0;

				for (int k = 0; k < meineListe.size(); k++) {
					if (s.equalsIgnoreCase(meineListe.get(k))) {
						anzahlWieOftEsVorkommt++;
					}
				}

				zuordnung_String_AnzahlWieOftErVorkommt.put(s, anzahlWieOftEsVorkommt);
			}

			for (Map.Entry<String, Integer> entry : zuordnung_String_AnzahlWieOftErVorkommt.entrySet()) {

				String key = entry.getKey();
				int value = entry.getValue();

				if (value > 1) {
					System.out.println(key + "; " + value);
				}
			}
```


----------



## kneitzel (8. Feb 2021)

Wobei ich so eine Lösung eher als zu komplex ansehen würde. Das ist ja relativ einfach zu prüfen:

Man nimmt einfach von Anfang an jedes Element und prüft dann alle folgenden Elemente, ob diese gleich sind. Sobald ein Treffer gefunden wurde, hat man das Ergebnis. Wenn man durchgelaufen ist ohne ein doppelten Wert zu finden, dann gibt es keine doppelten.

Und der Code scheint mir sehr viel zu nacheinander zu machen, das man doch vereinfachen könnte. Wenn also die jeweilige Anzahl wichtig ist, dann würde ich die Liste einmal durchgehen und in der Map prüfen, ob der Wert des Arrays als Key vorhanden ist. Ist es der Fall, dann wird die bisherige Anzahl aus der Map gelesen, erhöht und zurück geschrieben. Ist es nicht der Fall, dann fügt man den Key mit Zähler 1 ein,
Dabei könnte man sich dann auch merken, was man so braucht. Dadurch würde die Anzahl der Interationen über das Array reduziert.


----------



## krgewb (11. Feb 2021)

Er sagte, dass er sie auch auslesen lassen will.
---
Achso, bei Set ist die Abfrage sehr schnell.


----------



## kneitzel (11. Feb 2021)

krgewb hat gesagt.:


> Er sagte, dass er sie auch auslesen lassen will.
> ---
> Achso, bei Set ist die Abfrage sehr schnell.


Ist ja bei der HashMap auch nicht anders was die Speicherung / das finden der keys angeht. Du gehst nun einmal die Liste der Elemente mehrfach durch und damit hast Du ein schlechtes Laufzeitverhalten. 

So Du davon ausgehst, dass bei n immer k*n einzelne da sind und k ein konstanter Faktor ist, dann hast Du ein O(n^2) Laufzeitverhalten - alleine schon durch Deine verschachtelten Schleifen.
Da ist es toll, ein O(1) beim set zu haben. Hat die HashMap aber ebenso. (HashTable liegt beiden zu Grunde mit O(1): https://www.bigocheatsheet.com/)

Daher ist mein Laufzeitargument: O(n) statt O(n^2)


----------



## krgewb (11. Feb 2021)

https://server.kneitzel.de:1443/software/html5.html
Es erscheint eine Loginmaske.


----------



## kneitzel (11. Feb 2021)

krgewb hat gesagt.:


> https://server.kneitzel.de:1443/software/html5.html
> Es erscheint eine Loginmaske.


Das passiert, wenn man im Browser einen Remote Desktop hat, in dem dann ein Browser ist ... 





__





						Big-O Algorithm Complexity Cheat Sheet (Know Thy Complexities!) @ericdrowell
					





					www.bigocheatsheet.com
				




Edit: Ursprünglichen Post auch editiert ...


----------



## Jonas_E (3. Mrz 2021)

Das wäre eine Lösung:


```
public class DoppelteZahleninArray {

        public static void main(String[] args) {

        Random random = new Random();

        int[] array = new int[50];
        int[] even;
        int[] doubleNum;
        int count = 0;
        int doubles = 0;

        for (int i = 0; i < array.length; i++) {
            array[i] = random.nextInt(200);
            System.out.println(array[i] + " ");
        }
        for (int j = 0; j < array.length; j++) {
            even = new int[array.length];
            if (array[j] % 2 == 0) {
                even[count] = array[j];
                count++;
            }
            for (int k = 0; k < array.length; k++) {
                doubleNum = new int[array.length];
                if (array[j] / 2 == array[k]) {
                    even[doubles] = k;
                    doubles++;
                    System.out.println(even[doubles]);            
                }            
            }            
        }
        System.out.println(count);
        }
    }
```


----------



## Oneixee5 (4. Mrz 2021)

Jonas_E hat gesagt.:


> Das wäre eine Lösung:


Das sieht etwas wild aus. Hier noch mal etwas übersichtlicher:

```
final Random random = new Random();
        final int[] array = random.ints(30, 0, 30).toArray();
        System.out.println(String.format("Array mit Zufallswerten:\n%s\n", Arrays.toString(array)));

        Arrays.sort(array);
        int count = 1;
        int value = array[0];
        for (int i = 1; i < array.length; i++) {
            if (value == array[i]) {
                count++;
            } else {
                System.out.println(String.format(
                        "Der Wert \u001b[31m%1$2s\u001b[0m ist \u001b[34m%2$2s\u001b[0m mal vorhanden.",
                        value, count));
                count = 1;
            }
            value = array[i];
        }
```


```
Der Wert  6 ist  2 mal vorhanden.
Der Wert  7 ist  3 mal vorhanden.
Der Wert  8 ist  1 mal vorhanden.
Der Wert 11 ist  2 mal vorhanden.
Der Wert 12 ist  1 mal vorhanden.
Der Wert 13 ist  1 mal vorhanden.
Der Wert 14 ist  2 mal vorhanden.
Der Wert 15 ist  1 mal vorhanden.
Der Wert 16 ist  2 mal vorhanden.
Der Wert 18 ist  1 mal vorhanden.
Der Wert 20 ist  1 mal vorhanden.
Der Wert 21 ist  2 mal vorhanden.
Der Wert 23 ist  2 mal vorhanden.
Der Wert 24 ist  2 mal vorhanden.
Der Wert 25 ist  1 mal vorhanden.
Der Wert 26 ist  2 mal vorhanden.
Der Wert 27 ist  1 mal vorhanden.
Der Wert 28 ist  1 mal vorhanden.
```
Gearbeitet wird nach folgendem Prinzip: Das Array wird zuerst sortiert, dann wird einfach gezählt wie viele gleiche Elemente aufeinander folgen. Diese Anzahl wird dann zusammen mit dem Wert ausgegeben, wenn ein neuer Wert erkannt wurde.


----------

