Verzweifelt: Algorithmus zur Ermittlung aufeinander folgender Zahlen Array

[himitsu]

1. Variante:

* das Array Wert für Wert durchlaufen (also erstmal der Array-Anfang)
* Wenn 0 dann 0
* wenn keine 0, dann eigener Wert + äußere Werte (zwei innere Schleifen)
* * alle Nicht-Null davor, bis zum Anfang oder zur ersten nächsten 0
* * alle Nicht-Null danach, bis zum Ende oder zur ersten nächsten 0

2. Variante:

* aktuelle Position merken
* nächste 0 suchen
* dabei gleich die Summe bilden (mitzählen)
* bei allem von aktueller Position bis vor der 0 mit der der Summe befüllen
* und nun alles von vorne
* * also Position nach der 0
* * nächste 0 suchen
* * dabei gleich die Summe bilden (mitzählen)
* * bei allem von aktueller Position bis vor der 0 mit der der Summe befüllen
* * und nun alles von vorne
* * * ...

[Blup]

Noch eine Variante:

Delphi-Quellcode:

function MyArrayCalc(const AValues: TIntegerDynArray): TIntegerDynArray;
var
  i, sum: Integer;
begin
  SetLength(Result, Length(AValues));

  sum := 0;
  for i := 0 to High(AValues) do
  begin
    if AValues[i] = 0 then
      sum := 0
    else
      sum := sum + AValues[i];
 
    Result[i] := sum;
  end;

  sum := 0;
  for i := High(AValues) downto 0 do
  begin
    if AValues[i] = 0 then
      sum := 0
    else
    begin
      Result[i] := Result[i] + sum;
      sum := sum + AValues[i];
    end;
  end;
end;

[Dejan Vu]

Diese Funktion liefert die Summe für eine beliebige Position (zumindest soll sie das).

Delphi-Quellcode:

function GetConsecutiveSum(position : Integer) : Integer;
Begin
  if Values[position]=0 then begin 
     result := 0
     exit;
  end;
    
  while (position > low(Values)) and (Values[position] <> 0) do 
    dec(position);

  result := 0;
  repeat
    inc(result,values[position]);
    Inc(position);
  until (position>High(values)) or (values[position]=0);
end;

Getippt und nicht getestet.

[Blup]

Funktioniert nicht wenn du auf einer Position stehst die den Wert 0 hat und ein Wert <> 0 folgt.

[Dejan Vu]

Jetzt vielleicht?