zahlenreihe an array

[cweiss25]

Hi,
vll hat jemand eine bessere Idee:
Aufgabe ist Zahlen einzugeben - beliebig viele.
Dann übergibt man diese an ein Unterprogramm welches diese Zahlen in ein Array (Arraylänge gleich eingegebener Zahlen) einträgt und dann berechnet man etwas damit und übergibt diesen Wert wieder.

Meine Idee war bei der Eingabe der Zahlen diese in eine String Variable zu schreiben - Trennung ist ein Delimiter.
Bei der Übergabe an das Unterprogramm lese ich dann die Anzahl der Delimiter und entsprechend gross ist das Array.
Dann geh ich den String durch und trage die einzelnen Zahlen in die entsprechenden Felder ein => Berechnung => Rückgabe.

Was mir nicht gefällt ist:
Bei dieser Lösung gebe ich int-Werte ein => konvertiere in String => übergebe den String dem Unterprogramm => diese liest die einzelnen char aus => konvertiert dann wieder in int und trägt dies ins array ein. Dann berechne ich, konvertiere das ergebnis wieder in string und gebe es retour.

Dieses hin und her konviertieren ist kann nicht des rätsels lösung sein.
Hat jemand eine bessere idee?

Lg Chris

 

[Templarthelast]

Warum übergibst du nicht einfach das Array?

 

[Timothy Truckle]

Dieses hin und her konviertieren ist kann nicht des rätsels lösung sein.
Hat jemand eine bessere idee?

Wie wäre es mit einer

List<Integer>

? Da gibt es dann so schöne Methoden wie

.toArray()

.

Spoiler

(wobei ich mich frech über die Forderung nach dem Array hinweg setzten würde...)

bye
TT

 

[cweiss25]

Das Array übergeben wäre schön - aber leider nicht die Aufgabe.
Nächste Woche ist Klausur - hinwegsetzen ist leider auch nicht des Rätsels Lösung, denn wenns zur Klausur kommt ...

Werde mir dies mal anschauen
Wie wäre es mit einer List<Integer> ? Da gibt es dann so schöne Methoden wie .toArray() .

Danke

 

[Spin]

Hallo,

public int sum( int... digits) {

 int t[] = new int[digits.length]; // hier tu was damit ;) Ich habe nichts reingespeichert :P
 int total;

 for ( int i : digits) {
  total += i;
}

return total;

@TT,

Listen sind viel zu langsam und verbrauchen viel mehr Speicher. Sobald du den ersten Algorithmus geschrieben hast, wirdt du merken das man sehr schnell auf primitive Arrays zurückgreifen sollte. Ich versuche immer alles ohne listen zu bauen, solange nicht dynamisch irgendwelche Größen geändert werden sollen.

 

[Timothy Truckle]

Listen sind viel zu langsam und verbrauchen viel mehr Speicher. Sobald du den ersten Algorithmus geschrieben hast, wirdt du merken das man sehr schnell auf primitive Arrays zurückgreifen sollte. Ich versuche immer alles ohne listen zu bauen, solange nicht dynamisch irgendwelche Größen geändert werden sollen.

Ich sag nur: "premature optimization".

Listen sind einfacher in der Handhabung und besser lesbar. Das ist mir 'n paar Sekunden Rechenzeit wert. Wenn die Verzögerungen größer werden liegts idR. nicht daran, dass man Listen statt Arrays hat.

bye
TT

 

[Bleiglanz]

Listen sind viel zu langsam und verbrauchen viel mehr Speicher. Sobald du den ersten Algorithmus geschrieben hast, wirdt du merken das man sehr schnell auf primitive Arrays zurückgreifen sollte. Ich versuche immer alles ohne listen zu bauen, solange nicht dynamisch irgendwelche Größen geändert werden sollen.

Das ist sicher übertrieben. Listen sind für 99 Prozent aller Anwendungsfälle schnell genug.

Wenn ganz sicher feste Länge und ganz sicher kein Luxus aus Collections gebraucht => Array

Sonst => List, außer Performance/Speicher spielt wirklich eine Rolle - und das ist selten.

 

[Crian]

Listen sind viel zu langsam und verbrauchen viel mehr Speicher. Sobald du den ersten Algorithmus geschrieben hast, wirdt du merken das man sehr schnell auf primitive Arrays zurückgreifen sollte. Ich versuche immer alles ohne listen zu bauen, solange nicht dynamisch irgendwelche Größen geändert werden sollen.

Das ist ein Fehler. Keine Vorausoptimierung bitte, Listen sind wesentlich besser zu handhaben, sie sind Fehlerunanfälliger und bieten einen Haufen Vorteile. Optimieren bitte erst, wenn der Flaschenhals definiert ist und wirklich zu langsam ist.

Und meist bietet dann ein anderer Algorithmus eine viel bessere Möglichkeit zur Zeiteinsparung, als Arrays (bäh) statt Listen zu verwenden.

 

[cweiss25]

Hm,
ich befürchte das löst mein Problem auch nicht.
1) nicht nur ziffern, sondern Zahlen.
2) Die Eingabe soll sein:

12<enter>
14<enter>
27<enter>
....
bis eingabe n.

Dann übergabe an unterprogramm => bildet array und trägt werte ein


List<Integer> .toArray()
hab ich mir angesehen - könnte das ganze schon lösen

 

[cweiss25]

Hab es jetzt so gelöst wie mein erster Gedanke war - glaub aber nicht, dass der Algorithmus glücklich gewählt ist - da muss es doch etwas einfacheres geben (List Integer und to.array wäre eine Option - macht mich aber auch nicht ganz glücklich). ???:L

	public static void main(String[] args) 
		{	
		Scanner in = new Scanner(System.in);
		String zahlenreihe = "";
		String eingabe;
		String mittelwert;
		
		System.out.println("Eingaben Zahlenreihe - zum Beenden 'n' eingeben:");
		do 
			{
			eingabe = in.next();
			if (!"n".equals(eingabe))
				{
				zahlenreihe = zahlenreihe + eingabe + "_";
				}
			}
		while (!"n".equals(eingabe));
		
		mittelwert = mittelwert(zahlenreihe);
		System.out.println("Der Mittelwert der eingegebenen Zahlen ist: " + mittelwert);
		}
	
	
	public static String mittelwert(String zahlenreihe)
		{	
		String mittelwert = "";
		double mittelwertb = 0;
		char a;
		int arraylaenge = 0;
		int length = zahlenreihe.length();
		
	
		for (int i = 0; i < length; i++) 
			{
			a = zahlenreihe.charAt(i);
			if (a == '_')
				{
				arraylaenge = arraylaenge + 1;
				}
			}
			
		int array[] = new int[arraylaenge];
		String zahl = "";
		int j = 0;
		
		for (int i = 0; i < length; i++) 
			{
			a = zahlenreihe.charAt(i);
			if (a != '_')
				{
				zahl = zahl + a;
				}
			else
				{
				array[j] = Integer.parseInt(zahl);
				j = j + 1;
				zahl = "";
				}
			}
			
		for (int i = 0; i < array.length; i++) 
			{
			mittelwertb = mittelwertb + array[i];
			}
		
		mittelwertb = mittelwertb / array.length; 
		mittelwert = String.valueOf(mittelwertb);
		
	return mittelwert;
	}


}

 

[Olli_M]

Äh, wozu brauchst du da einen String (zahlenreihe)? Das macht es beim Zerlegen (wie Du sicher gemerkt hast) unnötig schwierig.

List <Integer> oder ArrayList <Integer> passt doch prima auf die Aufgabenstellung.
Erklär mal etwas genauer, was daran so "unglücklich machend" ist derzeit.

Olli

 

[Spin]

Hallo,

das doch nicht dein ernst ???:L

Du möchtest zahlen einlesen und dann einer Methode zum zusammenrechnen übergeben.

// main methode 


class X {
  // hier musst du eine liste nehmen, weil du nicht weisst, wieviele zahlen eingelesen werden
  private ArrayList<Integer> list = new ArrayList<Integer>

 public static void main(String[] args) {
    //Einlesen der zeilen

   while ...

   dann speichern in eine list
   list(add(zahl))

   und while end;

   dann der methode übergeben , siehe meinen ersten beitrag! 

 }

}

Du brauchst keinen Seperator definieren