# Kommandozeilenargumente einlesen



## SaltonSea (3. Dez 2005)

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. 



Gruß, SaltonSea


----------



## Murray (3. Dez 2005)

Das sieht doch sehr nach Hausaufgabe aus. Hast Du Dir schon selbst Gedanken gemacht? Was genau ist das Problem?


----------



## SaltonSea (3. Dez 2005)

Ja natürlich hab ich mir Gedanken gemacht.

So siehts bisher aus:


```
import java.io.*;
import java.util.*;

  public class Zahlenfolge {
	
		public static void main(String[] args) throws Exception {
			
		String Eingabe= "1";	
			
		BufferedReader Tastatur;
		
		Tastatur = new BufferedReader(new InputStreamReader(System.in));
		
			Eingabe = Tastatur.readLine();
		 //	System.out.println(Eingabe);
					
			
		}// Ende main	


	
  } //Ende class
```

Also Zahlen kann ich jetzt beliebig viele eingeben, aber wie findet man die zusammenhängende Folge von Zahlen, die addiert die größte Summe ergeben?


----------



## messi (3. Dez 2005)

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.


----------



## Murray (3. Dez 2005)

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:

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


   
 }
```


----------



## messi (3. Dez 2005)

Murray hat gesagt.:
			
		

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


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.


----------



## SlaterB (3. Dez 2005)

> Ja natürlich hab ich mir Gedanken gemacht.


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


```
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");
   ...
}
```


----------



## bygones (3. Dez 2005)

der effiziente Algorithmus ist wie oben beschrieben ein einfacher scan, der einmal über die Daten geht.

du kannst dir das ganze mal als diagramm aufzeichnen und den summenverlauf eintragen, dann erkennt man schön, wie der Algorithmus läuft


----------

