Замена двух значений переменной без использования третьей переменной

Один из самых каверзных вопросов в интервью.

Поменяйте местами значения двух переменных, например a=10и b=15.

Обычно, чтобы поменять местами значения двух переменных, нам нужна третья переменная, например:

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

Теперь необходимо поменять местами значения двух переменных без использования третьей переменной.

Использование алгоритма обмена xor

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

Зачем тест?

Тест должен убедиться, что x и y имеют разные ячейки памяти (а не разные значения). Это потому что(p xor p) = 0 если и x, и y совместно используют одну и ту же ячейку памяти, когда один из них установлен в 0, оба устанавливаются в 0. Когда оба * x и * y равны 0, все другие операции xor для * x и * y будут равны 0 (поскольку они одинаковы), что означает, что функция установит для * x и * y значение 0.

Если у них одинаковые значения, но не одно и то же место в памяти, все работает должным образом.

*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

Следует ли это использовать?

В общих случаях нет. Компилятор оптимизирует временную переменную и, учитывая, что замена является обычной процедурой, он должен вывести оптимальный машинный код для вашей платформы.

Возьмем, к примеру, эту программу быстрого тестирования, написанную на 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;    
}

Скомпилировано с использованием:

gcc -Os main.c -o swap

Версия xor принимает

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

Где в качестве версии с временной переменной принимает:

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

общая форма:

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

однако вы должны потенциально остерегаться переполнения, а также не все операции имеют инверсию, которая хорошо определена для всех значений, определенных для операции. например, * и / работают, пока A или B не станут 0

xor особенно приятен, поскольку он определен для всех целых чисел и является его собственным обратным

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

Пока никто не предлагал использовать std::swap.

std::swap(a, b);

Я не использую никаких временных переменных и в зависимости от типа aиb реализации может иметь специализацию, которая тоже не работает. Реализация должна быть написана с учетом того, уместен ли «трюк». Нет смысла повторять догадки.

В более общем плане я, вероятно, хотел бы сделать что-то подобное, поскольку это будет работать для типов классов, позволяющих ADL найти лучшую перегрузку, если это возможно.

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

Конечно, реакция интервьюера на такой ответ может многое сказать о вакансии.

Как уже отмечалось в manu, алгоритм XOR - популярный алгоритм, который работает для всех целочисленных значений (включая указатели, если повезет и приведение типов). Для полноты картины хотелось бы упомянуть еще об одном менее мощном алгоритме с добавлением / вычитанием:

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

Здесь вы должны быть осторожны с переполнением / недостаточным заполнением, но в остальном все работает так же хорошо. Вы даже можете попробовать это с числами с плавающей запятой / удвоением, если XOR для них не разрешен.

Глупые вопросы заслуживают соответствующих ответов:

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

Единственное хорошее использование registerключевого слова.

Обмен двух чисел с использованием третьей переменной будет таким:

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

Замена двух чисел без использования третьей переменной

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

Поскольку исходное решение:

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

Вы можете сделать его двухслойным, используя:

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

Затем сделайте его однострочным, используя:

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

Если вы немного измените вопрос о двух регистрах сборки вместо переменных, вы также можете использовать xchgоперацию как одну опцию, а операцию стека как другую.

Учтите a=10, что b=15:

Использование сложения и вычитания

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

Использование деления и умножения

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

Обновление: здесь мы получаем от пользователя два целых числа. Затем мы используем побитовую операцию XOR, чтобы поменять их местами.

Скажем , у нас есть два целых числа a=4и , b=9а затем:

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

Вот еще одно решение, но с одним риском.

код:

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

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

любое значение в местоположении a + 1 будет переопределено.

Конечно, ответ C ++ должен быть std::swap.

Однако в следующей реализации swap:

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

Или, как однострочный:

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

это правильный алгоритм обмена 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;
      }
   }
}

вы должны убедиться, что ячейки памяти разные, а также фактические значения, потому что A XOR A = 0

Вы можете сделать .... простым способом ... в пределах одной строки Логика

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

или

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

Лучшим ответом было бы использовать XOR, и использовать его в одной строке было бы здорово.

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

x, y - переменные, и запятая между ними вводит точки последовательности, поэтому они не зависят от компилятора. Ура!

Давайте посмотрим на простой пример c, чтобы поменять местами два числа без использования третьей переменной.

программа 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();
}

Вывод:

До свопа a = 10 b = 20 После свопа a = 20 b = 10

Программа 2: Использование * и /

Давайте посмотрим на другой пример, чтобы поменять местами два числа с помощью * и /.

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

Вывод:

До свопа a = 10 b = 20 После свопа a = 20 b = 10

Программа 3: Использование побитового оператора XOR:

Побитовый оператор XOR можно использовать для обмена двумя переменными. XOR двух чисел x и y возвращает число, в котором все биты равны 1, если биты x и y различаются. Например, XOR для 10 (в двоичном формате 1010) и 5 ​​(в двоичном формате 0101) равно 1111, а XOR для 7 (0111) и 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;

Вывод:

После обмена: x = 5, y = 10

Программа 4:

Пока никто не предлагал использовать std :: swap.

std::swap(a, b);

Я не использую какие-либо временные переменные, и в зависимости от типа a и b реализация может иметь специализацию, которой тоже нет. Реализация должна быть написана с учетом того, уместен ли «трюк».

Проблемы с вышеуказанными методами:

1) Подход, основанный на умножении и делении, не работает, если одно из чисел равно 0, поскольку произведение становится 0 независимо от другого числа.

2) Оба арифметических решения могут вызвать арифметическое переполнение. Если x и y слишком велики, сложение и умножение могут выйти за пределы целочисленного диапазона.

3) Когда мы используем указатели на переменную и выполняем замену функций, все вышеперечисленные методы не работают, когда оба указателя указывают на одну и ту же переменную. Давайте посмотрим, что произойдет в этом случае, если оба будут указывать на одну и ту же переменную.

// Побитовый метод на основе XOR

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

// Метод на основе арифметики

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

Посмотрим на следующую программу.

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

Выход :

После обмена (& x, & x): x = 0

Замена переменной самой собой может потребоваться во многих стандартных алгоритмах. Например, посмотрите эту реализацию QuickSort, где мы можем поменять местами переменную с собой. Вышеупомянутой проблемы можно избежать, поставив условие перед заменой.

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

Выход :

После обмена (& x, & x): x = 10

Может быть, не по теме, но если вы знаете, что меняете одну переменную между двумя разными значениями, вы можете выполнить логику массива. Каждый раз, когда эта строка кода запускается, она меняет значение между 1 и 2.

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

Вы могли сделать:

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

Или используйте make_tuple при замене более двух переменных:

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

Но я не уверен, использует ли std :: tie внутреннюю временную переменную или нет!

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

Обратите внимание на время выполнения обоих вариантов.

Запустив этот код, я измерил его.

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

Как вы можете видеть (и как многие говорили), замена на месте (xor) занимает намного больше времени, чем другой вариант с использованием временной переменной.

В R отсутствует параллельное задание, предложенное Эдсгером В. Дейкстра в «Дисциплина программирования» , 1976, глава 4, стр.29. Это позволило бы найти элегантное решение:

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

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

Это очень просто, но может вызвать предупреждение.

однострочное решение для замены двух значений на языке 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;