2 Variablen vertauschen

[HAF4ever]

Ich hab mir mal den Kopf darüber zerbrochen warum es nötig sein muss beim Tauschen der Werte zweier Variablen eine Hilfsvariable heranzuziehen.
:arrow: z.B.:

Code:

h:=x;
x:=y;
y:=h;

:coder: ich hab ein wenig herumgecoded und bin schließlich auf einen grünen zweig gekommen.
:arrow: hier der code:

Code:

x:=x xor y;
y:=x xor y;
x:=x xor y;

[sakura]

Zitat:

Zitat von HAF4ever

ich hab ein wenig herumgecoded und bin schließlich auf einen grünen zweig gekommen

Nur wo ist der wirkliche Vorteil :gruebel: Der Computer muss dreimal rechnen :arrow: Zeitaufwand. In Assembler kommt Deine Lösung auf den folgenden Ansatz (X, Y sind vom Typ Integer):

Delphi-Quellcode:

  asm
    mov EAX, Y
    xor X, EAX
    mov EAX, X
    xor Y, EAX
    mov EAX, Y
    xor X, EAX
  end;

Dann doch lieber gleich so

Delphi-Quellcode:

  asm
    mov EAX, Y
    mov EBX, X
    mov Y, EBX
    mov X, EAX
  end;

...:cat:...

[roderich]

Delphi-Quellcode:

Code: 
x:=x xor y; 
y:=x xor y; 
x:=x xor y;

Das erinnert mich an die C-Programmierer, die auch in einer einzigen Zeile gleich ganz viel codieren können.
Damit gewinnst du vielleicht 1 Nanosekunde Ausführungszeit, dafür kann den Code in zwei Wochen keiner mehr verstehen.

[choose]

Zitat:

Zitat von sakura

wo ist der wirkliche Vorteil :gruebel: [..] In Assembler[..]

Hallo sakura,

gerade bei der Arbeit mit der begrenzten Anzahl von Registern hat sich dieser alte ASM-Trick schon häufig bewähren können, ohne zusätzlich mit dem Stack oder einer Variablen arbeiten zu müssen, falls zwei GP-Register ausgetauscht werden sollten (hier EAX und EBX), was wesentlich (zeit-)aufwendiger wäre:

Code:

xor   EAX, EBX
xor   EBX, EAX
xor   EAX, EBX

[Neg]

Der Kontrast zwischen dieser Lösung und deiner Signatur könnte kaum größer sein... :roll:

[glkgereon]

könnte das einer für mich nichtassembler mal erklären?

was soll dieses y:= x xor y und so?

imn voraus: ich weiss was xor ist!!!

[negaH]

Dann solltest du auch deine Frage selber beantworten können ;)

Gruß Hagen

[glkgereon]

hä?

das heisst für mich:

Delphi-Quellcode:

x:= x oder y;
y:= x oder y;
x:= x oder y;

also oder heisst jetzt xor
aber wqarum sollte das vertauschen;

zb x:=x xor y, woher soller wissen ob jetzt x:=x oder x:=y????? :gruebel:

[phXql]

xor ist kein normales oder (or), sondern ein exklusives oder (macht nen unterschied ;))

[Chewie]

Mal dir einfach die Bitmuster auf ein Blatt und vollzieh den Tauschvorgang nach.

[Luckie]

Nicht oder, sonder nicht oder.

Code:

x = 1010
y = 1011

x: 1010
y: 1011  xor
-------
x= 0100

x: 0100
y: 1011 xor
-------
y= 0000

x: 0100
y: 0000 xor
-------
x= 1011

Somit hätte x den Wert von y. Nur ist da bei mir gerade der Wert von y auf der Strecke geblieben. :gruebel:

[Chewie]

Ähm, Luckie, ich weiß nicht, welche Operation du da jetzt ausgeführt hast, aber in XOR ist das definitiv nicht...

Halt, jetzt sehe ich es, es ist ein NAND ;)

Edit: Blödsinn, ich mein natürlich NOR :wall:

[glkgereon]

ich kapier das zwar grundsätzlich, aber ich dachte xor wär das:

bedingung:

if (x=1) xor (y=2)...

ist gleich

if ((x=1) and (y<>2)) or ((x<>1) and (y=2))...

oder nit :gruebel: :gruebel: :gruebel:

ich mein man kann ja auch nit sagen x=x and y, oder?

[Chewie]

Ersetze das "ist gleich" durch "ist äquivalent", und wir sind im Geschäft ;)

Das ist aber nicht die Definition von xor, sondern eine Anwendung.
xor ist zunächst eine Operation, die zwei Bit-Operanden hat. Das Ergebnis dieser Operation ist nun 1, falls genau ein Bit 1 ist und sonst 0.

Folgende Beispiele sollten es verdeutlichen:

Code:

01011 xor
10101
-----
11110

00101 xor
11100
-----
11001

Du kannst es auch als Addition ohne Berücksichtigung des Übertrags ansehen.

[CalganX]

Öhm... Luckie? :gruebel:

Code:

x = 1010
y = 1011

x: 1010
y: 1011  xor
-------
x= 0001

x: 0001
y: 1011 xor
-------
y= 1010

x: 0001
y: 1010 xor
-------
x= 1011

Wäre wohl richtiger. :lol: ;)

Chris

[Ultimator]

D.h. sind zwei bits gleich, so ist das Ergebnis Null, anderenfalls ist es Eins.

[Chewie]

Zitat:

Zitat von Ultimator

D.h. sind zwei bits gleich, so ist das Ergebnis Null, anderenfalls ist es Eins.

Bingo :thuimb:
Deswegen nennt man das Ding auch "Ambivalenzoperator", weil es ausdrückt, ob zwei Werte verschieden sind oder nicht. Die negierte Version davon, also das XNOR, wäre dann der "Äquivalenzoperator".

[glkgereon]

kann ich denn jetzt sagen

x:= x and y???

[Chewie]

Klar kannst du das sagen, die Frage ist nur, was du damit ausdrücken willst :gruebel:

[negaH]

Zitat:

imn voraus: ich weiss was xor ist!!!

Tja, anscheindend doch nicht ;)

Gruß Hagen

[Luckie]

Zitat:

Zitat von Chewie

Das ist aber nicht die Definition von xor, sondern eine Anwendung.
xor ist zunächst eine Operation, die zwei Bit-Operanden hat. Das Ergebnis dieser Operation ist nun 1, falls genau ein Bit 1 ist und sonst 0.

Hm. Und wo ist dann der Unterschied zu or?

Code:

1 or 0 = 1
0 or 1 = 1
0 or 0 = 0
1 or 1 = 1

Haaaa, habs:

Code:

1 xor 1 = 0

oder?

Zitat:

Du kannst es auch als Addition ohne Berücksichtigung des Übertrags ansehen.

Das ist eine gute Erklärung.

[CalganX]

Hi,

Zitat:

Zitat von Luckie

Haaaa, habs:

Code:

1 xor 1 = 0

oder?

jepp. ;)

Chris

[gmarts]

or = oder
xor = entweder, oder