Du verwendest einen veralteten Browser. Es ist möglich, dass diese oder andere Websites nicht korrekt angezeigt werden. Du solltest ein Upgrade durchführen oder ein alternativer Browser verwenden.
Hallo, ich suche ein kleines Programm, was eine beliebig lange Folge von ganzen Zahlen als Kommandozeilenargumente einliest. Das Programm soll in der Eingabe die zusammenhängende Folge von Zahlen finden, die addiert die größte Summe bildet.
Also z.B.:
> 1 2 -4 3 5 6 -2 3 -15 9
3 5 6 -2 3
Wäre nett, wenn mir jemand bei diesem Problem helfen könnte.
Du könntest z. B. mit zwei Schleifen alle möglichen Folgen bilden und deren Summen errechnen. Beim Durchlauf merkst du dir dann nur die Folge mit der bisher größten Summe.
Wenn in der Aufgabe "Kommandozeilenparameter" gefragt sind, dann machst Du Dir mit dem Einlesen schon zuviel Arbeit: normalerweise würde man darunter die Parameter verstehen, die der main-Methode übergeben werden. Daraus kannst Du dann ein int-Array machen:
Code:
public class Zahlenfolge {
public static void main(String[] args) {
try {
int[] nums = new int[ args.length];
for ( int i=0; i<nums.length; i++) nums[i] = Integer.parseInt( args[i]);
//--- Und jetzt zwei verschachtelte for-Schleifen: eine variiert den Start-Index der
//--- betrachteten Folge (von 0 bis (nums.length-2), die andere den End-Index (von 1
//--- bis (nums.length-1)). Mit diesen Indices wieder eine for-Schleife laufen lassen und
//--- alles aufsummieren. Wenn die Summe grösser ist als das bisherige Maximum: Folge
//--- merken
} catch ( Exception e) {
e.printStackTrace();
}
}
}
//--- Und jetzt zwei verschachtelte for-Schleifen: eine variiert den Start-Index der
//--- betrachteten Folge (von 0 bis (nums.length-2), die andere den End-Index (von 1
//--- bis (nums.length-1)). Mit diesen Indices wieder eine for-Schleife laufen lassen und
//--- alles aufsummieren. Wenn die Summe grösser ist als das bisherige Maximum: Folge
//--- merken
Auch die erste Schleife muss bis n.l-1 laufen, weil ggf. das letzte Element alleine die größte "Folge" sein kann. Die zweite Schleife startet nicht bei 1 und außerdem kann diese Schleife schon zum Aufsummieren verwendet werden.
guter Scherz, zum eigentlichen Problem schreibt du doch gar nix
wäre evtl. auch in einen Mathematik-Forum besser aufgehoben,
auf doppelte Schleifen kann man übrigens verzichten, du musst nur einmal alle Zahlen durchlaufen, etwa so:
Zahlen 1 2 -4 3 5 6 -2 3 -15 9
maximale Summe bisher: 0;
ArrayList der maximalen Summe bisher = null;
zwischensumme = 0;
zwischensummen-ArrayList = null
untersuche Zahl 1, starte neue Zwischensumme, nehme 1 auf
(in die Summe und in die Liste zum Merken aller Werte der Zwischensumme),
merke Liste mit 1 als maximale Summe bisher
untersuche Zahl 2, nehme 2 auf in aktuelle Zwischensumme auf,
merke Liste mit 1, 2 als maximale Summe bisher
untersuche Zahl -4, nehme -4 auf in aktuelle Zwischensumme auf,
aktuelle Zwischensumme damit kleiner 0,
löse aktuelle Zwischensumme auf, fahre fort
untersuche Zahl 3, starte neue Zwischensumme, nehme 3 auf,
Liste mit 3 ist eine genausogroße Liste wie bisher maximale Liste 1 und 2, was tun? muss Anwender entscheiden
untersuche Zahl 5, nehme 5 auf in aktuelle Zwischensumme auf
merke Liste mit 3, 5 als maximale Summe bisher
untersuche Zahl 6, nehme 6 auf in aktuelle Zwischensumme auf
merke Liste mit 3, 5, 6 als maximale Summe bisher
untersuche Zahl -2, nehme -2 auf in aktuelle Zwischensumme auf
Zwischensumme von 3, 5, 6, -2 noch größer als 0, ok
untersuche Zahl 3, nehme 3 auf in aktuelle Zwischensumme auf
merke Liste mit 3, 5, 6, -2, 3 als maximale Summe bisher
untersuche Zahl -15, nehme -15 auf in aktuelle Zwischensumme auf,
aktuelle Zwischensumme damit kleiner 0,
löse aktuelle Zwischensumme auf, fahre fort
untersuche Zahl 3, starte neue Zwischensumme, nehme 9 auf,
Ende, wandle ArrrayList der maximalen Summe bisher in ein int-Array oder was auch immer
ich hab jetzt mal auf konkrete Programmierung verzichtet, dann kannst du vielleicht doch noch ein wenig dabei lernen,
mit int-Werten alleine oder int-Arrays kann man nur schlecht dynamisch Listen aufbauen die immer länger werden,
deshalb schlage ich da ArrayLists vor, da man keine ints in ArrayListen reintun darf dann ersatzweise Integer-Objekte,
ansonsten ist das eigentlich nur eine Verwaltung von einigen Variablen, manche wachsen bei jedem Schleifendurchlauf oder werden wieder auf null/ 0 gesetzt, andere geben den Maximalstand wieder,
da ist dann eben ein bisschen zu basteln wie die Schleife eigentlich aussehen sollte,
viele Abfragen if (x == null), if (y < z) usw.
ist sicherlich schwieriger als der doppelte Schleifen-Ansatz, aber bei 1000 Zahlen geht das 500x schneller
----------
überlege ob die Aufgabe auch nur negative Zahlen als mögliche Eingabe vorsieht,
dann sollte das Programm später auch mit einer Liste wie "-3 -5 -17 -4" korrekt arbeiten
-> testen!
------------
Tipp: falls du ArrayLists verwendest und die maximale List durch die aktuelle ZwischenList ersetzen möchtest:
kopiere die ArrayList, nicht einfach das Objekt übernehmen, ansonsten wirken sich spätere Änderungen an der ZwischenList (als Einfügen weitere Zahlen) auch auf die MaximumList aus,
Tipp: schreib sehr viele Log-Ausgaben, etwa zu Beginn jeder Schleife,
und auch wenn du in der Schleife irgendwas tust, einfach immer ein Log dazu,
dann kannst du später einfacher überblicken was passiert ist
Code:
System.out.println("untersuche nun Zahl "+zahl);
System.out.println("maximale Summe bisher: "+..);
System.out.println("ArrayList der maximalen Summe bisher: "+..);
if (zwischenList == null) {
System.out.println("erstelle neue ZwischenList");
...
} else {
System.out.println("benutze vorhandene ZwischenList");
...
}