Intercambiar dos valores variables sin usar la tercera variable

Una de las preguntas más difíciles que se hacen en una entrevista.

Intercambia los valores de dos variables como a=10y b=15.

Generalmente, para intercambiar dos valores de variables, necesitamos una tercera variable como:

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

Ahora el requisito es intercambiar valores de dos variables sin usar la tercera variable.

Usando el algoritmo de intercambio xor

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

¿Por qué la prueba?

La prueba es para asegurar que xey tengan diferentes ubicaciones de memoria (en lugar de valores diferentes). Esto se debe a que, (p xor p) = 0y si tanto x como y comparten la misma ubicación de memoria, cuando uno se establece en 0, ambos se establecen en 0. Cuando tanto * x como * y son 0, todas las demás operaciones xor en * x e * y serán iguales 0 (ya que son iguales), lo que significa que la función establecerá tanto * x como * y en 0.

Si tienen los mismos valores pero no la misma ubicación de memoria, todo funciona como se esperaba

*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

¿Debería usarse esto?

En casos generales, no. El compilador optimizará la variable temporal y dado que el intercambio es un procedimiento común, debería generar el código de máquina óptimo para su plataforma.

Tomemos, por ejemplo, este programa de prueba rápida escrito 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;    
}

Compilado usando:

gcc -Os main.c -o swap

La versión xor lleva

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

Donde como toma la versión con la variable temporal:

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

la forma general es:

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

sin embargo, es posible que tenga cuidado con los desbordamientos y tampoco todas las operaciones tienen una inversa que esté bien definida para todos los valores que la operación está definida. p. ej. * y / trabajar hasta que A o B sea 0

xor es particularmente agradable ya que se define para todos los ints y es su propio inverso

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

Nadie ha sugerido usarlo std::swaptodavía.

std::swap(a, b);

No utilizo ninguna variable temporal y dependiendo del tipo ay bla implementación puede tener una especialización que tampoco. La implementación debe escribirse sabiendo si un 'truco' es apropiado o no. No tiene sentido intentar adivinar.

De manera más general, probablemente querría hacer algo como esto, ya que funcionaría para tipos de clases que permitan a ADL encontrar una mejor sobrecarga si es posible.

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

Por supuesto, la reacción del entrevistador a esta respuesta podría decir mucho sobre la vacante.

Como ya señaló manu, el algoritmo XOR es uno de los populares que funciona para todos los valores enteros (que incluye punteros, con algo de suerte y conversión). En aras de la integridad, me gustaría mencionar otro algoritmo menos poderoso con suma / resta:

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

Aquí debe tener cuidado con los desbordamientos / subdesbordamientos, pero de lo contrario, funciona igual de bien. Incluso puede probar esto en flotadores / dobles en el caso de que XOR no esté permitido en ellos.

Las preguntas estúpidas merecen respuestas adecuadas:

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

El único buen uso de la registerpalabra clave.

Intercambiar dos números usando la tercera variable sería así,

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

Intercambiar dos números sin usar la tercera 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();
}

Dado que la solución original es:

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

Puede convertirlo en un delineador de dos usando:

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

Luego conviértalo en un delineador usando:

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

Si cambia un poco la pregunta para preguntar sobre 2 registros de ensamblaje en lugar de variables, puede usar también la xchgoperación como una opción y la operación de pila como otra.

Considere a=10, b=15:

Usando la suma y la resta

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

Usando división y multiplicación

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

Actualización: en esto estamos tomando la entrada de dos enteros del usuario. Entonces usamos la operación XOR bit a bit para intercambiarlos.

Digamos que tenemos dos enteros a=4y b=9ya continuación:

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

Aquí hay una solución más pero con un solo riesgo.

código:

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

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

cualquier valor en la ubicación a + 1 será anulado.

Por supuesto, la respuesta de C ++ debería ser std::swap.

Sin embargo, tampoco existe una tercera variable en la siguiente implementación de swap:

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

O, como una sola línea:

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

ese es el algoritmo de intercambio XOR correcto

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

debe asegurarse de que las ubicaciones de la memoria sean diferentes y también de que los valores reales sean diferentes porque A XOR A = 0

Puede hacerlo ... de manera fácil ... dentro de una línea 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;
}

o

#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 mejor respuesta sería usar XOR y usarlo en una línea sería genial.

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

x, y son variables y la coma entre ellas introduce los puntos de secuencia para que no dependa del compilador. ¡Salud!

Veamos un ejemplo simple de c para intercambiar dos números sin usar la tercera variable.

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

Salida:

Antes del intercambio a = 10 b = 20 Después del intercambio a = 20 b = 10

Programa 2: Uso de * y /

Veamos otro ejemplo para intercambiar dos números usando * y /.

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

Salida:

Antes del intercambio a = 10 b = 20 Después del intercambio a = 20 b = 10

Programa 3: haciendo uso del operador XOR bit a bit:

El operador XOR bit a bit se puede utilizar para intercambiar dos variables. El XOR de dos números xey devuelve un número que tiene todos los bits como 1 siempre que los bits de xey difieran. Por ejemplo, XOR de 10 (en binario 1010) y 5 (en binario 0101) es 1111 y XOR de 7 (0111) y 5 (0101) es (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;

Salida:

Después del intercambio: x = 5, y = 10

Programa 4:

Nadie ha sugerido usar std :: swap, todavía.

std::swap(a, b);

No utilizo ninguna variable temporal y, dependiendo del tipo de ayb, la implementación puede tener una especialización que tampoco. La implementación debe escribirse sabiendo si un 'truco' es apropiado o no.

Problemas con los métodos anteriores:

1) El método basado en la multiplicación y la división no funciona si uno de los números es 0, ya que el producto se convierte en 0 independientemente del otro número.

2) Ambas soluciones aritméticas pueden provocar un desbordamiento aritmético. Si xey son demasiado grandes, la suma y la multiplicación pueden salirse del rango de números enteros.

3) Cuando usamos punteros a una variable y hacemos un intercambio de función, todos los métodos anteriores fallan cuando ambos punteros apuntan a la misma variable. Echemos un vistazo a lo que sucederá en este caso si ambos apuntan a la misma variable.

// Método basado en XOR bit a bit

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

// Método basado en aritmética

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

Veamos el siguiente programa.

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

Salida :

Después del intercambio (& x, & x): x = 0

Es posible que sea necesario intercambiar una variable consigo misma en muchos algoritmos estándar. Por ejemplo, vea esta implementación de QuickSort donde podemos intercambiar una variable consigo misma. El problema anterior se puede evitar poniendo una condición antes del intercambio.

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

Salida :

Después del intercambio (& x, & x): x = 10

Quizás fuera del tema, pero si sabe lo que está intercambiando una sola variable entre dos valores diferentes, es posible que pueda hacer una lógica de matriz. Cada vez que se ejecuta esta línea de código, cambiará el valor entre 1 y 2.

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

Podrías hacerlo:

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

O use make_tuple cuando intercambie más de dos variables:

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

¡Pero no estoy seguro de si internamente std :: tie usa una variable temporal o no!

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
}

Tenga en cuenta el tiempo de ejecución de ambas opciones.

Al ejecutar este código, lo medí.

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

Como puede ver (y como muchos dijeron), el intercambio en el lugar (xor) toma mucho tiempo que la otra opción que usa la variable temporal.

A R le falta una asignación concurrente propuesta por Edsger W. Dijkstra en A Discipline of Programming , 1976, cap.4, p.29. Esto permitiría una solución elegante:

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

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

Es muy simple, pero puede generar una advertencia.

solución de una sola línea para intercambiar dos valores en lenguaje 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;