Ganze Zahl immer auf nächste 50 runden?

[BBoy]

Wie kann ich eine ganze Zahl auf die nächsten 50 auf oder abrunden?
zb:
1732 = 1700
1776 = 1800

Also so lange die 10er <50 wird abgerundet und wenn 10er >=50 dann aufrunden.

Ich sag schon mal Danke für eure Hilfe :thumb:

[Darlo]

ungetestet und ggf. zu kompliziert ��

Delphi-Quellcode:

if (x +49 mod 50) mod 2 = 0 then
   erg := (x +49 mod 50)*50
else
   erg := (x +49 mod 50)*50-50.

[DeddyH]

Ich verstehe das Beispiel nicht. Willst Du wirklich auf 50 runden oder doch eher auf 100?

[edit] Falls Letzteres, aus dem Hut und ungetestet:

Delphi-Quellcode:

if Zahl mod 100 < 50 then
  Zahl := Zahl div 100 * 100
else 
  Zahl := Succ(Zahl div 100) * 100;

[/edit]

[t.roller]

SetRoundMode(rmNearest);
http://docwiki.embarcadero.com/CodeE...ndMode_(Delphi)
Zwischenschritte: Div 100, Multi 100

Delphi-Quellcode:

uses ...System.Math,...

procedure TForm1.ButtonClick(Sender: TObject);
var
  OldRM: TRoundingMode;
  TestValue: Real;

  procedure RecordRound(const TextStr: String; Value: Real);
  { Calls Round() and shows its value in the Memo control.
    Affected by the value passed to SetRoundMode(). }
  var RetVal: Real;
  begin
    RetVal := Round(Value);
    Memo1.Lines.Add(Format('%-15s   RetVal=%f', [TextStr, RetVal]));
  end;

begin
  OldRM := GetRoundMode; { Save the original setting for the Round Mode }

  TestValue := 5.7;  { First test value }
  Memo1.Lines.Add(Format('Value=%f', [TestValue]));

  SetRoundMode(rmDown);
  RecordRound('rmDown #1', TestValue);

  SetRoundMode(rmUp);
  RecordRound('rmUp #2', TestValue);

  SetRoundMode(rmNearest);
  RecordRound('rmNearest #3', TestValue);

  SetRoundMode(rmTruncate);
  RecordRound('rmTruncate #4', TestValue);

  Memo1.Lines.Add('');  { Adds a blank line to the memo }

  TestValue := -1.3;   { Second test value }
  Memo1.Lines.Add(Format('Value=%f', [TestValue]));

  SetRoundMode(rmDown);
  RecordRound('rmDown #5', TestValue);

  SetRoundMode(rmUp);
  RecordRound('rmUp #6', TestValue);

  SetRoundMode(rmNearest);
  RecordRound('rmNearest #7', TestValue);

  SetRoundMode(rmTruncate);
  RecordRound('rmTruncate #8', TestValue);

  SetRoundMode(OldRM); { Restore the original Rounding Mode }
end;

[juergen]

Hallo,

in der Umsetzung aufwändig, aber das Ergebnis scheint zu stimmen : :shock:

Delphi-Quellcode:

function auf50kaufmaennisch_runden(Const Value: Integer): Integer;
Var
  i, temp: Integer;
begin
  temp := Value;
  if temp > 49 then begin
    if (StrToInt(copy(IntToStr(temp), Length(IntToStr(temp)) - 1, Length(IntToStr(temp)))) > 49) then begin
      for i := 0 to 50 do begin
        if temp mod 50 = 0 then begin
          Result := temp;
          Exit;
        end
        else Inc(temp);
      end;
    end else begin
      for i := 50 downto 0 do begin
        if temp mod 50 = 0 then begin
          Result := temp;
          Exit;
        end
        else Dec(temp);
      end;
    end;
  end
  else Result := 0;
end;

procedure TForm11.Button1Click(Sender: TObject);
begin
  showmessage(IntToStr(auf50kaufmaennisch_runden(SpinEdit1.Value)));
end;

[Benedikt Magnus]

Deine Beschreibung sagt Rundung auf hundert, das wäre dann so:

Delphi-Quellcode:

function RundenAufHundert(const Wert: Integer): Integer;
begin
  Result := Round(Wert / 100) * 100;
end;

Immer auf die vollen Fünfziger zu runden würde ich so machen:

Delphi-Quellcode:

function RundenAufFünfzig(const Wert: Integer): Integer;
begin
  Result := Round(Wert / 50) * 50;
end;

Oder allgemein:

Delphi-Quellcode:

function RundenAufZahl(const Wert, Zahl: Integer): Integer;
begin
  Result := Round(Wert / Zahl) * Zahl;
end;

[Darlo]

Zitat:

Zitat von Benedikt Magnus (Beitrag 1362734)

Deine Beschreibung sagt Rundung auf hundert, das wäre dann so:

Delphi-Quellcode:

function RundenAufHundert(const Wert: Integer): Integer;
begin
  Result := Round(Wert / 100) * 100;
end;

Immer auf die vollen Fünfziger zu runden würde ich so machen:

Delphi-Quellcode:

function RundenAufFünfzig(const Wert: Integer): Integer;
begin
  Result := Round(Wert / 50) * 50;
end;

Oder allgemein:

Delphi-Quellcode:

function RundenAufZahl(const Wert, Zahl: Integer): Integer;
begin
  Result := Round(Wert / Zahl) * Zahl;
end;

:thumb: So isses.

[Uwe Raabe]

In System.Math gibt es auch eine Funktion

Delphi-Quellcode:

RoundTo

, mit der das ebenfalls recht einfach realisiert werden kann. Runden auf ganze 100er ginge dann so:

Delphi-Quellcode:

function RundenAufHundert(const Wert: Integer): Integer;
begin
  Result := RoundTo(Wert, 2);
end;

[t.roller]

Nö: E2010 Inkompatible Typen: 'Integer' und 'Extended'

Delphi-Quellcode:

function RundenAufHundert(const Wert: Extended): Extended;
begin
  Result := RoundTo(Wert, 2);
end;

[Uwe Raabe]

Zitat:

Zitat von t.roller (Beitrag 1362737)

Nö: E2010 Inkompatible Typen: 'Integer' und 'Extended'

OK, dann eben so:

Delphi-Quellcode:

function RundenAufHundert(const Wert: Integer): Integer;
begin
  Result := Round(RoundTo(Wert, 2));
end;

[BBoy]

wooow. Vielen Dank für die vielen Antworten. Auch hier kann man mal wieder sagen: Es führen viele Wege nach Rom (bzw. zum Ergebnis).

Das Problem ist gelöst und ich habe wieder dazu gelernt. Welch ein schöner Tag :-D
Danke :thumb:

[Mikkey]

Es gibt noch eine Möglichkeit, die ohne "Round", ohne floats und ohne Abfragen auskommt:

Delphi-Quellcode:

Function MyRound(wert: Integer): Integer
begin
    result = ((wert + 50) div 100) * 100;
end;