C# Berechnung mit Array-Elementen

[shortstory]

Hallo und gleich mal vorne weg: Ich bin Anfänger :-)

Ich zerbreche mir schon ziemlich lange den Kopf über folgende Problematik:

1) Ich habe ein Array_A mit 20 Elementen

2) Es folgt ein Array_B mit 19 Elementen, die ich aus den Elementen des ersten Arrays berechnen lasse und zwar mit einer for-Schleife nach folgendem Ablauf:

Das erste Element aus Array_B wird aus der Differenz vom ersten und zweiten Element aus
Array_A berechnet.

usw.

Wie kann ich nun das letzte Element aus Array_B berechnen? Ich stoße hierbei immer auf das Problem, dass die for-Schleife außerhalb des Array-Bereiches von Array_B liegt:

for (int i = 1; i < Array_A.Length; i++)
{
Array_B = Array_A - Array_A[i+1]);
}


Ich hoffe ich konnte das Problem verständlich machen und freu mich schon auf konstruktive Hilfe.

 

[darkarchon]

for(int i = 0;i<Array_A.length-1;i++) {
Array_B[i] = Array_A[i] - Array_A[i+1];
}

 

[sasdensas]

Der Index des ersten Elements ist 0

Element: 1 | 2 | ... | x
Index__: 0 | 1 | ... | x-1

 

[Bagbag]

Dein Array_A hat 20 Elemente, also ist Length = 20.

for (int i = 1; i < Array_A.Length; i++)
-> irgendwann ist i = 19.
-> Array_B = Array_A - Array_A[i+1]);
19+ 1 ist aber 20, also außerhalb des Bereiches (0 - 19).

Da du für jedes Element in Array_B, die Differenz von Array_A und Array_A[i+1] berechnen willst, und Array_A 1 Element mehr hat, nimmst du am besten einfach

for (int i = 1; i < Array_B.Length; i++)



Und dann noch etwas schönes, sofern du mit Visual Studio arbeitest.

Visual Studio hat einen sehr guten Debugger, womit man das ganze hätte Schritt für Schritt durchlaufen lassen und dann wärst du selbst darauf gekommen. Google am besten mal danach.

 

[shortstory]

Ok super vielen Dank schon mal… jetzt geht das Spielchen aber weiter und zwar:

Die Aufgabe besteht darin die Steigerungsraten zwischen jeweils 2 Elementen double Arrays "werte_ar"
(diese hat 20 Elemente, also Indexe von 0 bis 19) zu berechnen und ich mache das bis jetzt so, indem
ich für diese zu berechnenden Werte ein neues Array sr_jahre_array anlege:


double[]sr_jahre_ar = new double [20];

for (int i = 1; i < werte_ar.Length; i++)
{
sr_jahre_ar[i-1] = Math.Round(((jahreswerte_ar - werte_ar[i-1])/werte_ar[i-1])*100,2);
}



Klappt prima, allerdings fehlt mir noch die Steigerungsrate vom 19. zum 20. Element des werte_ar Arrays.

Was tun?

 

[Bagbag]

for (int i = 1; i < werte_ar.Length; i++)
->
for (int i = 0; i < werte_ar.Length; i++)

Du beginnst bei Index 1, deshalb wird das erste weggelassen.

 

[shortstory]

Hab ich mir auch schon gedacht, aber leider führt das dann aber dazu, dass ich ja bei meiner Berechnung außerhalb des Arrays liege, wegen i-1 und ich brauche ja werte_ar[i-1] für die Formel…

 

[darkarchon]

Dann machst du werte_ar.Length-1, wie ich im ersten Post bereits beschrieben habe. Hättest du den gelesen hättest du das gesehen…

 

[Smagjus]

Ich weiß nicht, ob dir diese Problematik bewusst ist, aber bei den Differenzen von 20 Elementen bekommst du 19 Ergebnisse. Oder bekommst du nur 18 Ergebnisse in dein zweites Array?

 

[shortstory]

Genau ich bekomme leider nur 18 Ergebnisse…

@ darkarchon: Bin immer noch außerhalb des Array-Bereiches, auch wenn ich es so mache:

double[]sr_jahre_ar = new double [20];

for (int i = 0; i < werte_ar.Length-1; i++)
{
sr_jahre_ar[i-1] = Math.Round(((jahreswerte_ar - werte_ar[i-1])/werte_ar[i-1])*100,2);
}

 

[Bagbag]

Und was ist in dem Array "jahreswerte_ar"?

Mal abgesehen davon, deine Variablen haben (meiner Meinung nach) schlechte Namen.

 

[simpsonsfan]

Dein Array sr_jahre_ar fängt ja auch nicht bei [-1] an.
Kleiner Tipp: betrachte doch deine Schleife einmal für den jeweils ersten und letzten Wert, im letzten Beispiel für i=0 und i=18.

 

[darkarchon]

sr_jahre_ar[i-1]

Wenn du bei i=0 anfängst kann das nicht funktionieren. Hättest du das 1:1 so gemacht wie ichs geschrieben habe würde das wunderbar funktionieren.

 

[shortstory]

@ darkarchon: ich muss ja aber bei i=1 anfangen, denn sonst kann ich in der Formel nicht werte_ar[i-1]
ansprechen:

sr_jahre_ar[i-1] = Math.Round(((jahreswerte_ar - werte_ar[i-1])/werte_ar[i-1])*100,2);


@ Bagbag: in jahreswerte_ar liegen die 20 Werte, die ich zur Berechnung von der Steigerungswerte benutze. Sorry ich hab es jetzt mal angepasst…


@ simpsonsfan: genau. deshalb hatte ich ja die schleife bei i = 1 angefangen, damit ich dann
bei der berechnung für den ersten wert von sr_jahre_ar auf das element werte_ar[i-1] zugreifen kann:

for (int i = 1; i < jahreswerte_ar.Length; i++)
{
sr_jahre_ar[i-1] = Math.Round(((jahreswerte_ar - werte_ar[i-1])/werte_ar[i-1])*100,2);
}

 

[simpsonsfan]

Und wie man erkennt, ist der letzte Wert, der hier gefüllt wird (solange nämlich i=19 ist, also i<jahreswerte_ar.Length=20) dieser:

sr_jahre_ar[18] = Math.Round(((jahreswerte_ar[19] - werte_ar[18])/werte_ar[18])*100,2);

Edit: jetzt bin ich auch wieder drausgekommen, egal, betrachte am besten noch mal die Längen aller Arrays und was von wo bis wo läuft.

 

[darkarchon]

for (int i = 0; i < jahreswerte_ar.Length-1; i++)
{
sr_jahre_ar = Math.Round(((jahreswerte_ar[i+1] - werte_ar)/werte_ar)*100,2);
}

Gibt für i<jahreswerte_ar.Length-1 (i = 18) folgendes

sr_jahre_ar[18] = Math.Round(((jahreswerte_ar[19] - werte_ar[18])/werte_ar[18])*100,2);

sr_jahre_ar[18] ist das Maximum für ein Array mit 19 Stellen!
jahreswerte_ar[19] das Maximum für ein Array mit 20 Stellen!

 

[F_GXdx]

Sorry aber du musst strukturierter Denken. Zur Not auch mal Papier und Bleistift nehmen, und wenn es dann nicht funktioniert mit dem Debugger arbeiten, sonst wird das nichts.

Ein Programmierer geht so vor:
1) Überlegen was man überhaupt machen will
2) Mathematisches Modell anlegen
3) In das Modell Zusicherungen einbauen, die man im Code wiederfinden kann
4) Korrektheit überprüfen
5) Code optimieren
6) Korrektheit überprüfen

Wenn du also arrays hast, dann mach doch in Gottes Namen eine Zugriffsvariable und setz einen Breakpoint im Debugger. Du weißt dann, dass die Variable von 0 bis 19 gehen soll bis die Schleife fertig ist für ein Array mit 20 Elementen. Das schaust du dir halt an. Dabei ist es egal, wie die Schleife läuft und wo irgendwo noch "-1" steht, zum Zeitpunkt des Array-Zugriffs darf sie halt die Zusicherung "Wert zwischen einschließlich 0 und 19" nicht verletzen.

Also

for (int i ... {
int j = ... // aktuelle berechnung des index von 0 bis 19; hier den Breakpoint setzen
array[j] // jetzt array zugriff
}