Function vereinfachen, bei vielen if abfragen

[Hallo_Thomas]

Gibt für so eine function eine einfachere, bzw, schnellere Abfrage!Im Grundegenommen soll bloss eine bestimmte Additionsaufgabe zu einem bestimmten Wert ausgeführt werden.

Delphi-Quellcode:

function zaehler(z:Integer):Integer;
begin
if z=0 then
result:=x+y+z
if z=1 then
result:=x+y
....///////dass sollte dann so bis if z=1500 then gehen
end;

[jim_raynor]

spannend ist die Frage was denn bei z=2, z=3 usw. passiert. das wird bei deinem Quellcode nicht ersichtlicht. Auf jeden Fall wäre case eine vernüftige Variante.

[nailor]

ich weiß wirklich nicht, was genau du willst. aber vielleicht wäre es sinnvoll, sich mal die case-anweisung anzuschauen.

edit:mal wieder viiiiieeel zu langsam

[Christian Seehase]

Moin Thomas,

Zitat:

Zitat von Hallo_Thomas

...soll bloss eine bestimmte Additionsaufgabe zu einem bestimmten Wert ausgeführt werden.

wie sieht denn die Aufgabe aus?
Vielleicht lässt sie sich ja einfacher lösen.

[runger]

Hallo,

ich will ja nicht stänkern aber du stellst eine Frage die Hellseherei verlangt. Ist es eigentlich zuviel verlangt, dass man bevor man eine Frage stellt, etwas nachdenkt?
So kriegst du auf jedenfall keine Antwort.

Rainer

[Hallo_Thomas]

Ich wollte eine Art function geschreiben, die wesentlichen eine Aufgabe haben soll,und zwar: Dass es zu jedem Wert,sagen wir Wertigkeit[0..1500] jeweils einein Wert(hier(Z)) gibt, der nach bedarf aufgerufen werden ( Dies soll ne Additionsaufgabe sein).

Delphi-Quellcode:

function zaehler(z:Integer):Integer; 
begin 
if z=0 then 
result:=x+y+z 
if z=1 then 
result:=x+y
if z=2 then 
result:=x+y+a
....///////dass sollte dann so bis if z=1500 then gehen 
end;

[marabu]

nu iss alles glar.

Nur mir nicht. Wenn du keine Regel angeben kannst, nach der deine Additionen ausgeführt werden sollen, dann wirst du alle 1500 Fälle einzeln beschreiben müssen - vielleicht erkennt dann jemand die Systematik. Ansonsten bleibt es beim CASE-Statement.

marabu

[Hallo_Thomas]

Es gibt keine Sytetemathik, ich muss auf alle Fälle, 1500 mal Result:=..+.+.+.. schreiben, die Variblen aus em sich Result ergibt, stehen unter private

Zitat:

Ich dachte an so ne Art Zusammenfassung, wo ich nicht 1500 if abfrageb hab.

Result:= nimm wert[1]

Wert[0]:=x+y+z
Wert[1]:=z+y

In diesem Moment beötige ich auch nur Wert[1]

In einem Procedurdurchlauf, soll dann auf 10-50 Werte zurückgefriffen werden.

[Jasocul]

Keine Systematik => keine Vereinfachung.

[TeronG]

Zitat:

Zitat von Jasocul

Keine Systematik => keine Vereinfachung.

YUP
Aber die oben genannte CASE-anweisung macht das dennoch sauberer denk ich :gruebel: (auch weil ELSE vorhanden)

[Jasocul]

War case nicht auf 256 Fälle beschränkt?

[Thanatos81]

Kann ich in der OH keinen Hinweis drauf entdecken, aber selbst wenn, dann setzt er halt 6 case-Anweisungen nacheinander. Ist immer noch übersichtlicher/kürzer als 1500 if-then-Abfragen :roll:

[Jasocul]

Habe gerade nochmal nachgesehen. Es muss lediglich ein Ordinaltyp sein (Integer geht z.B. auch).
Die Info mit den 256 Fällen ist vermutlich noch aus Turbo-Pascal-Zeiten. Sorry. (Ja, ja. Das Alter)

[r2c2]

Aus performance-Gründen würde ich aber noch 1500 else mehr schreiben:

Delphi-Quellcode:

if z=0 then
  Result := ...
else if z=1 then
  Result := ...
else if ...

Das macht bei 1500 Abfragen schon was aus. Ansonsten: Ohne Systematik is das wohl nicht einfacher zu machen...

mfg

Christian

//Edit: Da sich das mit den 256 Fällen ja erledigt hat is Case die bessere Lösung, sollte eigentlich auch etwas schneller sein.

[Jasocul]

Sicher, dass die Performance besser ist? Ich war bisher der Meinung, dass "Case" genau so arbeitet.

[r2c2]

Zitat:

Zitat von Jasocul

Sicher, dass die Performance besser ist? Ich war bisher der Meinung, dass "Case" genau so arbeitet.

IMHO geht Case die Werte in ner Schleife durch(warum sollte dann auch sonst ein Ordinaltyp vorausgesetzt werden?). Case is dann wahrscheinlich in der Hinsicht irgendwie optimiert. Ansonsten wär das mit den Ordinaltyp ja Blödsinn.

mfg

Christian

[DerDan]

Ich hab mal nachgesehen,

bei einer Case Anweisung mit lediglich 9 [0..8] aufeinanderfolgenden Werten wird bereits eine Sprungtabelle angelegt. Das heist es wird quasi berechnet an welche Stelle das Programm verzweigt.

Effizienter geht das nicht mehr.

das das in einer Schleife abgearbeitet wird oder in eine "if then else" orgie aufgedröselt wird stimmt nicht.


derDan

[marabu]

Und dazu noch das hier: Compiler-Verhalten bei case statements

marabu

[Jasocul]

Klasse Link. Danke marabu. Jetzt bin ich mal wieder auf einem aktuellen Stand.
Damals, anno dingens, da war das alles noch anders. :lol:

[DerDan]

@Jasocul

Nicht ist so beständig wie die Änderung!

[runger]

Hallo,

kann man das Ergebnis irgendwie mathematisch erfassen?
z.B. result:=a+y+z
wobei wenn ich z nicht haben will z einfach null gesetzt wird?

Rainer

[Matthias-k]

case und if combinieren, abschnitte machen:

[delphi]
if a >=0 and <100 then
begin
case ...
case ...
//bis case varaible = 100
end;

if a>99 and <200 then
begin
case ...
case ...
//bis case variable = 200
end;

zumindest wird die procedure dadurch ein wenig schneller!

schreiben musst du den mist trotzdem!

(wobei mir immernoch ne klar is, was du wirklich machen willst)

aber leb ruhig damit, 1500 zeilen mist zu schreiben! :wall:

matthias

[r2c2]

Zitat:

Zitat von Matthias-k

case und if combinieren, abschnitte machen:

Warum jetzt schon wieder kombinieren? Und warum ohne else beim if? :gruebel:
Ich dachte wir hätten geklärt, dass es mit nem langen case geht. Oder hab ich da was verpasst? Und warum soll das ganze schneller sein?

mfg

Christian

[Jasocul]

Sein Gedanke war wohl, dass dann die schnelleren Sprungtabellen erzeugt werden.

[Hallo_Thomas]

@r2c2 frag mal runger oder Matthias-k

Ich finds erst mah ne tolle Idee mit dem Case of, Dankeschön Thomas

[Hallo_Thomas]

noch mah ne kleene Frage

Delphi-Quellcode:

function zaehler(z:Integer):Integer;
var x  :Integer;
begin

  case z of
for x:=0 to 144 do
    x : begin
      Result := Zaehler[x]
    end;

Kann ich diese Case of ANweisung mit soner Schleife combinieren ohne alle 144 Werte auszuschreiben?

[r2c2]

@Jasocul
:idea: Ah! Jetzt hab ichs kapiert!


@Hallo_Thomas

Zitat:

Zitat von Hallo_Thomas

noch mah ne kleene Frage

Delphi-Quellcode:

function zaehler(z:Integer):Integer;
var x  :Integer;
begin

  case z of
for x:=0 to 144 do
    x : begin
      Result := Zaehler[x]
    end;

Kann ich diese Case of ANweisung mit soner Schleife combinieren ohne alle 144 Werte auszuschreiben?

lol... Ne, so nicht, aber, dann setzt du ja voraus, dass es n mathematischen zusammenhang zwischen z und den Summanden gibt. Dann kann man das seeeehr vereinfachen:

Delphi-Quellcode:

Result := <mathematischer Zusammenhang>;

z.B.:

Result := z*2+(z-4);

mfg

Christian

[Hallo_Thomas]

[/quote]r2c2

Delphi-Quellcode:

Result := z*2+(z-4);

Wie komme ich da, an den Wert des Zaehlers?

[Jasocul]

Ich verstehe es noch nicht. Zaehler ist bei dir eine Funktion und du übergist and die Funktion "z". Welchen Wert des Zaehler (der ja dein Funktions-Bezeichner ist) willst du denn in Erfahrung bringen?
Vielleicht habe ich ja auch ein Brett vor dem Kopp.

[r2c2]

Zitat:

Zitat von Hallo_Thomas

Wie komme ich da, an den Wert des Zaehlers?

Welcher Zähler? Du prüfst bei deinem Pseudo-Code doch nur, welchen Wert z hat. Wenn der 1 ist(d.h. deine Pseudo-Schleife bis1 gezählt hat), ist x=z(das fragst du ja bei deinem Pseudo-case ab).

Wenn das wirklich so ist, d.h., wenn du das wirklich so gemeit hast, kannst du dir 1499 Zeilen sparen!

mfg

Christian

//Edit: Schon wieder 2 min. zu spät! :?

[Hallo_Thomas]

@r2c2 Das dient ja erst mal als, und soll mir nach möglichkeit eine zusammenfassung von verschieden Rechnungen erleichtern

Delphi-Quellcode:

private
{ Private-Deklarationen }
Zaehler            : array[0..144] of Integer;

Verwirrt vieleicht etwas, die ähnlichen Namen
Dem Zähler wird schon in einer übergeordneteten Procedure bestimmt.

Delphi-Quellcode:

function zaehler(z:Integer):Integer; 
var x  :Integer; 
begin 

  case z of 
for x:=0 to 144 do 
    x : begin 
      Result := Zaehler[x] 
    end;
end;

Kann ich diese Case of Anweisung mit so ner Schleife combinieren ohne alle 144 Werte auszuschreiben? bzw.welche möglichkeit gibts sonst den Text zu kürzen

[Jasocul]

Mich wundert es, dass man das überhaupt compilieren kann.
Dein Case geht dann so:

Delphi-Quellcode:

 case z of
   0..144: Result := Zaehler[x]
 end;

Oder so ähnlich, da du ja keine Rechenoperationen mit x machst. Erschließt sich mir noch nicht der Sinn.
Wesentlich scheint aber in diesem Fall zu sein, dass du in einem Case auch Bereiche angeben kannst (s.o.).

[Hallo_Thomas]

Jetzt fällt mir doch klatt die Lösung ein, Dem Anfänger seis verziehen.

Delphi-Quellcode:

case z of 
   0..144: Result := Zaehler[z] 
end;

is datt nett simple und einfach? Ich danke allen der Antwortfindung!