Échange de deux valeurs de variable sans utiliser de troisième variable

Une des questions très délicates posées lors d'une interview.

Échangez les valeurs de deux variables comme a=10et b=15.

Généralement, pour échanger deux valeurs de variables, nous avons besoin d'une troisième variable comme:

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

Maintenant, l'exigence est de permuter les valeurs de deux variables sans utiliser la 3e variable.

Utilisation de l' algorithme d'échange xor

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

Pourquoi le test?

Le test consiste à s'assurer que x et y ont des emplacements mémoire différents (plutôt que des valeurs différentes). Ceci est dû au fait que (p xor p) = 0et si x et y partagent le même emplacement mémoire, quand l'un est défini sur 0, les deux sont définis sur 0. Lorsque * x et * y sont tous deux 0, toutes les autres opérations xor sur * x et * y seront égales 0 (car ils sont identiques), ce qui signifie que la fonction définira à la fois * x et * y sur 0.

S'ils ont les mêmes valeurs mais pas le même emplacement mémoire, tout fonctionne comme prévu

*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

Cela devrait-il être utilisé?

Dans les cas généraux, non. Le compilateur optimisera la variable temporaire et étant donné que la permutation est une procédure courante, il devrait générer le code machine optimal pour votre plate-forme.

Prenons par exemple ce programme de test rapide écrit en C.

#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;    
}

Compilé avec:

gcc -Os main.c -o swap

La version xor prend

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

Où prend la version avec la variable temporaire:

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

la forme générale est:

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

Cependant, vous devez potentiellement faire attention aux débordements et toutes les opérations n'ont pas non plus un inverse bien défini pour toutes les valeurs que l'opération est définie. par exemple * et / fonctionnent jusqu'à ce que A ou B soit 0

xor est particulièrement agréable car il est défini pour tous les entiers et est son propre inverse

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

Personne n'a encore suggéré d'utiliser std::swap.

std::swap(a, b);

Je n'utilise aucune variable temporaire et selon le type de aet bl'implémentation peut avoir une spécification qui ne l'est pas non plus. L'implémentation doit être écrite en sachant si une «astuce» est appropriée ou non. Il ne sert à rien d'essayer de remettre en question.

Plus généralement, je voudrais probablement faire quelque chose comme ça, car cela fonctionnerait pour les types de classe permettant à ADL de trouver une meilleure surcharge si possible.

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

Bien entendu, la réaction de l'intervieweur à cette réponse pourrait en dire long sur le poste vacant.

Comme déjà noté par manu, l'algorithme XOR est un algorithme populaire qui fonctionne pour toutes les valeurs entières (qui comprend alors des pointeurs, avec un peu de chance et de casting). Par souci d'exhaustivité, je voudrais mentionner un autre algorithme moins puissant avec addition / soustraction:

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

Ici, vous devez faire attention aux débordements / sous-débits, mais sinon cela fonctionne tout aussi bien. Vous pouvez même essayer ceci sur les flottants / doubles dans le cas où XOR n'est pas autorisé sur ceux-ci.

Les questions stupides méritent des réponses appropriées:

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

Le seul bon usage du registermot - clé.

Échangez deux nombres en utilisant la troisième variable comme ceci,

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

Échange de deux nombres sans utiliser la troisième variable

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();
}

Puisque la solution originale est:

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

Vous pouvez en faire une doublure en utilisant:

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

Puis faites-en un one liner en utilisant:

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

Si vous modifiez un peu la question pour poser environ 2 registres d'assemblage au lieu de variables, vous pouvez également utiliser l' xchgopération comme une option et l'opération de pile comme une autre.

Considérez a=10, b=15:

Utilisation de l'addition et de la soustraction

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

Utilisation de la division et de la multiplication

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;
}

Mise à jour: En cela, nous prenons la saisie de deux entiers de l'utilisateur. Ensuite, nous utilisons l'opération XOR au niveau du bit pour les permuter.

Disons que nous avons deux entiers a=4et b=9puis:

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

Voici une autre solution mais un seul risque.

code:

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

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

toute valeur à l'emplacement a + 1 sera remplacée.

Bien sûr, la réponse C ++ devrait être std::swap.

Cependant, il n'y a pas non plus de troisième variable dans l'implémentation suivante de swap:

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

Ou, en monoplace:

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;
}

c'est le bon algorithme d'échange XOR

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;
      }
   }
}

vous devez vous assurer que les emplacements de mémoire sont différents et que les valeurs réelles sont différentes car A XOR A = 0

Vous pouvez faire ... de manière simple ... en une seule ligne Logic

#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;
}

ou

#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);
}

La meilleure réponse serait d'utiliser XOR et de l'utiliser en une seule ligne serait cool.

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

x, y sont des variables et la virgule entre elles introduit les points de séquence afin qu'elle ne devienne pas dépendante du compilateur. À votre santé!

Voyons un exemple c simple pour échanger deux nombres sans utiliser la troisième variable.

programme 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();
}

Production:

Avant échange a = 10 b = 20 Après échange a = 20 b = 10

Programme 2: Utilisation de * et /

Voyons un autre exemple pour échanger deux nombres en utilisant * et /.

#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();
}

Production:

Avant échange a = 10 b = 20 Après échange a = 20 b = 10

Programme 3: Utilisation de l'opérateur XOR bit à bit:

L'opérateur XOR au niveau du bit peut être utilisé pour permuter deux variables. Le XOR de deux nombres x et y renvoie un nombre dont tous les bits valent 1 partout où les bits de x et y diffèrent. Par exemple, XOR de 10 (en binaire 1010) et 5 (en binaire 0101) est 1111 et XOR de 7 (0111) et 5 (0101) est (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;

Production:

Après échange: x = 5, y = 10

Programme 4:

Personne n'a encore suggéré d'utiliser std :: swap.

std::swap(a, b);

Je n'utilise aucune variable temporaire et en fonction du type de a et b, l'implémentation peut avoir une spécialisation qui ne l'est pas non plus. L'implémentation doit être écrite en sachant si une «astuce» est appropriée ou non.

Problèmes avec les méthodes ci-dessus:

1) L'approche basée sur la multiplication et la division ne fonctionne pas si l'un des nombres est 0 car le produit devient 0 quel que soit l'autre nombre.

2) Les deux solutions arithmétiques peuvent provoquer un débordement arithmétique. Si x et y sont trop grands, l'addition et la multiplication peuvent sortir de l'intervalle entier.

3) Lorsque nous utilisons des pointeurs vers une variable et faisons un échange de fonction, toutes les méthodes ci-dessus échouent lorsque les deux pointeurs pointent vers la même variable. Voyons ce qui se passera dans ce cas si les deux pointent vers la même variable.

// Méthode basée sur XOR au niveau du bit

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

// Méthode basée sur l'arithmétique

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

Voyons le programme suivant.

#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;
}

Sortie :

Après échange (& x, & x): x = 0

L'échange d'une variable avec elle-même peut être nécessaire dans de nombreux algorithmes standard. Par exemple, voyez cette implémentation de QuickSort où nous pouvons échanger une variable avec elle-même. Le problème ci-dessus peut être évité en mettant une condition avant l'échange.

#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;
}

Sortie :

Après échange (& x, & x): x = 10

Peut-être hors sujet, mais si vous savez ce que vous échangez une seule variable entre deux valeurs différentes, vous pourrez peut-être faire de la logique de tableau. Chaque fois que cette ligne de code est exécutée, elle permute la valeur entre 1 et 2.

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

Vous pourriez faire:

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

Ou utilisez make_tuple lors de l'échange de plus de deux variables:

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

Mais je ne suis pas sûr si std :: tie utilise en interne une variable temporaire ou non!

En 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
}

Soyez conscient du temps d'exécution des deux options.

En exécutant ce code, je l'ai mesuré.

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

Comme vous pouvez le voir (et comme beaucoup l'ont dit), swap in place (xor) prend beaucoup de temps que l'autre option utilisant la variable temp.

Il manque à R une affectation concurrente proposée par Edsger W.Dijkstra dans A Discipline of Programming , 1976, ch.4, p.29. Cela permettrait une solution élégante:

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

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

C'est très simple, mais cela peut soulever un avertissement.

solution sur une seule ligne pour permuter deux valeurs en langage 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;