# Maximum berechnen ...



## Vulymuz (12. Okt 2012)

Hallo,

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


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


----------



## ssoul26 (12. Okt 2012)

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 (12. Okt 2012)

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


----------



## bone2 (12. Okt 2012)

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_


----------



## Spacerat (12. Okt 2012)

bone2 hat gesagt.:


> 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 (12. Okt 2012)

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:


```
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
      }
    }
}
```


----------



## bone2 (12. Okt 2012)

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


```
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 (12. Okt 2012)

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!!!


----------



## ssoul26 (12. Okt 2012)

Du musst das Array so lange von Anfang durchlaufen, bis du keine indexvertauschungen mehr vorgenommen hast.


----------



## ssoul26 (12. Okt 2012)

Marco13 hat gesagt.:


> 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!!!




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.


----------



## bone2 (12. Okt 2012)

ssoul26 hat gesagt.:


> Du musst das Array so lange von Anfang durchlaufen, bis du keine indexvertauschungen mehr vorgenommen hast.


wo tauscht hier jemand was?



ssoul26 hat gesagt.:


> 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


```
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
            }
```


```
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


----------



## ssoul26 (12. Okt 2012)

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


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


----------



## Vulymuz (12. Okt 2012)

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 (12. Okt 2012)

bone2 hat gesagt.:


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


----------



## bone2 (12. Okt 2012)

Vulymuz hat gesagt.:


> Sorry, aber ich komme nicht drauf. Zum Beispiel bei der Zahlenreihe
> 89 (-> zahlen[0])
> 34 (-> zahlen[1])
> 56 (-> zahlen[2])
> ...


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.


----------



## Vulymuz (12. Okt 2012)

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


----------



## bone2 (12. Okt 2012)

```
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;
        }
```


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

```
int temp = Integer.MIN_VALUE;

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

        System.out.println("größte Zahl ist " + temp);
```


----------



## Ark (12. Okt 2012)

ssoul26 hat gesagt.:


> 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 (12. Okt 2012)

bone2 hat gesagt.:


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



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 (12. Okt 2012)

TL;DR

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


----------



## Spacerat (12. Okt 2012)

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]


----------

