Maximum berechnen ...

Vulymuz

Aktives Mitglied
Hallo,

ich will anhand folgenden Codes den Maximum einer Zahlenreihe berechnen, doch irgendwie komme ich nicht darauf, wo mein Fehler liegt.

Java:
public class Zufallszahlen 
{
  
  public static void main(String[] args) {
    
    int[] zahlen = new int[1+5];
    int Summe = 0;
    int max, min, i, y;
    y = 0;
    
    for (i = 0;i <= 5;i++)
    {
      zahlen[i] = (int) (Math.random()*100+1);
      System.out.println(zahlen[i]);
      Summe = Summe + zahlen[i];
      
      if (i == 5) {
        System.out.println("DURCHSCHNITT: Der Durchschnitt liegt bei: " + (Summe / i));
      } // end of if
    }
    // AB HIER GEHTS EIGENTLICH LOS MIT DER MAXIMUM-BERECHNUNG
    for (max = 5;max >= 0;max--)
    {
      for (int j = 0;j <= max;j++) {
        if (zahlen[max] >= zahlen[j])
        {
          y++;
          
          if (y == 6)
          {
            System.out.println(zahlen[max]);
          }
          
          if (j == 5)
          {
            y = 0;
          } // end of if
        } // end of if
      }
    }
}

Der Sinn dahinter ist ganz einfach: Die Laufumgebung geht alle Zahlen durch, und falls beispielsweise zahlen[0] (zahlen[max] eigentlich, aber durch die for-Schleife ändert sich die Variable ja immer) größer als zahlen[1] ist, erhöht sich die Variable y um einen Punkt (y++). Falls dann die Variable der zweiten for-Schleife, "j", fünf entspricht, setze ich y wieder auf 0, sonst würde sich y ja immer weiter erhöhen und ich könnte schlecht herausbekommen, welche Zahl nun die größte ist.

Manchmal klappt die Idee, manchmal wiederum nicht ... Zum Beispiel wird auch mal die kleinste Zahl als der Maximum dargestellt... Warum?! :autsch:
 
Zuletzt bearbeitet:

ssoul26

Bekanntes Mitglied
Sortier das Array mit BubbleSort und zieh dir dann einfach das Maximum raus. Implementierungen zu BubbleSort findest du überall, ist auch nicht schwer zu verstehen.
 

Vulymuz

Aktives Mitglied
Ja, aber ich will mit meinen bisherigen Kenntnissen auf die Lösung kommen. Also einfach verstehen wo mein Fehler bei der Codierung liegt.

Ist eh für den Informatik-Unterricht, und wenn ich da plötzlich ganz andere Codes benutze, die andere nicht checken, kommt das schlecht rüber...
 
B

bone2

Gast
max ist ganze einfach, eine for schleife über das array und ein temp int = 0.
dann guckst du, ist zah größer als tempint, dann schreib zahl in tempint, sonst geh zur nächsten zahl.
nach der schleife steht in tempint die größte zahl
 
S

Spacerat

Gast
max ist ganze einfach, eine for schleife über das array und ein temp int = 0.
dann guckst du, ist zah größer als tempint, dann schreib zahl in tempint, sonst geh zur nächsten zahl.
nach der schleife steht in tempint die größte zahl
... mit Startwert "tmpInt = Integer.MIN_VALUE", macht's auch nichts, wenn alle Zahlen im Array negativ sind.
 

Vulymuz

Aktives Mitglied
In meinem Fall würde das aber funktionieren...


Trotzdem: Ich würde gerne wissen, wo bei MEINER Codierung der Fehler liegt... Irgendwo scheine ich da etwas nicht beachtet zu haben.

Übrigens eine neue Version:

Java:
public class Zufallszahlen 
{
  
  public static void main(String[] args) {
    
    int[] zahlen = new int[1+5];
    int Summe = 0;
    int max, min, i, y;
    y = 0;
    
    for (i = 0;i <= 5;i++)
    {
      zahlen[i] = (int) (Math.random()*100+1);
      System.out.println(zahlen[i]);
      Summe = Summe + zahlen[i];
      
      if (i == 5) {
        System.out.println("DURCHSCHNITT: Der Durchschnitt liegt bei: " + (Summe / i));
      } // end of if
    }
    
    for (max = 5;max >= 0;max--)
    {
      for (int j = 0;j <= max;j++) {
        if (zahlen[max] >= zahlen[j])
        {
          y++;
          
          if (y == 6)
          {
            System.out.println(zahlen[max]);
            break;
          }
          
          if (j == 5)
          {
            y = 0;
          } // end of if
        } // end of if
      }
    }
}
 
B

bone2

Gast
warum sind da zwei schleifen? hast du mal ausgaben eingebaut, die in jdem durchlauf anzeigen was passiert? bist du deine schleifen mal schritt für schritt mit bespielwerten durchgengangen? auf nem blatt papier?

du findest den fehler so leicht selber und lernst dabei.


sonst:
variablennamen lowerCamelCase, also summe nicht Summe

Java:
      if (i == 5) {
        System.out.println("DURCHSCHNITT: Der Durchschnitt liegt bei: " + (Summe / i));
      } // end of if
gehört nicht in die erste schleifen, sondern einfach danach und ohne if
 

Marco13

Top Contributor
Weil ich es schon so oft gelesen habe, und es SO :autsch: ist, hier mal deutlich und in neckischem rot:

Man macht keine Maximumsuche indem man sortiert!!!
 
B

bone2

Gast
Du musst das Array so lange von Anfang durchlaufen, bis du keine indexvertauschungen mehr vorgenommen hast.
wo tauscht hier jemand was?

Für einen Anfänger sind das zwei Fliegen mit einer Klappe. Ich seh darin kein großes Problem darin, eventuell will er ja später vllt. das Array weiter verwenden.
egal wie mans nimmt, 10km am ziel vorbeigeschossen.
oder um es schulisch auszudrücken: aufgabenstellung verfehlt, 5

@TE ich hab dein problem gefunden, und ich glaube, ich habe die logik verstanden die du benutzen wolltest um nach dem größten zu suchen

Java:
        for (max = 5; max >= 0; max--) {
            System.out.println("max=" + max);
            for (int j = 0; j <= max; j++) {
                System.out.println("j=" + j + " z[max]" + zahlen[max] + " z[j]" + zahlen[j] + " z[max]>=z[j]=" + (zahlen[max] >= zahlen[j]));

                if (zahlen[max] >= zahlen[j]) {
                    y++;

                    if (y == 6) {
                        System.out.println("max gefunden=" + zahlen[max]);
                        break;
                    }

                    if (j == 5) {
                        y = 0;
                    } // end of if
                } // end of if
            }
Code:
DURCHSCHNITT: Der Durchschnitt liegt bei: 40
[11, 84, 37, 63, 25, 21]
max=5
j=0 z[max]21 z[j]11 z[max]>=z[j]=true
j=1 z[max]21 z[j]84 z[max]>=z[j]=false
j=2 z[max]21 z[j]37 z[max]>=z[j]=false
j=3 z[max]21 z[j]63 z[max]>=z[j]=false
j=4 z[max]21 z[j]25 z[max]>=z[j]=false
j=5 z[max]21 z[j]21 z[max]>=z[j]=true
max=4
j=0 z[max]25 z[j]11 z[max]>=z[j]=true
j=1 z[max]25 z[j]84 z[max]>=z[j]=false
j=2 z[max]25 z[j]37 z[max]>=z[j]=false
j=3 z[max]25 z[j]63 z[max]>=z[j]=false
j=4 z[max]25 z[j]25 z[max]>=z[j]=true
max=3
j=0 z[max]63 z[j]11 z[max]>=z[j]=true
j=1 z[max]63 z[j]84 z[max]>=z[j]=false
j=2 z[max]63 z[j]37 z[max]>=z[j]=true
j=3 z[max]63 z[j]63 z[max]>=z[j]=true
max=2
j=0 z[max]37 z[j]11 z[max]>=z[j]=true
max gefunden=37
max=1
j=0 z[max]84 z[j]11 z[max]>=z[j]=true
j=1 z[max]84 z[j]84 z[max]>=z[j]=true
max=0
j=0 z[max]11 z[j]11 z[max]>=z[j]=true

j wird immer kürzer, so funktioniert dein vergleich gegen die restzahlen nicht mehr
du setzt y zu früh/falsch/nie 0
 
Zuletzt bearbeitet von einem Moderator:

ssoul26

Bekanntes Mitglied
Java:
  for (max = 5;max >= 0;max--)
    {
      for (int j = 0;j <= max;j++) {
        if (zahlen[max] >= zahlen[j])
        {
          y++;
          
          if (y == 6)
          {
            System.out.println(zahlen[max]);
            break;
          }
          
          if (j == 5)
          {
            y = 0;
          } // end of if
        } // end of if
      }
    }

Du brauchst hier meiner Meinung nach keine zwei Schleifen.
Folgender Auszug sollte dir weiterhelfen:

Java:
for (i=0; i<array.length; i++) { 
if (array[i]>max) { 
max = array[i]; 
} 
}
 

Vulymuz

Aktives Mitglied
Sorry, aber ich komme nicht drauf. Zum Beispiel bei der Zahlenreihe
89 (-> zahlen[0])
34 (-> zahlen[1])
56 (-> zahlen[2])
60 (-> zahlen[3])
45 (-> zahlen[4])
63 (-> zahlen[5])

müsste laut meiner Codierung bei

if zahlen[max] (was am Anfang 5, also max == 5 ist) >= zahlen[j]
do {y++}

ja bei 63 y == 5, also müsste dementsprechend auch 63 auf jeden Fall herausgegeben werden, auch wenns nicht der Maximum ist. Aber der Compiler gibt nur 56 heraus ... -_-
 

ssoul26

Bekanntes Mitglied
egal wie mans nimmt, 10km am ziel vorbeigeschossen.
Vorbeigeschossen ist es bestimmt nicht. Das gewollte Ergebnis wird geliefert, aber halt mit einem Umweg, den man als Laie gerne mal in Kauf nehmen sollte. Aber das verstehen viele "Profis" nicht. Wenn er schon dabei ist mit Arrays zu hantieren, dann macht es nichts, auch mal einen kleinen Exkurs innerhalb der eigenen Software zu unternehmen. ;)
 
B

bone2

Gast
Sorry, aber ich komme nicht drauf. Zum Beispiel bei der Zahlenreihe
89 (-> zahlen[0])
34 (-> zahlen[1])
56 (-> zahlen[2])
60 (-> zahlen[3])
45 (-> zahlen[4])
63 (-> zahlen[5])

müsste laut meiner Codierung bei

if zahlen[max] (was am Anfang 5, also max == 5 ist) >= zahlen[j]
do {y++}

ja bei 63 y == 5, also müsste dementsprechend auch 63 auf jeden Fall herausgegeben werden, auch wenns nicht der Maximum ist. Aber der Compiler gibt nur 56 heraus ... -_-
hab im letzten beitrag nochmal was editiert, les das nochmal.
hab hier ne gefixte version wenn du es nicht hinbekommst, post ich dir die

@ssoul26
die normale max lösung die ich vor 5 posts geschrieben hab? wow ;)
und warum man als laie in den ersten schritten gleich alles andere mögliche nebenbei, wie sort, machen sollte, erschliest sich mir pädagogisch nicht.
 
Zuletzt bearbeitet von einem Moderator:

Vulymuz

Aktives Mitglied
aber es ist doch richtig, wenn bei j = 5, y = 0 setze oder nicht? ... Ansonsten, bitte her mit der Lösung, muss gleich weg ... :s
 
B

bone2

Gast
Java:
        int mengeZahlen = 6;
        int[] zahlen = new int[mengeZahlen];
        int summe = 0;
        int max, min, i, y;

        for (i = 0; i < mengeZahlen; i++) {
            zahlen[i] = (int) (Math.random() * 100 + 1);
            System.out.println(zahlen[i]);
            summe = summe + zahlen[i];
        }

        System.out.println("DURCHSCHNITT: Der Durchschnitt liegt bei: " + (summe / mengeZahlen));
        System.out.println(Arrays.toString(zahlen));

        y = 0;

        for (max = 5; max >= 0; max--) {
            System.out.println("max=" + max);
            for (int j = 0; j < mengeZahlen; j++) {
                System.out.println("j=" + j + " z[max]" + zahlen[max] + " z[j]" + zahlen[j] + " z[max]>=z[j]=" + (zahlen[max] >= zahlen[j]));

                if (zahlen[max] >= zahlen[j]) {
                    y++;

                    if (y == 6) {
                        System.out.println("max gefunden=" + zahlen[max]);
                        break;
                    }

                }
            }

            y = 0;
        }

Code:
27
15
38
10
50
41
DURCHSCHNITT: Der Durchschnitt liegt bei: 30
[27, 15, 38, 10, 50, 41]
max=5
j=0 z[max]41 z[j]27 z[max]>=z[j]=true
j=1 z[max]41 z[j]15 z[max]>=z[j]=true
j=2 z[max]41 z[j]38 z[max]>=z[j]=true
j=3 z[max]41 z[j]10 z[max]>=z[j]=true
j=4 z[max]41 z[j]50 z[max]>=z[j]=false
j=5 z[max]41 z[j]41 z[max]>=z[j]=true
max=4
j=0 z[max]50 z[j]27 z[max]>=z[j]=true
j=1 z[max]50 z[j]15 z[max]>=z[j]=true
j=2 z[max]50 z[j]38 z[max]>=z[j]=true
j=3 z[max]50 z[j]10 z[max]>=z[j]=true
j=4 z[max]50 z[j]50 z[max]>=z[j]=true
j=5 z[max]50 z[j]41 z[max]>=z[j]=true
max gefunden=50
max=3
j=0 z[max]10 z[j]27 z[max]>=z[j]=false
j=1 z[max]10 z[j]15 z[max]>=z[j]=false
j=2 z[max]10 z[j]38 z[max]>=z[j]=false
j=3 z[max]10 z[j]10 z[max]>=z[j]=true
j=4 z[max]10 z[j]50 z[max]>=z[j]=false
j=5 z[max]10 z[j]41 z[max]>=z[j]=false
max=2
j=0 z[max]38 z[j]27 z[max]>=z[j]=true
j=1 z[max]38 z[j]15 z[max]>=z[j]=true
j=2 z[max]38 z[j]38 z[max]>=z[j]=true
j=3 z[max]38 z[j]10 z[max]>=z[j]=true
j=4 z[max]38 z[j]50 z[max]>=z[j]=false
j=5 z[max]38 z[j]41 z[max]>=z[j]=false
max=1
j=0 z[max]15 z[j]27 z[max]>=z[j]=false
j=1 z[max]15 z[j]15 z[max]>=z[j]=true
j=2 z[max]15 z[j]38 z[max]>=z[j]=false
j=3 z[max]15 z[j]10 z[max]>=z[j]=true
j=4 z[max]15 z[j]50 z[max]>=z[j]=false
j=5 z[max]15 z[j]41 z[max]>=z[j]=false
max=0
j=0 z[max]27 z[j]27 z[max]>=z[j]=true
j=1 z[max]27 z[j]15 z[max]>=z[j]=true
j=2 z[max]27 z[j]38 z[max]>=z[j]=false
j=3 z[max]27 z[j]10 z[max]>=z[j]=true
j=4 z[max]27 z[j]50 z[max]>=z[j]=false
j=5 z[max]27 z[j]41 z[max]>=z[j]=false



musterlösung:
Java:
        int temp = Integer.MIN_VALUE;

        for (int zahl : zahlen) {
            if (zahl > temp) {
                temp = zahl;
            }
        }

        System.out.println("größte Zahl ist " + temp);
 
Zuletzt bearbeitet von einem Moderator:

Ark

Top Contributor
Für einen Anfänger sind das zwei Fliegen mit einer Klappe. Ich seh darin kein großes Problem darin, eventuell will er ja später vllt. das Array weiter verwenden.
Das sieht dann aber sehr nach unsauberer Schnittstelle aus: "Hey, eigentlich bin ich nicht fürs Sortieren zuständig, aber ich mach das trotzdem mal, weil ich die Daten sortiert benötige. Hier also als Nebenprodukt die sortierte Liste." Das ist ganz schelchter Stil. Besser wäre: "Hey, ich berechne dir Minimum, Maximum und Median einer Liste in O(1), aber du musst mir dafür diese Liste sortiert geben."

Mal davon abgesehen, stimmt es natürlich, dass viele Operationen auf sortierten Datenstrukturen wesentlich einfacher auszuführen sind als auf unsortierten, etwa Suche, Minimum, Maximum, Median sowie auch (Mengen-)vereinigung, -schnitt und -differenz.

@Vulymuz: Natürlich weiß ich jetzt nicht, wie du so drauf bist. Aber es gibt halt Programmierer, die z.B. eine Methode wirklich nur gerade so hingekriegt haben, und das immer und immer wieder nur "gerade so" machen – ganz egal, wie schlecht die Lösung bei genauerer Betrachtung ist. Stell dir vor, dir würde jemand eine "Lösung" dafür präsentieren, wie man ohne abwaschen zu müssen und ohne Spülmaschine an sauberes Geschirr kommt: Man wirft das schmutzige weg und kauft neues! Klingt nicht gut? Deine Lösung ist halt (nur in Bezug auf die Maximumssuche) von ähnlichem Kaliber. Deshalb die Diskussion hier.

Ark
 

ssoul26

Bekanntes Mitglied
hab im letzten beitrag nochmal was editiert, les das nochmal.
hab hier ne gefixte version wenn du es nicht hinbekommst, post ich dir die

@ssoul26
die normale max lösung die ich vor 5 posts geschrieben hab? wow ;)
und warum man als laie in den ersten schritten gleich alles andere mögliche nebenbei wie sort machen sollte erschliest sich mir pädagogisch nicht.

Summa summarum scheint beides dem TO noch nicht geholfen zu haben. Aber glaub mir dein Post habe ich nicht als Stütze benutzt ;)

Hier geht es nicht um alles andere, sondern um eine meiner Meinung noch im selben Kontext liegende Handlung. Man sieht, dass der TO Probleme mit Arrays und Schleifen hat, da ist es nicht verkehrt, ihm über andere Wege mehr Verständnis für Arrays und Schleifen nahe zu bringen. Er wird früher oder später sowieso selber drauf kommen, dass er eventuell einige Vorschläge gar nicht hätte umsetzen müssen. Aber für das Grundverständnis ist mir dieser Weg sehr wohl pädagogisch als sinnvoll zu betrachten.
 

Landei

Top Contributor
TL;DR

Hatte schon jemand erwähnt, dass der Durchschnitt nicht richtig berechnet wird, da Summe und Anzahl beides int sind?
 
S

Spacerat

Gast
BTW.: Wie wollte man in einem sortierten Array den ursprünglichen Index des Maximalwertes bekommen? In einem solchen liegt dieser je nach auf- bzw. absteigender Sortierung ganz am Ende bzw. ganz am Anfang. MaxValue + Sortierung ist weder "zwei Fliegen mit einer Klappe schlagen" noch eine "unsaubere Schnittstelle" sondern schlicht falsch. Siehe Marco13's Anmerkung in dezentem Rot.
[EDIT]...ach verd.... ich mein' natürlich das neckische Rot. XD[/EDIT]
 
Ähnliche Java Themen
  Titel Forum Antworten Datum
hello_autumn Maximum berechnen. Java Basics - Anfänger-Themen 17
M Maximum, Minimum und Mittelwert berechnen Java Basics - Anfänger-Themen 25
H Minimum und Maximum ausgeben lassen Java Basics - Anfänger-Themen 7
S Array Maximum bestimmen mit for und foreach Java Basics - Anfänger-Themen 7
RudiRüssel Binäre Suche, unsortiert, lokales Maximum Java Basics - Anfänger-Themen 15
J Maximum herauskriegen mit foreach Java Basics - Anfänger-Themen 6
S Compiler-Fehler im array Maximum ermitteln Java Basics - Anfänger-Themen 6
M Maximum einer sinusfunktion (Spalt-Experiment) Java Basics - Anfänger-Themen 5
K Maximum Suchen Array Java Basics - Anfänger-Themen 6
R Erste Schritte Minimum und Maximum in Array finden Java Basics - Anfänger-Themen 29
D VM Argumente - Das Maximum rausholen Java Basics - Anfänger-Themen 19
S JSplitPane Divider Maximum Position Java Basics - Anfänger-Themen 5
D Maximum Subarray Problem; Problem mit der Rückgabe Java Basics - Anfänger-Themen 10
J Das Maximum einer Liste ermitteln Java Basics - Anfänger-Themen 8
S JAVA Methode für Maximum aus 4 ganzen Zahlen Java Basics - Anfänger-Themen 12
A Felder- Minimum/Maximum Java Basics - Anfänger-Themen 2
T aus Integer Array Maximum bestimmen Java Basics - Anfänger-Themen 7
R maximum in integer array suchen Java Basics - Anfänger-Themen 29
B Applet, welches Maximum eines Array bestimmt Java Basics - Anfänger-Themen 2
P Lokales Minimum- Maximum, Globales Minimum - Maximum ? Java Basics - Anfänger-Themen 4
P Minimum/Maximum aus einer Liste Java Basics - Anfänger-Themen 3
Z Zahlenreihe maximum Java Basics - Anfänger-Themen 3
U Maximum zweier Zahlen ermitteln Java Basics - Anfänger-Themen 7
D Maximum werte eines Arrays bestimmen !!!??? Java Basics - Anfänger-Themen 13
S maximum zweier Zahlen Java Basics - Anfänger-Themen 1
M OOP Brüche nicht richtig berechnen Java Basics - Anfänger-Themen 3
V Durchschnittliche Volatility in Prozent für 4 Stunden berechnen Java Basics - Anfänger-Themen 14
T Fibonacci mit einer Hilfsmethode berechnen Java Basics - Anfänger-Themen 10
laxla123 Quersumme berechnen Java Basics - Anfänger-Themen 1
I For Schleife Summe berechnen Java Basics - Anfänger-Themen 13
S Vollmond berechnen und ausgeben Java Basics - Anfänger-Themen 12
S Vollkommene Zahl berechnen und ausgeben Java Basics - Anfänger-Themen 16
A Berechnen Moor Nachbarschaft Java Basics - Anfänger-Themen 5
E Geburtstag im Schaltjahr berechnen Java Basics - Anfänger-Themen 24
Lion.King Schaltjahr berechnen Java Basics - Anfänger-Themen 31
E Alter (Laufzeit) berechnen Java Basics - Anfänger-Themen 11
I Zuschläge berechnen Java Basics - Anfänger-Themen 15
L mit Fakultät mathematische Formel berechnen Java Basics - Anfänger-Themen 5
TanTanIsTrying Durschnitt berechnen von eingegebener Zahl bis 1 heruntergezählt Java Basics - Anfänger-Themen 9
L Präfix berechnen Java Basics - Anfänger-Themen 33
F Abstand zwischen zwei Objekten berechnen wie? Java Basics - Anfänger-Themen 1
Aemulit Java Schaltjahr berechnen Code Java Basics - Anfänger-Themen 7
Poppigescorn Quersumme Berechnen mit einer While Schleife Java Basics - Anfänger-Themen 13
I Potenz berechnen mit for-Schleife Java Basics - Anfänger-Themen 3
A Standardabweichung in Java berechnen Java Basics - Anfänger-Themen 10
H Gesamtabweichung mit Array berechnen Java Basics - Anfänger-Themen 2
G Java Rabatt berechnen Java Basics - Anfänger-Themen 8
V Rückgeld berechnen Java Basics - Anfänger-Themen 6
eleonori Durchschnitt aller Werte eines Baums berechnen Java Basics - Anfänger-Themen 5
Ianatrix Zahlen von a bis b berechnen Java Basics - Anfänger-Themen 7
L Max, min, Summe und Durchschnitt berechnen Java Basics - Anfänger-Themen 4
L Anhalteweg berechnen Java Basics - Anfänger-Themen 6
Aeon Erste Schritte Preise berechnen mit do-while Java Basics - Anfänger-Themen 9
M Quadratwurzel berechnen Java Basics - Anfänger-Themen 8
V Wachstum berechnen und in Ist-Formel verwenden Java Basics - Anfänger-Themen 5
N Variable aus anderen Variablen in statischer Klasse berechnen/abspeichern? Java Basics - Anfänger-Themen 4
M Abschreibungsplan berechnen Java Basics - Anfänger-Themen 23
V Gehalt berechnen in Java Java Basics - Anfänger-Themen 6
justemii Gehalt berechnen - Aufgabe Java-Programm Java Basics - Anfänger-Themen 9
L Anzahl der benachbarten Minen berechnen und setzen Java Basics - Anfänger-Themen 15
J Array Speicherplatz berechnen Java Basics - Anfänger-Themen 35
H Eingabedaten berechnen Java Basics - Anfänger-Themen 9
B Tranportkosten berechnen mit unterschiedlichen MwSt Java Basics - Anfänger-Themen 9
L Anzahl der Paare deren Summe = 0 ergibt berechnen Java Basics - Anfänger-Themen 0
V Erste Schritte Berechnen von Sinus; sin(x) ohne Math.* Java Basics - Anfänger-Themen 1
J Hilfe bei Java Aufgabe (Restschuld berechnen) Java Basics - Anfänger-Themen 11
N Ein Datum berechnen Java Basics - Anfänger-Themen 3
T Sparplan berechnen Java Basics - Anfänger-Themen 4
F Abstand zum Durchschnitt von 5 Zahlen berechnen... Java Basics - Anfänger-Themen 16
B java.util.Date berechnen Java Basics - Anfänger-Themen 11
P Mittelwert Arrayelemente berechnen Fehler Java Basics - Anfänger-Themen 5
CptK Best Practice Schussparabel berechnen Java Basics - Anfänger-Themen 3
T Modulo / Pow berechnen Java Basics - Anfänger-Themen 4
E Statistische Kennzahlen berechnen Java Basics - Anfänger-Themen 2
F Switch Case Modulo berechnen Java Basics - Anfänger-Themen 12
B mehrere Werte mit scanner und while schleife einlesen, max berechnen bzw addieren Java Basics - Anfänger-Themen 2
C Preis berechnen mit Java Java Basics - Anfänger-Themen 4
B Zahl in String abspeichern und später berechnen Java Basics - Anfänger-Themen 15
N Best Practice Image recognition fuzzy Superhash berechnen Java Basics - Anfänger-Themen 1
Dawinartor Erste Schritte Schaltjahr berechnen Java Basics - Anfänger-Themen 1
L Pi berechnen Java Basics - Anfänger-Themen 1
CptK Term (als String) berechnen und ausgeben Java Basics - Anfänger-Themen 10
L Den Winkel zwischen zwei Vektoren berechnen! Java Basics - Anfänger-Themen 2
J Variablen arithmetischen Mittelwert berechnen Java Basics - Anfänger-Themen 5
K Matrixen berechnen nach Worker Master Paradigma mit Threads Java Basics - Anfänger-Themen 4
R Winkel berechnen bzw. Geraden sortieren Java Basics - Anfänger-Themen 33
I Schnittpunkt zweier Geraden berechnen Java Basics - Anfänger-Themen 25
M Erste Schritte Mittelwert berechnen -> Methode in der Methode? Java Basics - Anfänger-Themen 14
S Compiler-Fehler Schaltjahr berechnen Java Basics - Anfänger-Themen 5
B Fakultätsfunktion Rekursiv Berechnen aber mit Array Java Basics - Anfänger-Themen 10
S Durchschnitt berechnen aus zwei Textfeldern Java Basics - Anfänger-Themen 21
D Summe berechnen mit verändertem Wert aus Schleife Java Basics - Anfänger-Themen 1
R Liga Berechnen Java Basics - Anfänger-Themen 1
P Klassen Berechnen mehrerer Map-Werte Java Basics - Anfänger-Themen 13
R Fussballtabellen berechnen Java Basics - Anfänger-Themen 12
J Fibonacci -Folge rekursiv berechnen Java Basics - Anfänger-Themen 18
J Durchschnitt jeder Zeile und und Spalte in einem 2D Arrays berechnen Java Basics - Anfänger-Themen 6
F ISBN Prüfziffer berechnen Java Basics - Anfänger-Themen 17
F Die Teilersumme einer Eingabe berechnen Java Basics - Anfänger-Themen 11
S Negafibonacci Folge berechnen Java Basics - Anfänger-Themen 24

Ähnliche Java Themen

Neue Themen


Oben