Tauschen Sie zwei Variablenwerte aus, ohne die dritte Variable zu verwenden

Eine der sehr kniffligen Fragen, die in einem Interview gestellt wurden.

Tauschen Sie die Werte zweier Variablen wie a=10und aus b=15.

Um zwei Variablenwerte auszutauschen, benötigen wir im Allgemeinen die dritte Variable wie:

temp=a;
a=b;
b=temp;

Jetzt ist die Anforderung, Werte von zwei Variablen zu tauschen, ohne die dritte Variable zu verwenden.

Verwendung des xor-Swap-Algorithmus

void xorSwap (int* x, int* y) {
    if (x != y) { //ensure that memory locations are different
       *x ^= *y;
       *y ^= *x;
       *x ^= *y;
    }
}

Warum der Test?

Der Test soll sicherstellen, dass x und y unterschiedliche Speicherorte haben (und nicht unterschiedliche Werte). Dies liegt daran, dass (p xor p) = 0und wenn sowohl x als auch y denselben Speicherort teilen, wenn einer auf 0 gesetzt ist, beide auf 0 gesetzt sind. Wenn sowohl * x als auch * y 0 sind, sind alle anderen xor-Operationen an * x und * y gleich 0 (da sie gleich sind), was bedeutet, dass die Funktion sowohl * x als auch * y auf 0 setzt.

Wenn sie dieselben Werte, aber nicht denselben Speicherort haben, funktioniert alles wie erwartet

*x = 0011
*y = 0011
//Note, x and y do not share an address. x != y

*x = *x xor *y  //*x = 0011 xor 0011
//So *x is 0000

*y = *x xor *y  //*y = 0000 xor 0011
//So *y is 0011

*x = *x xor *y  //*x = 0000 xor 0011
//So *x is 0011

Sollte dies verwendet werden?

Im Allgemeinen nein. Der Compiler optimiert die temporäre Variable und sollte, da das Austauschen ein gängiges Verfahren ist, den optimalen Maschinencode für Ihre Plattform ausgeben.

Nehmen Sie zum Beispiel dieses in C geschriebene Schnelltestprogramm.

#include <stdlib.h>
#include <math.h>

#define USE_XOR 

void xorSwap(int* x, int *y){
    if ( x != y ){
        *x ^= *y;
        *y ^= *x;
        *x ^= *y;
    }
}

void tempSwap(int* x, int* y){
    int t;
    t = *y;
    *y = *x;
    *x = t;
}


int main(int argc, char* argv[]){
    int x = 4;
    int y = 5;
    int z = pow(2,28); 
    while ( z-- ){
#       ifdef USE_XOR
            xorSwap(&x,&y);
#       else
            tempSwap(&x, &y);
#       endif
    }
    return x + y;    
}

Kompiliert mit:

gcc -Os main.c -o swap

Die xor-Version dauert

real    0m2.068s
user    0m2.048s
sys  0m0.000s

Wo wie die Version mit der temporären Variablen nimmt:

real    0m0.543s
user    0m0.540s
sys  0m0.000s

Die allgemeine Form lautet:

A = A operation B
B = A inverse-operation B
A = A inverse-operation B 

Sie müssen jedoch möglicherweise auf Überläufe achten, und auch nicht alle Operationen haben eine Umkehrung, die für alle Werte, für die die Operation definiert ist, gut definiert ist. zB * und / arbeiten bis A oder B 0 ist

xor ist besonders erfreulich, da es für alle Ints definiert ist und seine eigene Umkehrung ist

a = a + b
b = a - b // b = a
a = a - b

std::swapNoch hat niemand vorgeschlagen , zu verwenden.

std::swap(a, b);

Ich verwende keine temporären Variablen und je nach Art aund bImplementierung kann es zu einer Spekalisierung kommen, die dies auch nicht tut. Die Implementierung sollte so geschrieben werden, dass bekannt ist, ob ein „Trick“ angemessen ist oder nicht. Es macht keinen Sinn, zu raten.

Im Allgemeinen würde ich wahrscheinlich so etwas tun wollen, da dies für Klassentypen funktionieren würde, die es ADL ermöglichen, wenn möglich eine bessere Überlastung zu finden.

using std::swap;
swap(a, b);

Natürlich könnte die Reaktion des Interviewers auf diese Antwort viel über die Vakanz aussagen.

Wie bereits von manu bemerkt, ist der XOR-Algorithmus ein beliebter Algorithmus, der für alle ganzzahligen Werte funktioniert (einschließlich Zeiger, mit etwas Glück und Casting). Der Vollständigkeit halber möchte ich einen weiteren weniger leistungsfähigen Algorithmus mit Addition / Subtraktion erwähnen:

A = A + B
B = A - B
A = A - B

Hier muss man auf Über- / Unterläufe achten, sonst funktioniert es genauso gut. Sie können dies sogar bei Floats / Doubles versuchen, falls XOR auf diesen nicht zulässig ist.

Dumme Fragen verdienen angemessene Antworten:

void sw2ap(int& a, int& b) {
  register int temp = a; // !
  a = b;
  b = temp;
}

Die einzig gute Verwendung des registerSchlüsselworts.

Das Vertauschen von zwei Zahlen mit der dritten Variablen ist wie folgt:

int temp;
int a=10;
int b=20;
temp = a;
a = b;
b = temp;
printf ("Value of a", %a);
printf ("Value of b", %b);

Zwei Zahlen tauschen, ohne die dritte Variable zu verwenden

int a = 10;
int b = 20;
a = a+b;
b = a-b;
a = a-b;
printf ("value of a=", %a);
printf ("value of b=", %b);

#include<iostream.h>
#include<conio.h>
void main()
{
int a,b;
clrscr();
cout<<"\n==========Vikas==========";
cout<<"\n\nEnter the two no=:";
cin>>a>>b;
cout<<"\na"<<a<<"\nb"<<b;
a=a+b;
b=a-b;
a=a-b;

cout<<"\n\na="<<a<<"\nb="<<b;
getch();
}

Da die ursprüngliche Lösung ist:

temp = x; y = x; x = temp;

Sie können daraus einen Zweiliner machen, indem Sie Folgendes verwenden:

temp = x; y = y + temp -(x=y);

Machen Sie es dann zu einem Einzeiler, indem Sie Folgendes verwenden:

x = x + y -(y=x);

Wenn Sie die Frage nach 2 Assembly-Registern anstelle von Variablen ein wenig ändern, können Sie auch die xchgOperation als eine Option und die Stack-Operation als eine andere verwenden.

Betrachten Sie a=10, b=15:

Addition und Subtraktion verwenden

a = a + b //a=25
b = a - b //b=10
a = a - b //a=15

Division und Multiplikation verwenden

a = a * b //a=150
b = a / b //b=10
a = a / b //a=15

#include <iostream>
using namespace std;
int main(void)
{   
 int a,b;
 cout<<"Enter a integer" <<endl;
 cin>>a;
 cout<<"\n Enter b integer"<<endl;
 cin>>b;

  a = a^b;
  b = a^b;
  a = a^b;

  cout<<" a= "<<a <<"   b="<<b<<endl;
  return 0;
}

Update: Hier nehmen wir zwei Ganzzahlen vom Benutzer ein. Dann verwenden wir die bitweise XOR- Operation, um sie auszutauschen.

Sagen wir zwei ganzen Zahlen haben a=4und b=9dann:

a=a^b --> 13=4^9 
b=a^b --> 4=13^9 
a=a^b --> 9=13^9

Hier ist eine weitere Lösung, aber ein einziges Risiko.

Code:

#include <iostream>
#include <conio.h>
void main()
{

int a =10 , b =45;
*(&a+1 ) = a;
a =b;
b =*(&a +1);
}

Jeder Wert an Position a + 1 wird überschrieben.

Natürlich sollte die C ++ - Antwort lauten std::swap.

Es gibt jedoch auch keine dritte Variable in der folgenden Implementierung von swap:

template <typename T>
void swap (T &a, T &b) {
    std::pair<T &, T &>(a, b) = std::make_pair(b, a);
}

Oder als Einzeiler:

std::make_pair(std::ref(a), std::ref(b)) = std::make_pair(b, a);

#include <stdio.h>

int main()
{
    int a, b;
    printf("Enter A :");
    scanf("%d",&a);
    printf("Enter B :");
    scanf("%d",&b);
    a ^= b;
    b ^= a;
    a ^= b;
    printf("\nValue of A=%d B=%d ",a,b);
    return 1;
}

Das ist der richtige XOR-Swap-Algorithmus

void xorSwap (int* x, int* y) {
   if (x != y) { //ensure that memory locations are different
      if (*x != *y) { //ensure that values are different
         *x ^= *y;
         *y ^= *x;
         *x ^= *y;
      }
   }
}

Sie müssen sicherstellen, dass die Speicherorte unterschiedlich sind und dass die tatsächlichen Werte unterschiedlich sind, da A XOR A = 0 ist

Sie können ... auf einfache Weise ... innerhalb einer Zeile Logik

#include <stdio.h>

int main()
{
    int a, b;
    printf("Enter A :");
    scanf("%d",&a);
    printf("Enter B :");
    scanf("%d",&b);
    int a = 1,b = 2;
    a=a^b^(b=a);
    printf("\nValue of A=%d B=%d ",a,b);

    return 1;
}

oder

#include <stdio.h>

int main()
{
    int a, b;
    printf("Enter A :");
    scanf("%d",&a);
    printf("Enter B :");
    scanf("%d",&b);
    int a = 1,b = 2;
    a=a+b-(b=a);
    printf("\nValue of A=%d B=%d ",a,b);

    return 1;
}

public void swapnumber(int a,int b){
    a = a+b-(b=a);
    System.out.println("a = "+a +" b= "+b);
}

Die beste Antwort wäre, XOR zu verwenden und es in einer Zeile zu verwenden, wäre cool.

    (x ^= y), (y ^= x), (x ^= y);

x, y sind Variablen und das Komma zwischen ihnen führt die Sequenzpunkte ein, damit sie nicht vom Compiler abhängig werden. Prost!

Sehen wir uns ein einfaches c-Beispiel an, um zwei Zahlen ohne Verwendung der dritten Variablen auszutauschen.

Programm 1:

#include<stdio.h>
#include<conio.h>
main()
{
int a=10, b=20;
clrscr();
printf("Before swap a=%d b=%d",a,b);
a=a+b;//a=30 (10+20)
b=a-b;//b=10 (30-20)
a=a-b;//a=20 (30-10)
printf("\nAfter swap a=%d b=%d",a,b);
getch();
}

Ausgabe:

Vor dem Tausch a = 10 b = 20 Nach dem Tausch a = 20 b = 10

Programm 2: Verwenden von * und /

Sehen wir uns ein weiteres Beispiel an, um zwei Zahlen mit * und / auszutauschen.

#include<stdio.h>
#include<conio.h>
main()
{
int a=10, b=20;
clrscr();
printf("Before swap a=%d b=%d",a,b);
a=a*b;//a=200 (10*20)
b=a/b;//b=10 (200/20)
a=a/b;//a=20 (200/10)
printf("\nAfter swap a=%d b=%d",a,b);
getch();
}

Ausgabe:

Vor dem Tausch a = 10 b = 20 Nach dem Tausch a = 20 b = 10

Programm 3: Verwendung des bitweisen XOR-Operators:

Mit dem bitweisen XOR-Operator können zwei Variablen ausgetauscht werden. Das XOR aus zwei Zahlen x und y gibt eine Zahl zurück, die alle Bits als 1 hat, wo immer sich die Bits von x und y unterscheiden. Zum Beispiel ist XOR von 10 (In Binary 1010) und 5 (In Binary 0101) 1111 und XOR von 7 (0111) und 5 (0101) ist (0010).

#include <stdio.h>
int main()
{
 int x = 10, y = 5;
 // Code to swap 'x' (1010) and 'y' (0101)
 x = x ^ y;  // x now becomes 15 (1111)
 y = x ^ y;  // y becomes 10 (1010)
 x = x ^ y;  // x becomes 5 (0101)
 printf("After Swapping: x = %d, y = %d", x, y);
 return 0;

Ausgabe:

Nach dem Tauschen: x = 5, y = 10

Programm 4:

Bisher hat noch niemand vorgeschlagen, std :: swap zu verwenden.

std::swap(a, b);

Ich verwende keine temporären Variablen und je nach Typ von a und b hat die Implementierung möglicherweise eine Spezialisierung, die dies auch nicht tut. Die Implementierung sollte so geschrieben werden, dass bekannt ist, ob ein „Trick“ angemessen ist oder nicht.

Probleme mit den oben genannten Methoden:

1) Der auf Multiplikation und Division basierende Ansatz funktioniert nicht, wenn eine der Zahlen 0 ist, da das Produkt unabhängig von der anderen Zahl 0 wird.

2) Beide arithmetischen Lösungen können einen arithmetischen Überlauf verursachen. Wenn x und y zu groß sind, können Addition und Multiplikation außerhalb des ganzzahligen Bereichs liegen.

3) Wenn wir Zeiger auf eine Variable verwenden und einen Funktionsaustausch durchführen, schlagen alle oben genannten Methoden fehl, wenn beide Zeiger auf dieselbe Variable zeigen. Lassen Sie uns einen Blick darauf werfen, was in diesem Fall passieren wird, wenn beide auf dieselbe Variable zeigen.

// Bitweise XOR-basierte Methode

x = x ^ x; // x becomes 0
x = x ^ x; // x remains 0
x = x ^ x; // x remains 0

// Arithmetikbasierte Methode

x = x + x; // x becomes 2x
x = x – x; // x becomes 0
x = x – x; // x remains 0

Lassen Sie uns das folgende Programm sehen.

#include <stdio.h>
void swap(int *xp, int *yp)
{
    *xp = *xp ^ *yp;
    *yp = *xp ^ *yp;
    *xp = *xp ^ *yp;
}

int main()
{
  int x = 10;
  swap(&x, &x);
  printf("After swap(&x, &x): x = %d", x);
  return 0;
}

Ausgabe :

Nach dem Tausch (& x, & x): x = 0

Das Austauschen einer Variablen mit sich selbst kann in vielen Standardalgorithmen erforderlich sein. Sehen Sie sich zum Beispiel diese Implementierung von QuickSort an, in der wir eine Variable mit sich selbst austauschen können. Das obige Problem kann vermieden werden, indem vor dem Austausch eine Bedingung gestellt wird.

#include <stdio.h>
void swap(int *xp, int *yp)
{
    if (xp == yp) // Check if the two addresses are same
      return;
    *xp = *xp + *yp;
    *yp = *xp - *yp;
    *xp = *xp - *yp;
}
int main()
{
  int x = 10;
  swap(&x, &x);
  printf("After swap(&x, &x): x = %d", x);
  return 0;
}

Ausgabe :

Nach dem Tausch (& x, & x): x = 10

Möglicherweise außerhalb des Themas, aber wenn Sie wissen, was Sie für eine einzelne Variable zwischen zwei verschiedenen Werten austauschen, können Sie möglicherweise Array-Logik ausführen. Jedes Mal, wenn diese Codezeile ausgeführt wird, wird der Wert zwischen 1 und 2 ausgetauscht.

n = [2, 1][n - 1]

Du könntest es tun:

std::tie(x, y) = std::make_pair(y, x);

Oder verwenden Sie make_tuple, wenn Sie mehr als zwei Variablen austauschen:

std::tie(x, y, z) = std::make_tuple(y, z, x);

Ich bin mir aber nicht sicher, ob intern std :: tie eine temporäre Variable verwendet oder nicht!

In Javascript:

function swapInPlace(obj) {
    obj.x ^= obj.y
    obj.y ^= obj.x
    obj.x ^= obj.y
}

function swap(obj) {
    let temp = obj.x
    obj.x = obj.y
    obj.y = temp
}

Beachten Sie die Ausführungszeit beider Optionen.

Durch Ausführen dieses Codes habe ich ihn gemessen.

console.time('swapInPlace')
swapInPlace({x:1, y:2})
console.timeEnd('swapInPlace') // swapInPlace: 0.056884765625ms

console.time('swap')
swap({x:3, y:6})
console.timeEnd('swap')        // swap: 0.01416015625ms

Wie Sie sehen können (und wie viele sagten), dauert der Austausch an Ort und Stelle (xor) viel länger als die andere Option mit der temporären Variablen.

R fehlt eine gleichzeitige Zuordnung, wie von Edsger W. Dijkstra in A Discipline of Programming , 1976, Kap. 4, S. 29 vorgeschlagen. Dies würde eine elegante Lösung ermöglichen:

a, b    <- b, a         # swap
a, b, c <- c, a, b      # rotate right

a = a + b - (b=a);

Es ist sehr einfach, aber es kann eine Warnung auslösen.

Einzeilige Lösung zum Vertauschen von zwei Werten in der Sprache c.

a=(b=(a=a+b,a-b),a-b);

second_value -= first_value;
first_value +=  second_value;
second_value -= first_value;
second_value *= -1;