Anzahl gleicher Elemente in Array

Kabauter

Mitglied
Hallo,
wie kann ich in einem sortierten Array die Anzahl gleicher Elemente möglichst schnell (Binäre Suche) herausfinden? In dem Beispiel also die Anzahl von 5 in einem int-array.
Normalerweise (ohne binäre Suche) sieht der Code so aus:

Java:
for (int i = 0; i < array.length; i++) {
    if (array[i]==5) {   
        anzahl++;
    }
}
 

Kabauter

Mitglied
Das hatte ich mir auch so gedacht, nur fällt mir dazu kein passender Code ein :D
Hatte den Array in zwei Teile geteilt und so jeden Teil durchsucht, allerdings komme ich dann mit dem finden des ersten Elements nicht mehr klar.
tmp soll hier den kleinsten Index, der die 5 enthält, darstellen
Java:
while (links < rechts) {
         int mid = (links+rechts) / 2;
         if (array[mid] == 5)
             tmp=middle;
         else if (array[mid] > 5)
             rechts = mid - 1;
         else
             links = mid + 1;
         }
}
 
X

Xyz1

Gast
Nein leider nicht, es soll in log(n) gesucht werden.

Also, ich weiß zwar nicht, why ich mir das antue, aber es kann in log(n) herausgefunden werden, wie oft eine Zahl n im (sortiert) Array enthalten ist, dabei steht 0 == nicht enthalten:
Java:
    // main method...
        for (int i = 0; i < 10; i++) {
            int[] ia = rando.ints(5, 0, 2).toArray();
            Arrays.sort(ia);
            System.out.println(Arrays.toString(ia));
            System.out.println(findNotNCount(ia, findIndex(ia, 0)));
            System.out.println(findNotNCount(ia, findIndex(ia, 1)));
            System.out.println("");
        }

    }

    /**
     * n/2....
     *
     * @param array
     * @param n
     * @return
     */
    static int findNaiv(int[] array, int n) {
        for (int i = 0; i < array.length; i++) {
            if (array[i] == n) {
                for (int j = i + 1; j < array.length; j++) {
                    if (array[j] != n) {
                        return j - i;
                    }
                }
                return array.length - i;
            }
        }
        return 0;
    }

    /**
     * log(n)..
     * @param array
     * @param n
     * @return
     */
    static int findIndex(int[] array, int n) {
        int i = 0, j = array.length - 1, k = i + (j - i) / 2;
        while (i <= j) {
            if (array[k] < n) {
                i = k + 1;
                k = i + (j - i) / 2;
            } else if (array[k] > n) {
                j = k - 1;
                k = i + (j - i) / 2;
            } else {
                return k;
            }
        }
        return -1;
    }

    /**
     * log(n)..
     * @param array
     * @param n
     * @return
     */
    static int findNotNCount(int[] array, int n) {
        int i = 0, j = n - 1, k = i + (j - i) / 2;
        while (i <= j) {
            if (array[k] == array[n]) {
                j = k - 1;
                k = i + (j - i) / 2;
            } else {
                i = k + 1;
                k = i + (j - i) / 2;
            }
        }
        if (k < 0) {
            return 0;
        }
        int a = k;
        i = n + 1;j = array.length - 1;k = i + (j - i) / 2;
        while (i <= j) {
            if (array[k] == array[n]) {
                i = k + 1;
                k = i + (j - i) / 2;
            } else {
                j = k - 1;
                k = i + (j - i) / 2;
            }
        }
        int b = k;
        return b - a;
    }

Ich muss aber gleich dazusagen, das es... unklug... ist, das auf ganze/volle 5 Elemente loszulassen; der Unterschied zu findNaiv macht sich vielleicht erst bei Tausenden von Elementen bemerkbar.

hth ;)

Aber hallo, was solls, ich habe auch etwas dabei gelernt. :)

Bearbeitung: Ich habe die Ausgabe vergessen:
Code:
[1, 1, 1, 1, 1]
0
5

[0, 0, 0, 0, 1]
4
1

[0, 1, 1, 1, 1]
1
4

[0, 0, 0, 1, 1]
3
2

[0, 1, 1, 1, 1]
1
4

[0, 0, 0, 1, 1]
3
2

[0, 0, 0, 1, 1]
3
2

[0, 0, 0, 0, 1]
4
1

[0, 1, 1, 1, 1]
1
4

[0, 0, 1, 1, 1]
2
3

wenn man rando mit 4 initialisiert....
 

Jardcore

Top Contributor
@Offtopic:
@DerWissende : kauf dir mal https://www.amazon.de/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882
Kannst du mir erklären wozu du die Kommentare an den Methoden brauchst?

Das sollte der Standard weg sein, der an der Unit gelehrt wird.
Java:
public class BinarySearch { 
    public void searchBinary(int[] intArr, int anfang, int ende, int zahl) {   
        int grenze = anfang + ((ende - anfang) / 2); 
         
        if (intArr.length == 0) { 
            System.out.println("Array leer."); 
            return; 
        } 
         
        if (grenze >= intArr.length){ 
            System.out.println(zahl + " nicht im Array enthalten."); 
            return; 
        } 

        if (zahl > intArr[grenze]) { 
            searchBinary(intArr, grenze + 1, ende, zahl); 
        } else if (zahl < intArr[grenze] && anfang != grenze) { 
            searchBinary(intArr, anfang, grenze - 1, zahl); 
        } else if(zahl == intArr[grenze]) { 
            System.out.println(zahl + " an Position " + grenze + " enthalten."); 
        } else{ 
            System.out.println(zahl + " nicht im Array enthalten."); 
        } 
    } 

    public static void main(String[] args) { 
        int[] testArr = { 5, 3, 5, 228, 14, 69, 18, 27, 109, 85 }; 
        Arrays.sort(testArr); 
        BinarySearch bs = new BinarySearch(); 
        bs.searchBinary(testArr, 0, testArr.length - 1, 228); 
    } 
}
Zu finden unter:
https://javabeginners.de/Algorithmen/Suchalgorithmen/Binaere_Suche.php
 
X

Xyz1

Gast
Das sollte der Standard weg sein, der an der Unit gelehrt wird.
Ja, der findige Fuchs (Student) kennt es am Ende des 1. Semesters. Den Anderen wird es später eingebläut.

aus der Praxis geht hervor, dass mehr als 1 Kommentar pro Methode unangebracht ist. (Methoden dürfen ja nicht beliebig lang werden.)

ABER 1. ist das eine rekursive Methode, 2. etwas langsamer, 3. entspricht das nicht der Aufgabenstellung, 4. sollte die Häufigkeit, mit der ein Element n vorkommt, ermittelt werden, 5. einfach einen Index eines Elements n zu ermitteln, ist nicht genug, 6. deine zwei Prüfungen, ob alle Parameter legal sind, braucht meine Methode *nicht* (das wird inklusiv geprüft).

Dennoch Danke, dass du nochmal die Basics aufzeigst.
 

Senftube

Aktives Mitglied
Hallo,
schön binarySearch() selbst zu implementieren (dann hat man es auch verstanden)
aber es gibt doch java.util.Arrays.binarySearch() mit zahllosen Überladungen, sodass man auch
sortierte arrays mit eigenen Klassen durchsuchen kann, indem man als 3. Parameter einen Comperator
übergibt.
Leider kannst du die Haeufigkeit eines Wertes nicht mit der binarySearch() methode ermitteln. Wenn es einen Wert mehrfach gibt ist die gelieferte Position/Index je nach der Position des Wertes der zuerst geprüft wird ehr zufällig. Wenn der Wert noch nicht enthalten ist, bekommt man die Position abzüglich -1 wo man den noch
unbekannten Wert im Array aufnehmen müsste, damit die Liste sortiert bleibt.Also wenn -1 geliefert wird muss auf Pos 0 eingefügt werden, bei -3 an der Stelle 2.

Ich würde das so lösen:
Java:
public static countValue(int[] array_sorted,int val)
{   
    int cnt=0; int i=0;
    for (i=0;i < array_sorted.length;i++)
    {
        if (array_sorted[i] == val)
        {
            cnt++; // jetzt nachfolgende werte untersuchen
            for (int k=i+1;k < array_sorted.length;k++)
            { if (array_sorted[k] != val) return cnt;
              cnt++;
            }
        }       
    }
    return cnt;
}
 
X

Xyz1

Gast
Außerdem macht das mein naiver Zählalgorithmus findNaiv bereits (damit (später) evtl. die Laufzeiten vergleichen werden können)...
Außerdem hab ich schon mit eine der besten Implementierungen hingeklatscht...
Soll nicht unfreundlich klingen, aber ich habe mir schon Mühe gegeben.^^
 
X

Xyz1

Gast
Aber findNotNCount ist echt unleserlich... ich sollte zwischendurch auf vernünftige Namensgebung usw.
----
Hallo aber, wenn es (unwahrscheinlich) den Algorithmus noch nicht gab, bin ich der Autor - und keiner darf ihn verwenden. :D (Sehr unwahrscheinlich)
 
X

Xyz1

Gast
(Er ist doch gar nicht rekursiv...) Ihr könnt das ja mal testen:
Java:
    public static void main(String[] args) {
        Random rando = new Random(4);
        long t1 = 0, t2 = 0, t3 = 0;
        for (int i = 5_000; i < 10_000_000; i++) {
            int[] ia = rando.ints(i, 0, 3).toArray();
            Arrays.sort(ia);
            t1 = System.currentTimeMillis();
            int n1 = findNaiv(ia, 0);
            t2 = System.currentTimeMillis();
            int n2 = findNotNCount(ia, findIndex(ia, 0));
            t3 = System.currentTimeMillis();
            System.gc();
            System.out.println("i  = " + i);
            System.out.println("n1 = " + n1);
            System.out.println("n2 = " + n2);
            System.out.println(t2 - t1);
            System.out.println(t3 - t2);
            System.out.println("----");
            if (t2 - t1 > t3 - t2) {
                break;
            }
        }
    }

Das Programm läuft bei mir ca. 1 Minute und hält bei ca. 15_000 an.

Das Programm wird immer irgendwann anhalten (auch ohne Abbruchbedingung)!!!! Da es unterschiedliche Laufzeiten sind.

System.gc ist da, damit das vorherige Array 'aufgeräumt' wird.

Dann ein Fazit noch.... Es ist sinnvoll, diesen Algorithmus bei Elementen > 15_000 anzuwenden. Mir fällt aber keine Anwendung ein, in der es sinnvoll ist, >= 5_000mal dasselbe Element zu haben. ;)
 

mrBrown

Super-Moderator
Mitarbeiter
Wäre als Kompromiss zwischen n/2 und log(n) wenn man die Sortiertheit ausnutzen will und nicht das
ganze Array absuchen will. Wenn man von einer Normalverteilung der Werte ausgeht, kann man entscheiden, ob man den Wert von vorne oder von hinten im Array sucht.
Das ist kein Kompromiss, das ist die quasi die Ursprungslösung mit stumpfem durchlaufen in hässlich.
 

mrBrown

Super-Moderator
Mitarbeiter
System.gc ist da, damit das vorherige Array 'aufgeräumt' wird.
Verbreite doch nicht immer diesen Unsinn mit händisch System.gc nutzen wäre irgendwie sinnvoll...

Dann ein Fazit noch.... Es ist sinnvoll, diesen Algorithmus bei Elementen > 15_000 anzuwenden. Mir fällt aber keine Anwendung ein, in der es sinnvoll ist, >= 5_000mal dasselbe Element zu haben. ;)
Wäre in der heutigen Zeit auch ein ziemliches Wunder, wenn man plötzlich viele Daten hätte.
 
X

Xyz1

Gast
Verbreite doch nicht immer diesen Unsinn mit händisch System.gc nutzen wäre irgendwie sinnvoll...

Wäre in der heutigen Zeit auch ein ziemliches Wunder, wenn man plötzlich viele Daten hätte.
gc: Ok, man müsste ihm noch 100 Millisekunden Zeit geben, damit es sinnvoll ist. Ich habe ja auch nicht behauptet, dass dieser Benchmark perfekt sei.... Aber theoretisch läufts nicht ewig ;)

Daten: Ok, bei DNA vielleicht, dann machts wiederum keinen Sinn, erst zu sortieren, dann zu zählen - anstatt einmal drüber zu laufen.

Das Szenario ist einfach nicht sinnvoll denkbar.

Außerdem.... Evtl. auf anderen nicht Beschimpfungen an den Kopf hauen, ich denke mal, viele sind einfach in der Lernphase.

Alle Hintergründe dazu werden in einer Komplexitätstheorievorlesung ausführlich behandelt ;)
 

mrBrown

Super-Moderator
Mitarbeiter
gc: Ok, man müsste ihm noch 100 Millisekunden Zeit geben, damit es sinnvoll ist. Ich habe ja auch nicht behauptet, dass dieser Benchmark perfekt sei.... Aber theoretisch läufts nicht ewig ;)
Ganz ehrlich: sag besser nie mehr was zu System.gc, da kommt nur Unsinn raus.

Daten: Ok, bei DNA vielleicht, dann machts wiederum keinen Sinn, erst zu sortieren, dann zu zählen - anstatt einmal drüber zu laufen.

Das Szenario ist einfach nicht sinnvoll denkbar.
Dir fällt ersthaft nur DNA ein zu Daten mit mehr als 5000 "gleichen" Elementen? Ich kann mir kaum Datenverarbeitung mit weniger als tausenden Elementen vorstellen...
 

Senftube

Aktives Mitglied
Vielleicht so:
Java:
public static int countValue(int[] arr,int val)
{
    int cnt=0;
    int pos = Arrays.binarySearch(arr,val);
    if (pos < 0) return cnt;
    cnt++;
    // benachbarte werte ober- und unterhalb pos untersuchen
    for (int i=pos-1;i >= 0;i--) // unterhalb
    {
        if (arr[i] != val) break;
        cnt++;
    }
    for (int i=pos+1;i < arr.length;i++) // oberhalb
    {
        if (arr[i] != val) break;
        cnt++;
    }
    return cnt;
}
 
X

Xyz1

Gast
Yeah, nur dass das nicht log(n) ist ;)
Lass es doch einfach, das Verlangte steht ja schon oben. :)
----
Oder Übungszwecke, dann will ich nichts gesagt haben...
 

Meniskusschaden

Top Contributor
naja, angenommen m wächst ähnlich wie n: O(log(n)+m) = O(log(n)+n/x) = O(log(n)+n) = O(n)
:)Ja, das ist der worst case, beispielsweise wenn sämtliche Elemente gleich sind. Es kann aber nicht viele Zahlen geben, die fast n-mal im Array vorkommen. Im Durchschnitt wird es also schneller sein, es sei denn, man fragt immer wieder diese Zahl ab. Ich glaube, das wäre wirklich kein realistisches Szenario mehr.
 
Ähnliche Java Themen
  Titel Forum Antworten Datum
B bei 2 Arrays Anzahl gleicher Elemente vergleichen? Java Basics - Anfänger-Themen 49
R Anzahl gleicher Elemente in ArrayList Java Basics - Anfänger-Themen 5
D Ermitteln der Anzahl gleicher Nachkommastellen 2er Zahlen Java Basics - Anfänger-Themen 9
onlyxlia Anzahl Random Zahlen mit Scanner abfragen und in Array speichern Java Basics - Anfänger-Themen 10
T code so schreiben das er von sich selber anpasst (code soll die anzahl aller bustaben bestimmen) Java Basics - Anfänger-Themen 16
C Parameter in verschiedenen Anzahl und Typen Java Basics - Anfänger-Themen 6
Ibrahim Anzahl möglicher Reiserouten zurückgeben Java Basics - Anfänger-Themen 5
K loop pausieren für eine bestimmte Anzahl? Java Basics - Anfänger-Themen 1
M Anzahl Kommandozeilenparamter mittels Methode Java Basics - Anfänger-Themen 11
I Eindeutiger String mit maximaler Anzahl an Zeichen Java Basics - Anfänger-Themen 11
nils812 Black Jack Karten Anzahl begrenzen Java Basics - Anfänger-Themen 5
berserkerdq2 sqllite in Java, wenn ich mache select count(*) ..., erhalte ich dann nur die gezählte Anzahl oder werden auch die Tabellen ausgegeben? Java Basics - Anfänger-Themen 2
I Prüfen, ob Anzahl an Monate ein Jahr ergeben Java Basics - Anfänger-Themen 4
B Anzahl Nullen uns Einsen in String ermitteln Java Basics - Anfänger-Themen 3
O Ich habe einen String und soll mit matches schauen, ob ein Buchstabe zu einer geraden ANzahl im String vorkommt, wie soll das gehen? Java Basics - Anfänger-Themen 7
C Anzahl ArrayLists unbekannt Java Basics - Anfänger-Themen 4
O Anzahl Datensätze ausgeben Java Basics - Anfänger-Themen 5
T Maximale Anzahl von Konsonanten im String Java Basics - Anfänger-Themen 6
N Aus einem String die Anzahl der Vokale auslesen Java Basics - Anfänger-Themen 40
W Dez-->Binär mit eigener bit Anzahl Erkennung. Java Basics - Anfänger-Themen 3
RudiRüssel maximale Anzahl von Schlüsseln in einer Hash Tabelle Java Basics - Anfänger-Themen 2
W Anzahl der Zeilen ausgeben lassen Java Basics - Anfänger-Themen 20
J Verschieben von Buchstaben in einem String um vorgegebene Anzahl von Zeichen innerhalb eines weiteren String Java Basics - Anfänger-Themen 12
Kingamadeus2000 Anzahl der Ziffern der kürzesten Zahl aus einem zurückliefern Java Basics - Anfänger-Themen 1
Tino1993 for-Schleife, die eine vorgegebene Anzahl von Zeichen ausgibt Java Basics - Anfänger-Themen 3
M Anzahl Schleifendurchgänge nach x Sekunden anzeigen Java Basics - Anfänger-Themen 2
P Primzahl mit Angabe der höchsten Primzahl und Angabe der Anzahl von Primzahlen bis 100 Java Basics - Anfänger-Themen 8
L Anzahl der benachbarten Minen berechnen und setzen Java Basics - Anfänger-Themen 15
Kirby.exe Anzahl vorkommender Elemente im Array zählen Java Basics - Anfänger-Themen 9
B Nur eine bestimmte Anzahl an Arrays ausgeben Java Basics - Anfänger-Themen 9
hello_autumn Klassen Anzahl sowie die Anzahl der Junit Tests ermitteln? Java Basics - Anfänger-Themen 8
B Von Array nur eine bestimmte Anzahl bekommen Java Basics - Anfänger-Themen 3
L Anzahl der Paare deren Summe = 0 ergibt berechnen Java Basics - Anfänger-Themen 0
L Anzahl der Elemente key in einem Array mit log(N) Laufzeit Java Basics - Anfänger-Themen 4
L Anzahl der Aufrufe von Schleifen bestimmen Java Basics - Anfänger-Themen 1
D Alle Möglichkeiten, n-Anzahl aus Elementen aus einem Array zu wählen, ausgeben? Java Basics - Anfänger-Themen 23
B Frage zu: String... strings -> Ungleiche Anzahl an Parameter? Java Basics - Anfänger-Themen 4
O ObjectOutputStream Anzahl Objekte festhalten Java Basics - Anfänger-Themen 17
B Anzahl von Stunden / Tage von zwei Datumswerten ermitteln Java Basics - Anfänger-Themen 1
L Dynamische Anzahl an Arrays mit verschiedenen Namen erzeugen Java Basics - Anfänger-Themen 6
H Anzahl verschiedener Buchstaben im String Java Basics - Anfänger-Themen 41
sondr Anzahl der gleichen Positionen im Array Java Basics - Anfänger-Themen 3
Y Konkrete Hilfe gesucht - Anzahl der Stellen einer eingegebenen Zahl überprüfen Java Basics - Anfänger-Themen 5
Y Begrenzte Anzahl an Objekten? Java Basics - Anfänger-Themen 12
P Input/Output Bestimmte Anzahl von Werten in einem Array an Methode übergeben Java Basics - Anfänger-Themen 2
L Graphen: Anzahl Knoten // Knoten in Array speichern Java Basics - Anfänger-Themen 4
E Anzahl Datensätze in Textfeld Java Basics - Anfänger-Themen 5
T befehle unterschiedlicher anzahl an strings wiedergeben Java Basics - Anfänger-Themen 2
L Feld mit beliebiger Anzahl von Buchstaben füllen... Java Basics - Anfänger-Themen 5
LikeManuel Anzahl der Teiler Java Basics - Anfänger-Themen 6
D Anzahl von Zahlen bei eingabe begrenzen Java Basics - Anfänger-Themen 37
T Erste Schritte Schreiben Sie eine Klasse Zeit, die eine Zeitdauer in Minuten beschreibt. Die Anzahl Minuten verwalt Java Basics - Anfänger-Themen 3
J Max. Anzahl von Knoten im Binärbaum Java Basics - Anfänger-Themen 3
ralli85 Programm nach einer gewissen Anzahl von Eingaben beenden Java Basics - Anfänger-Themen 15
Z Ausgabe: Anzahl Sterne, danach verringern Java Basics - Anfänger-Themen 7
R Anzahl von Zeichen in einem Char Array Java Basics - Anfänger-Themen 4
A Anzahl der Elemente in einem Stack wiedergeben Java Basics - Anfänger-Themen 3
V Anzahl der Möglichkeiten 20 € zu bezahlen Java Basics - Anfänger-Themen 2
A variable Anzahl an Nutzereinagben Java Basics - Anfänger-Themen 4
stylegangsta Anzahl der gefunden array Werte ausgeben Java Basics - Anfänger-Themen 6
D Variable Anzahl an Buttons per Schleife Java Basics - Anfänger-Themen 7
H Liste ausgeben (Spiel Hey Fisch (software-challenge) ändern Anzahl Fische) Java Basics - Anfänger-Themen 1
M Überschneidende Anzahl von Tagen Java Basics - Anfänger-Themen 4
D Suche nach der Anzahl von Zonen zwischen zwei Punkten Java Basics - Anfänger-Themen 2
S Input/Output Alphabet in eine Datei schreiben und Anzahl von Zeichen ausgeben. Java Basics - Anfänger-Themen 4
I Anzahl der Rechenschritte darstellen lassen Java Basics - Anfänger-Themen 11
C Anzahl bestimmter Zeichen in einem String ausgeben Java Basics - Anfänger-Themen 7
T Anzahl bestimmter Werte eines arrays bestimmen Java Basics - Anfänger-Themen 4
A Rekursion, Anzahl von Stellen ausgeben Java Basics - Anfänger-Themen 7
S Anzahl Quersummen bis zur Einstelligkeit Java Basics - Anfänger-Themen 12
S Anzahl unterschiedlicher Elemente zählen Java Basics - Anfänger-Themen 4
G Performance - höhere Anzahl Swing Elemente Java Basics - Anfänger-Themen 5
R Begrenzer Anzahl von paint() ? Java Basics - Anfänger-Themen 3
J Anzahl von for-Schleifen in Abhängigkeit von Zahleneingabe erzeugen Java Basics - Anfänger-Themen 1
C Beliebige Anzahl Arrays zusammenfügen Java Basics - Anfänger-Themen 5
L Best Practice Alle Kombinationen aus Listenelementen, Anzahl Listen unterschiedlich Java Basics - Anfänger-Themen 6
I Methoden ByteBuffer - Anzahl führender Nullen Java Basics - Anfänger-Themen 3
E Array Anzahl verschiedener Werte ausgeben Java Basics - Anfänger-Themen 3
V Anzahl von gleichen Werten in einem Int-Array ermitteln Java Basics - Anfänger-Themen 4
B Anzahl if anweisungen nicht bekannt Java Basics - Anfänger-Themen 3
T Anzahl der Schritte berechnen Java Basics - Anfänger-Themen 6
R Anzahl der ineinander verschachtelten for-Schleifen von Variable abhängig machen Java Basics - Anfänger-Themen 5
P BitSet- Objekt- Anzahl der Elemente bestimmen Java Basics - Anfänger-Themen 2
B Variablen Unbekante anzahl an Strings splitten und vergleichen Java Basics - Anfänger-Themen 31
M Anzahl Zahlen in String Java Basics - Anfänger-Themen 21
A Threads Minimale und maximale Anzahl. Java Basics - Anfänger-Themen 28
J Bestimmte Anzahl Zeichen aneinander fügen Java Basics - Anfänger-Themen 9
H Anzahl Ziffer in Zahl bestimmen Java Basics - Anfänger-Themen 3
A Anzahl nodes in einem Tree Java Basics - Anfänger-Themen 2
G maximale Anzahl der Tage im Monat Java Basics - Anfänger-Themen 18
G Datentypen Double ausgeben mit minimaler Anzahl Nachkommastellen Java Basics - Anfänger-Themen 3
P Anzahl der else if Operatoren begrenzt?? Java Basics - Anfänger-Themen 7
B genaue Anzahl der Operationen in Schleifen Java Basics - Anfänger-Themen 5
Dit_ Anzahl der Bestellungen grafisch abbilden | Statistisk Java Basics - Anfänger-Themen 6
Luk10 Anzahl der Knoten in einem Baum ausgeben! Java Basics - Anfänger-Themen 6
F Methoden Hanoi - Anzahl der Bewegungen Java Basics - Anfänger-Themen 8
A Counter für die anzahl von regulären ausdrücken Java Basics - Anfänger-Themen 4
M float/double Anzahl Nachkommastellen ermitteln Java Basics - Anfänger-Themen 18
B Anzahl der Werte bestimmen Java Basics - Anfänger-Themen 14
K Sortierung von Anzahl der Wörtern in ArrayList Java Basics - Anfänger-Themen 4

Ähnliche Java Themen

Neue Themen


Oben