Üçüncü değişkeni kullanmadan iki değişken değeri değiştirme

Bir röportajda sorulan çok zor sorulardan biri.

Gibi iki değişkenin değerlerini karşılıklı a=10ve b=15.

Genellikle iki değişken değerini takas etmek için 3. değişkene ihtiyacımız var:

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

Şimdi şart, 3. değişkeni kullanmadan iki değişkenin değerlerini değiştirmektir.

Xor takas algoritmasını kullanma

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

Neden test?

Test, x ve y'nin farklı bellek konumlarına sahip olmasını sağlamaktır (farklı değerler yerine). Bunun nedeni (p xor p) = 0ve eğer hem x hem de y aynı bellek konumunu paylaşıyorsa, biri 0 olarak ayarlandığında her ikisinin de 0'a ayarlanmasıdır. Hem * x hem de * y 0 olduğunda, * x ve * y üzerindeki diğer tüm xor işlemleri eşit olacaktır 0 (aynı olduklarından), bu, işlevin hem * x hem de * y'yi 0 olarak ayarlayacağı anlamına gelir.

Aynı değerlere sahipler ancak aynı bellek konumuna sahip değillerse, her şey beklendiği gibi çalışır

*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

Bu kullanılmalı mı?

Genel durumlarda hayır. Derleyici geçici değişkeni optimize edecek ve takasın yaygın bir prosedür olduğu göz önüne alındığında, platformunuz için optimum makine kodunu üretmesi gerekir.

Örneğin C ile yazılmış bu hızlı test programını ele alalım.

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

Kullanılarak derlendi:

gcc -Os main.c -o swap

Xor sürümü alır

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

Geçici değişkenli sürümün aldığı yer:

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

genel biçim:

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

ancak, potansiyel olarak taşmalara dikkat etmeniz gerekir ve ayrıca tüm işlemlerin, işlemin tanımlandığı tüm değerler için iyi tanımlanmış bir tersi yoktur. örneğin * ve / A veya B 0 olana kadar çalış

xor, tüm ints için tanımlandığı ve kendi tersi olduğu için özellikle sevindiricidir

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

Henüz kimse kullanılmasını std::swapönermedi.

std::swap(a, b);

Ben geçici değişkenler kullanmak ve türüne bağlı olarak yok ave buygulanması ya değil bir specalization sahip olabilir. Uygulama, bir "hile" nin uygun olup olmadığı bilerek yazılmalıdır. İkinci tahminde bulunmanın bir anlamı yok.

Daha genel olarak, ADL'nin mümkünse daha iyi bir aşırı yükleme bulmasını sağlayan sınıf türleri için işe yarayacağı için muhtemelen böyle bir şey yapmak isterdim.

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

Tabii ki, görüşmecinin bu cevaba tepkisi, boşluk hakkında çok şey söyleyebilir.

Manu tarafından daha önce belirtildiği gibi, XOR algoritması, tüm tamsayı değerleri için çalışan popüler bir algoritmadır (daha sonra, biraz şans ve döküm ile işaretçiler içerir). Tamlık adına toplama / çıkarma ile daha az güçlü başka bir algoritmadan bahsetmek istiyorum:

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

Burada taşmalara / yetersizliklere karşı dikkatli olmalısınız, ancak aksi takdirde o kadar iyi çalışır. XOR'a bunlarda izin verilmemesi durumunda, bunu float / double üzerinde deneyebilirsiniz.

Aptalca sorular uygun cevapları hak eder:

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

registerAnahtar kelimenin tek iyi kullanımı .

Üçüncü değişkeni kullanarak iki sayıyı değiştirmek şöyle olur,

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

Üçüncü değişkeni kullanmadan iki sayının yerini değiştirme

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

Orijinal çözüm şu olduğundan:

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

Şunları kullanarak iki astar yapabilirsiniz:

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

Ardından şunları kullanarak tek astar yapın:

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

Değişkenler yerine 2 montaj yazmacı hakkında sormak için soruyu biraz değiştirirseniz, xchgişlemi bir seçenek olarak ve yığın işlemini başka bir seçenek olarak da kullanabilirsiniz .

Düşünün a=10, b=15:

Toplama ve Çıkarmayı Kullanma

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

Bölmeyi ve çarpmayı kullanma

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

Güncelleme: Bunda kullanıcıdan iki tamsayı girdisi alıyoruz. Sonra bunları takas etmek için bitsel XOR işlemini kullanıyoruz .

İki tamsayılar olduğunu varsayalım a=4ve b=9daha sonra ve:

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

İşte bir çözüm daha ama tek bir risk.

kod:

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

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

a + 1 konumundaki herhangi bir değer geçersiz kılınır.

Elbette, C ++ yanıtı olmalıdır std::swap.

Bununla birlikte, aşağıdaki uygulamada üçüncü bir değişken de yoktur swap:

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

Veya tek astar olarak:

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

bu doğru XOR takas algoritmasıdır

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

bellek konumlarının farklı olduğundan ve ayrıca gerçek değerlerin farklı olduğundan emin olmalısınız çünkü A XOR A = 0

Yapabilirsin .... kolay bir şekilde ... tek satırda Mantık

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

veya

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

En iyi cevap XOR kullanmaktır ve onu tek satırda kullanmak harika olur.

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

x, y değişkenlerdir ve aralarındaki virgül sıra noktalarını tanıtarak derleyiciye bağımlı hale gelmez. Şerefe!

Üçüncü değişkeni kullanmadan iki sayıyı değiştirmek için basit bir c örneği görelim.

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

Çıktı:

Takas öncesi a = 10 b = 20 Takas sonrası a = 20 b = 10

Program 2: * ve / kullanma

* Ve / kullanarak iki sayıyı değiştirmek için başka bir örnek görelim.

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

Çıktı:

Takas öncesi a = 10 b = 20 Takas sonrası a = 20 b = 10

Program 3: Bitsel XOR operatörünün kullanılması:

Bitsel XOR operatörü iki değişkeni takas etmek için kullanılabilir. X ve y sayısının XOR'u, x ve y bitlerinin farklı olduğu yerlerde tüm bitleri 1 olan bir sayıyı döndürür. Örneğin, XOR of 10 (In Binary 1010) and 5 (In Binary 0101) is 1111 and XOR of 7 (0111) and 5 (0101) is (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;

Çıktı:

Değiştirmeden Sonra: x = 5, y = 10

Program 4:

Henüz kimse std :: swap kullanmayı önermedi.

std::swap(a, b);

Herhangi bir geçici değişken kullanmıyorum ve a ve b'nin türüne bağlı olarak uygulamanın da olmayan bir uzmanlığı olabilir. Uygulama, bir "hile" nin uygun olup olmadığı bilerek yazılmalıdır.

Yukarıdaki yöntemlerle ilgili sorunlar:

1) Çarpma ve bölme tabanlı yaklaşım, sayılardan biri 0 ise, ürün diğer sayıdan bağımsız olarak 0 olurken çalışmaz.

2) Her iki Aritmetik çözüm de aritmetik taşmaya neden olabilir. X ve y çok büyükse, toplama ve çarpma tamsayı aralığının dışına çıkabilir.

3) Bir değişkene işaretçi kullandığımızda ve bir işlev değişimi yaptığımızda, her iki işaretçi de aynı değişkeni gösterdiğinde yukarıdaki yöntemlerin tümü başarısız olur. Her ikisi de aynı değişkeni gösteriyorsa, bu durumda ne olacağına bir bakalım.

// Bitsel XOR tabanlı yöntem

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

// Aritmetik tabanlı yöntem

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

Aşağıdaki programı görelim.

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

Çıktı :

Değiştirmeden sonra (& x, & x): x = 0

Birçok standart algoritmada bir değişkeni kendisiyle değiştirmek gerekebilir. Örneğin, bir değişkeni kendisiyle değiştirebileceğimiz QuickSort uygulamasına bakın. Değişimden önce bir koşul koyarak yukarıdaki sorun önlenebilir.

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

Çıktı :

Değiştirmeden sonra (& x, & x): x = 10

Konu dışı olabilir, ancak tek bir değişkeni iki farklı değer arasında değiştirdiğinizi biliyorsanız, dizi mantığı yapabilirsiniz. Bu kod satırı her çalıştırıldığında, değeri 1 ile 2 arasında değiştirecektir.

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

Yapabilirsin:

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

Veya ikiden fazla değişkeni takas ederken make_tuple kullanın:

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

Ama dahili olarak std :: tie geçici bir değişken kullanıyor mu emin değilim!

JavaScript'te:

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
}

Her iki seçeneğin de uygulama süresine dikkat edin.

Bu kodu çalıştırarak ölçtüm.

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

Gördüğünüz gibi (ve birçoklarının söylediği gibi), yerinde takas (xor), temp değişkenini kullanan diğer seçenekten çok daha fazla zaman alır.

R , Edsger W. Dijkstra tarafından A Discipline of Programming , 1976, bölüm 4, s. 29'da önerildiği gibi eşzamanlı bir atama eksiktir . Bu, zarif bir çözüme izin verir:

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

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

Çok basit, ancak bir uyarı oluşturabilir.

c dilinde iki değeri takas etmek için tek satırlık çözüm.

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

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