Trocar dois valores de variáveis ​​sem usar a terceira variável

Uma das perguntas mais complicadas feitas em uma entrevista.

Troque os valores de duas variáveis ​​como a=10e b=15.

Geralmente, para trocar dois valores de variáveis, precisamos da terceira variável como:

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

Agora, o requisito é trocar os valores de duas variáveis ​​sem usar a terceira variável.

Usando o algoritmo de troca xor

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

Por que o teste?

O teste é para garantir que xey tenham localizações de memória diferentes (em vez de valores diferentes). Isso ocorre porque, (p xor p) = 0e se xey compartilham o mesmo local de memória, quando um é definido como 0, ambos são definidos como 0. Quando * x e * y são 0, todas as outras operações xor em * x e * y serão iguais 0 (porque são iguais), o que significa que a função definirá * x e * y como 0.

Se eles tiverem os mesmos valores, mas não o mesmo local de memória, tudo funcionará conforme o esperado

*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

Isso deve ser usado?

Em casos gerais, não. O compilador otimizará a variável temporária e, dado que a troca é um procedimento comum, ele deve produzir o código de máquina ideal para sua plataforma.

Veja, por exemplo, este programa de teste rápido escrito em 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

A versão xor leva

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

Onde a versão com a variável temporária leva:

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

a forma geral é:

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

no entanto, você deve potencialmente estar atento a estouros e também nem todas as operações têm um inverso bem definido para todos os valores em que a operação está definida. por exemplo, * e / trabalhar até que A ou B seja 0

xor é particularmente agradável, pois é definido para todos os ints e é seu próprio inverso

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

Ninguém sugeriu usar std::swap, ainda.

std::swap(a, b);

Eu não uso nenhuma variável temporária e dependendo do tipo de ae bda implementação pode haver uma especalização que também não. A implementação deve ser escrita sabendo se um 'truque' é apropriado ou não. Não adianta tentar adivinhar.

De forma mais geral, provavelmente gostaria de fazer algo assim, pois funcionaria para tipos de classe, permitindo que o ADL encontrasse uma sobrecarga melhor, se possível.

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

Claro, a reação do entrevistador a essa resposta pode dizer muito sobre a vaga.

Como já notado por manu, o algoritmo XOR é um algoritmo popular que funciona para todos os valores inteiros (isso inclui ponteiros então, com alguma sorte e fundição). Para ser mais completo, gostaria de mencionar outro algoritmo menos poderoso com adição / subtração:

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

Aqui, você deve ter cuidado com overflows / underflows, mas, caso contrário, funciona perfeitamente. Você pode até tentar isso em floats / doubles no caso de XOR não ser permitido neles.

Perguntas estúpidas merecem respostas adequadas:

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

O único bom uso da registerpalavra - chave.

Trocar dois números usando a terceira variável seja assim,

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

Trocar dois números sem usar a terceira variável

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

Já que a solução original é:

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

Você pode torná-lo um revestimento duplo usando:

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

Em seguida, transforme-o em um forro usando:

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

Se você mudar um pouco a pergunta para perguntar sobre 2 registros de montagem em vez de variáveis, você pode usar também a xchgoperação como uma opção e a operação de pilha como outra.

Considere a=10, b=15:

Usando adição e subtração

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

Usando divisão e multiplicação

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

Atualização: neste, estamos pegando a entrada de dois inteiros do usuário. Então, estamos usando o XOR bit a bit para trocá-los.

Digamos que temos dois inteiros a=4e b=9em seguida:

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

Aqui está mais uma solução, mas um único risco.

código:

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

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

qualquer valor no local a + 1 será substituído.

Claro, a resposta C ++ deve ser std::swap .

No entanto, também não há uma terceira variável na seguinte implementação de swap:

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

Ou, como uma linha:

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

esse é o algoritmo de troca XOR correto

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

você deve garantir que os locais de memória sejam diferentes e também que os valores reais sejam diferentes porque A XOR A = 0

Você pode fazer .... de maneira fácil ... dentro de uma linha Lógica

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

A melhor resposta seria usar o XOR e usá-lo em uma linha seria legal.

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

x, y são variáveis ​​e a vírgula entre elas introduz os pontos de sequência para que não se tornem dependentes do compilador. Felicidades!

Vamos ver um exemplo simples de c para trocar dois números sem usar a terceira variável.

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

Resultado:

Antes da troca a = 10 b = 20 Após a troca a = 20 b = 10

Programa 2: Usando * e /

Vamos ver outro exemplo para trocar dois números usando * e /.

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

Resultado:

Antes da troca a = 10 b = 20 Após a troca a = 20 b = 10

Programa 3: Fazendo uso do operador XOR bit a bit:

O operador XOR bit a bit pode ser usado para trocar duas variáveis. O XOR de dois números x e y retorna um número que tem todos os bits como 1 sempre que os bits de x e y diferem. Por exemplo, XOR de 10 (In Binary 1010) e 5 (In Binary 0101) é 1111 e XOR de 7 (0111) e 5 (0101) é (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;

Resultado:

Após a troca: x = 5, y = 10

Programa 4:

Ninguém sugeriu usar std :: swap, ainda.

std::swap(a, b);

Eu não uso nenhuma variável temporária e dependendo do tipo de aeb, a implementação pode ter uma especialização que também não. A implementação deve ser escrita sabendo se um 'truque' é apropriado ou não.

Problemas com os métodos acima:

1) A abordagem baseada na multiplicação e divisão não funciona se um dos números for 0, já que o produto se torna 0 independentemente do outro número.

2) Ambas as soluções aritméticas podem causar estouro aritmético. Se x e y forem muito grandes, a adição e a multiplicação podem sair do intervalo inteiro.

3) Quando usamos ponteiros para uma variável e fazemos uma troca de função, todos os métodos acima falham quando ambos os ponteiros apontam para a mesma variável. Vamos dar uma olhada no que acontecerá neste caso se ambos estiverem apontando para a mesma variável.

// Método baseado em XOR bit a bit

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

// Método baseado em aritmética

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

Vamos ver o seguinte 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;
}

Resultado :

Após a troca (& x, & x): x = 0

A troca de uma variável com ela mesma pode ser necessária em muitos algoritmos padrão. Por exemplo, veja esta implementação do QuickSort onde podemos trocar uma variável com ele mesmo. O problema acima pode ser evitado colocando uma condição antes da troca.

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

Produto :

Após a troca (& x, & x): x = 10

Talvez fora do assunto, mas se você sabe o que está trocando uma única variável entre dois valores diferentes, pode ser capaz de fazer lógica de array. Cada vez que essa linha de código é executada, ela troca o valor entre 1 e 2.

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

Você poderia fazer:

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

Ou use make_tuple ao trocar mais de duas variáveis:

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

Mas não tenho certeza se internamente std :: tie usa uma variável temporária ou não!

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

Esteja ciente do tempo de execução de ambas as opções.

Ao executar este código, eu o medi.

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 você pode ver (e como muitos disseram), a troca no lugar (xor) leva muito tempo do que a outra opção que usa a variável temp.

R está faltando uma atribuição concorrente, conforme proposto por Edsger W. Dijkstra em A Discipline of Programming , 1976, ch.4, p.29. Isso permitiria uma solução elegante:

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

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

É muito simples, mas pode gerar um alerta.

solução de linha única para trocar dois valores na linguagem 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;