Wie kann ich herausfinden ob doppelte Zahlen in einem Array sind

atots

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

M.L.

Top Contributor
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

Super-Moderator
Mitarbeiter
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?

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

krgewb

Top Contributor
Java:
		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);
				}
			}
 
K

kneitzel

Gast
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.
 
K

kneitzel

Gast
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)
 
Zuletzt bearbeitet von einem Moderator:

Jonas_E

Mitglied
Das wäre eine Lösung:

Java:
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

Top Contributor
Das wäre eine Lösung:
Das sieht etwas wild aus. Hier noch mal etwas übersichtlicher:
Java:
        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];
        }
Bash:
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.
 

Neue Themen


Oben