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:
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.
 
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...
 
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
 
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.
 
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
      }
    }
}
 
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
 
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!!!
 
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:
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]; 
} 
}
 
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 ... -_-
 
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. 😉
 
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:
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:
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
 
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.
 
TL;DR

Hatte schon jemand erwähnt, dass der Durchschnitt nicht richtig berechnet wird, da Summe und Anzahl beides int sind?
 
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]
 

Zurück
Oben