Positive Zahlen in negative umwandeln

[Khabarakh]

Zitat:

Zitat von alzaimar

Ich brech mir hier einen ab, poste eine endgeniale rekursive Lösung für das vermutlich NP-Komplette Problem der Zahlennegierung, [...]

Keine Tail Recursion (auf die deutsche Übersetzung verzichte ich mal)? Also bitte.

Delphi-Quellcode:

function MakeNegative(const aNumber: Integer): Integer;
  function Loop(const aNumber: Integer; const aContinuation: TFunc<Integer, Integer>): Integer;
  begin
    if aNumber > 0 then
      Result := Loop(aNumber-1, 
        function(X: Integer): Integer
        begin
          Result := aContinuation(Result-1);
        end)
  else
    Result := aContinuation(0);
  end;
  Result := Loop(aNumber,
    function(X: Integer): Integer
    begin
       Result := X;
    end);
end;

[Reinhardtinho]

Ich musste bei dem Thread gleich an den Comic hier denken http://xkcd.com/221/.

Deshalb mein Vorschlag (garantiert negativ!):

Delphi-Quellcode:

  function Negate: Integer;
begin
  Result := -4;
end;

Selten so ein tolles Topic gehabt :cheers:

[Die Muhkuh]

#81: Hä? :gruebel:

:mrgreen:

[Teekeks]

aber wie zu allen themen: die antwort lautet 42! Die zahl muss also 42mal minus 42 genommen werden. den sie dann immernoch >0 ist dan nochmal
also:

Delphi-Quellcode:

function negation(zahl, diezahl:integer):integer;
//macht aus JEDER zahl eine Negative ^^
goto 1;  //da ich noch nie GOTO´s angewendet habe vermute ich einfach mal das die hier deklariert werden
i, x:integer;
begin
  diezahl:=42; //damit kann ausgeschlossen werden das unwissende etwas anderes angeben!
1:for i:=0 to diezahl do
    for x:=0 to diezahl do
      zahl:=zahl-diezahl;
  if zahl>=0 then goto 1;
end;

damit dürfte IMMER etwas negatives rauskommen auch wenn man eine noch so hohe zahl nimmt! :lol:

[Sven M.]

Macht's euch doch nicht so schwierig...

Delphi-Quellcode:

if zahl<=0 then
begin
  for i:=1 to zahl do
    begin
      dec(zahl);
    end;
end;

[DeddyH]

Kann das sein, dass dieser Code gar nichts macht? :-D

[Sven M.]

Na doch...wenn es eine negative Zahl ist, dann wird sie quasi mit zwei multipliziert...:P

Aber um mal wieder ein bisschen Ernst in die Sache zu bringen:

Delphi-Quellcode:

if zahl>0 then 
begin 
  for i:=1 to zahl+1 do 
    begin 
      dec(zahl); 
    end; 
end;

[Neutral General]

Zitat:

Zitat von Sven M.

Macht's euch doch nicht so schwierig...

Delphi-Quellcode:

if zahl<=0 then
begin
  for i:=1 to zahl do
    begin
      dec(zahl);
    end;
end;

Deine Methode macht eine negative Zahl nur noch negativer. Wenn schon, dann musst du auf > 0 prüfen und dann eine Schleife von 1 bis 2*zahl laufen lassen :P

[DeddyH]

Zitat:

Delphi-Quellcode:

for i:=1 to zahl do

Was passiert hier wohl, wenn zahl negativ ist?

[Sven M.]

....hab's doch oben schon berichtigt...;)

[DeddyH]

Stimmt aber immer noch nicht, wie Neutral General bereits bemerkte ;)

[Neutral General]

Zitat:

Zitat von Sven M.

....hab's doch oben schon berichtigt...;)

Es ist aber immernoch falsch :mrgreen:

[grizzly]

Das hier macht sogar die 0 negativ ;)

Delphi-Quellcode:

FUNCTION Negativator(e: extended): extended;
BEGIN
  pbyteArray(@e)^[9] := pbyteArray(@e)^[9] or $80;
  Result := e;
END;

procedure TForm1.Button1Click(Sender: TObject);
var
  st : string;
begin
  Str(Negativator(42), st);       // st = '-4.20000000000000E+0001'
  Str(Negativator( 0), st);       // st = '-0.00000000000000E+0000'
  Str(Negativator(Infinity), st); // st = '                   -Inf'
end;

(Für "Infinity" müßt ihr die Math Unit einbinden).

Gruß
Michael

[Reinhardtinho]

Zitat:

Zitat von grizzly

Das hier macht sogar die 0 negativ ;)

:shock:

[Sven M.]

@Deddy und General...
War denn irgendwo gesagt, dass die Zahl "invertiert" sein muss? Nö! :P

Aber um euch zufriedenzustellen...;)

Delphi-Quellcode:

if zahl>0 then 
begin 
  for i:=1 to ((zahl*2)+1) do 
    begin 
      dec(zahl); 
    end; 
end;

[DeddyH]

Da dürfte meins performanter sein :mrgreen: (obwohl das auch vollkommener Quatsch ist, war ja Sinn oder besser Unsinn der Sache).

[Luckie]

Ich verschiebe das ganze jetzt einfach mal nach....? Gibt es hier eine Sparte "Quellcode den die Welt nicht braucht"? Jedensfalls Multimedia ist es nicht.

[Larsi]

Wie wärs denn mit Mülleimer oder du splittest den Thread nachdem die erste wertvolle Antwort kam und tust den Rest weg oder schiebst in in K&T.

[Tyrael Y.]

Ne das gehört in "Programmieren allgemein"...es zeigt sehr anschaulich, daß es für eine simples Problem sehr viele Wege geben kann ;)

[DeddyH]

"Threads, die die Welt nicht braucht" oder "Kollektiver Wahnsinn" fände ich angebrachter :mrgreen:

[divBy0]

Zitat:

Zitat von DeddyH

"Threads, die die Welt nicht braucht" oder "Kollektiver Wahnsinn" fände ich angebrachter :mrgreen:

Kollektiver Wahnsinn finde ich gut... :-D

Vielleicht können wir ja die Lazarus-Sparte umbenennen... :duck:

[Sir Rufo]

@luckie: das gehört eindeutig in die CodeLib :mrgreen:

cu

Oliver

[hathor]

Zitat:

Zitat von Sir Rufo

@luckie: das gehört eindeutig in die CodeLib :mrgreen:

cu

Oliver

Genau - und zwar Folgendes:

Um noch eine sinnvolle (und universelle) Antwort zu bringen:

Delphi-Quellcode:

var zahl : currency;

Zahl:= 3.14; // oder sonst was
Zahl := -abs(Zahl);
Memo1.lines.Add(Format('Zahl: %.2f ', [Zahl]));

[Matze]

Ich hoffe, das meinst du nicht ernst. ;)

und @Manu: Nein, den Source bekommst du nicht. *g*

Edit: Falscher Smiley.

[Missionar]

Gibt es da nicht etwas Performanteres, wie z. B.

Delphi-Quellcode:

procedure NEG(VAR Int: Integer);
assembler
  neg ACX;
end;

[jfheins]

Nein, das skaliert ja mindestens linear also O(n)

Matzes Texterkennungssoftware macht das ja sogar für beliebig viele Zahlen inm konstanter Zeit! O(1) :mrgreen:

P.S. Es geht bereits seit 6,5 Seiten nicht mehr um performante Lösungen ;)

[gammatester]

Vielleicht auch ActiveX (Excel oä). Performant wäre auch irgendwas mit inline.

[Missionar]

Dann müsste Mann es eben noch ausbauen. Vielleicht neben Integer noch, Real, Float, Double, Extended, BCD, Boolean, String, Negation von Klassen und von Pointern :shock:

[Die Muhkuh]

Zitat:

Zitat von Missionar

Negation von Klassen und von Pointern :shock:

Das ist was fürn Neutral General :zwinker:

[sirius]

Da das hier ein rein mathematisches Problem ist, muss man das auch so lösen.
Der Ansatz ist recht simpel. Man negiert eine reelle Zahl indem man sie ins Komplexe überführt und dort mit e^(i*pi) multipliziert. Das klingt jetzt etwas kompliziert, aber wenn man die eulersche Darstellung nimmt, reciht es die Phase mit pi zu summieren.

Delphi-Quellcode:

procedure TForm1.NegButtonClick(Sender: TObject);
var Kart:IKart;
    Euler:IEuler;
begin
  //Vorbereitung
  Kart:=TComplex.create as IKart;
  Kart.Imag:=0;
  Kart.Real:=StrToFloat(Eingabe.Text);
  Euler:=Kart as IEuler;

  //Negation
  Euler.Phase:=Euler.Phase+pi;

  //Ergebnis
  Ausgabe.Caption:=FloatToStr(Kart.Real);

end;

Die beiden Interfaces sehen so aus:

Delphi-Quellcode:

type
  IEuler=Interface
    ['{5EBED258-ACED-4D74-AB9D-C7048887343A}']
    procedure setPhase(value:Double);
    procedure setBetrag(value:Double);
    function getPhase:Double;
    function getBetrag:Double;
    property Phase:Double read getPhase write setPhase;
    property Betrag:Double read getBetrag write setBetrag;
  end;

  IKart=Interface
    ['{93216A14-7CB0-4377-B844-793511F3C24F}']
    procedure setReal(value:double);
    procedure setImag(value:Double);
    function getReal:Double;
    function getImag:Double;
    property Real:Double read getReal write setReal;
    property Imag:Double read getImag write setImag;
  end;

Und die Klasse dazu:

Delphi-Quellcode:

interface

type  
  TComplex=class(TInterfacedObject,IKart,IEuler)
    Constructor Create;
   private
    FReal,FImag:Double;
    FBetrag,FPhase:Double;
    procedure setReal(value:double);
    procedure setImag(value:Double);
    procedure setPhase(value:Double);
    procedure setBetrag(value:Double);

    function getReal:Double;
    function getImag:Double;
    function getPhase:Double;
    function getBetrag:Double;

    procedure Euler2Kart;
    procedure Kart2Euler;
   end;



implementation

{ TComplex }

constructor TComplex.Create;
begin
  FReal:=0;
  FImag:=0;
  FBetrag:=0;
  FPhase:=0;
end;

procedure TComplex.Euler2Kart;
begin
  FReal:=cos(FPhase)*FBetrag;
  FImag:=sin(FPhase)*FBetrag;
end;

function TComplex.getBetrag: Double;
begin
  result:=FBetrag;
end;

function TComplex.getImag: Double;
begin
  result:=FImag;
end;

function TComplex.getPhase: Double;
begin
  result:=FPhase;
end;

function TComplex.getReal: Double;
begin
  result:=FReal;
end;

procedure TComplex.Kart2Euler;
begin
  FBetrag:=sqrt(sqr(FReal)+sqr(FImag));
  asm
    MOV EAX, Self
    FLD QWORD PTR [EAX].FImag
    FLD QWORD PTR [EAX].FReal
    FPATAN
    FWAIT
    FST QWORD PTR [EAX].FPhase
  end;
  if FPhase<0 then FPhase:=FPhase+2*pi;
end;

procedure TComplex.setBetrag(value: Double);
begin
  FBetrag:=value;
  Euler2Kart;
end;

procedure TComplex.setImag(value: Double);
begin
  FImag:=value;
  Kart2Euler;
end;

procedure TComplex.setPhase(value: Double);
begin
  while value<0 do Value:=Value+2*pi;
  while value>=2*pi do Value:=Value-2*pi;
  FPhase:=Value;
  Euler2Kart;
end;

procedure TComplex.setReal(value: double);
begin
  FReal:=value;
  Kart2Euler;
end;

Achja: Für den Arctan musste ich mal kurz auf Assembler zurückgreifen (wegen FPATAN)

[hathor]

WIR SOLLTEN FÜR DIESEN THREAD EIN NEUES FORUM GRÜNDEN UND JÄHRLICH EINEN PREIS VERGEBEN:

- Vorschläge für Namen, Konventionen, AGB willkommen!

[Hador]

Zitat:

Zitat von Missionar

Gibt es da nicht etwas Performanteres, wie z. B.

Delphi-Quellcode:

procedure NEG(VAR Int: Integer);
assembler
  neg ACX;
end;

Wenn schon ASM, dann aber auch richtig. Bei folgender Funktion kommt immer eine negative Zahl heraus.
Das ganze ist natürlich hochoptimiert :mrgreen:

Delphi-Quellcode:

function Neg(i: Integer): Integer;
asm
  MOV EDX, EAX
  NEG EDX
  CMP EDX, EAX
  JAE @DUMDIDUM
  NEG EAX
  @DUMDIDUM:
    MOV EDX, EAX
    INC EAX
  @WUPPDI:
    DEC EAX
    MOV ECX, EAX
    NEG ECX
    CMP ECX, EDX
    JNE @WUPPDI
  @DIDUMDI:
    NOP
end;

[markusj]

Zitat:

Zitat von Larsi

Wie wärs denn mit Mülleimer oder du splittest den Thread nachdem die erste wertvolle Antwort kam und tust den Rest weg oder schiebst in in K&T.

Ich wär mit so einer Aussage vorsichtig ... wenn du mich fragst, sollte man deinen "Beitrag" zum Thread rausnehmen und den Rest als Lehrbeispiel für a) Viele Wege führn nach Rom und b) Es geht immer komplizierter stehen lassen.
Im Gegensatz zu den meisten deiner Posts hat das ganze hier irgend einen Sinn - Du hast die meisten deiner 1,5k Posts dadurch generiert, dass du die Suchfunktion und Google (sowie den normalen Verstand und etwas Kreativität) übergangen hast. Fast alles hätte man mit entsprechender Eigeninitiative selbst herausfinden können!
Richtig interessant wird das natürlich dadurch, dass du andere für GLEICHES Verhalten kritisierst/tadelst.

Und jetzt raus aus diesem durchgeknallten Thread *waaaah*

mfG
Markus

[Sherlock]

Die Kategorie könnte auch "Bewusstseinserweiterndes" heissen.

Sherlock

[kalmi01]

Wie wärs mit Durchgknalltes ?

Und 1x im Jahr gibts dann einen Contest, so wie bei den C-Programmierern.

[sirius]

Zitat:

Zitat von kalmi01

Wie wärs mit Durchgknalltes ?

Und 1x im Jahr gibts dann einen Contest, so wie bei den C-Programmierern.

Was ist denn das für ein Contest? Etwa: "Wer bekommt eine komplette Datenbankanwendung in eine Zeile?"

[divBy0]

Zitat:

Zitat von sirius

Zitat:

Zitat von kalmi01

Wie wärs mit Durchgknalltes ?

Und 1x im Jahr gibts dann einen Contest, so wie bei den C-Programmierern.

Was ist denn das für ein Contest? Etwa: "Wer bekommt eine komplette Datenbankanwendung in eine Zeile?"

Wenn die Zeile lang genug ist... :-D :-D :-D

[sirius]

Zitat:

Zitat von divBy0

Wenn die Zeile lang genug ist... :-D :-D :-D

Ich meinte "eine Zeile" == "ein Befehl"

[Tyrael Y.]

Zitat:

Zitat von sirius

Zitat:

Zitat von divBy0

Wenn die Zeile lang genug ist... :-D :-D :-D

Ich meinte "eine Zeile" == "ein Befehl"

Delphi-Quellcode:

Application.Run();

;)

[turboPASCAL]

@Hador, ich kenn mich nicht so aus mit Assembler.
Deswegen tüttel ich's mal nach Delphi, mit kleinen Änderungen um.

Delphi-Quellcode:

function Neg(EAX: Integer): Integer;
var
  EDX, ECX: integer;
label
  DUMDIDUM, WUPPDI, DIDUMDI;
begin
  EDX := EAX;           //   MOV EDX, EAX
  EDX :=  not EDX + 1;  //   NEG EDX
  if EDX >= EAX then    //   CMP EDX, EAX
   goto DUMDIDUM;       //   JAE @DUMDIDUM
  EAX := not EAX + 1;   //   NEG EAX
  DUMDIDUM:             // @DUMDIDUM:
    EDX := EAX;         //   MOV EDX, EAX
    INC(EAX);           //   INC EAX
  WUPPDI:               // @WUPPDI:
    DEC(EAX);           //   DEC EAX
    ECX := EAX;         //   MOV ECX, EAX
    ECX := not ECX + 1; //   NEG ECX
    if ECX = EDX then   //   CMP ECX, EDX
      goto WUPPDI;      //   JNE @WUPPDI
  DIDUMDI:              // @DIDUMDI:
    Result := EDX;      //   NOPpen tun wir heute nich, nich ?
end;

Oder einfavh so:

Delphi-Quellcode:

function Neg(ToNegativateValue: Integer): Integer;
begin
  Result := not ToNegativateValue + 1;
end;