 Open in App
Not now

# How to swap two numbers without using a temporary variable?

• Difficulty Level : Easy
• Last Updated : 13 Dec, 2022

Given two variables, x, and y, swap two variables without using a third variable. Method 1 (Using Arithmetic Operators)

The idea is to get a sum in one of the two given numbers. The numbers can then be swapped using the sum and subtraction from the sum.

## C++

 `// C++ Program to swap two numbers  without` `// using temporary variable` `#include ` `using` `namespace` `std;`   `int` `main()` `{` `    ``int` `x = 10, y = 5;`   `    ``// Code to swap 'x' and 'y'` `    ``x = x + y; ``// x now becomes 15` `    ``y = x - y; ``// y becomes 10` `    ``x = x - y; ``// x becomes 5` `    ``cout << ``"After Swapping: x ="` `<< x << ``", y="` `<< y;` `}`   `// This code is contributed by mohit kumar.`

## C

 `#include ` `int` `main()` `{` `    ``int` `x = 10, y = 5;`   `    ``// Code to swap 'x' and 'y'` `    ``x = x + y; ``// x now becomes 15` `    ``y = x - y; ``// y becomes 10` `    ``x = x - y; ``// x becomes 5`   `    ``printf``(``"After Swapping: x = %d, y = %d"``, x, y);`   `    ``return` `0;` `}`

## Java

 `// Java Program to swap two numbers  without` `// using temporary variable` `import` `java.io.*;`   `class` `Geeks {`   `    ``public` `static` `void` `main(String a[])` `    ``{` `        ``int` `x = ``10``;` `        ``int` `y = ``5``;` `        ``x = x + y;` `        ``y = x - y;` `        ``x = x - y;` `        ``System.out.println(``"After swapping:"` `                           ``+ ``" x = "` `+ x + ``", y = "` `+ y);` `    ``}` `}`   `// This code is contributed by Mayank Tyagi`

## Python3

 `x ``=` `10` `y ``=` `5`   `# Code to swap 'x' and 'y'`   `# x now becomes 15` `x ``=` `x ``+` `y`   `# y becomes 10` `y ``=` `x ``-` `y`   `# x becomes 5` `x ``=` `x ``-` `y` `print``(``"After Swapping: x ="``, x, ``" y ="``, y)`   `# This code is contributed` `# by Sumit Sudhakar`

## C#

 `// Program to swap two numbers  without` `// using temporary variable` `using` `System;`   `class` `GFG {` `    ``public` `static` `void` `Main()` `    ``{` `        ``int` `x = 10;` `        ``int` `y = 5;`   `        ``x = x + y;` `        ``y = x - y;` `        ``x = x - y;` `        ``Console.WriteLine(``"After swapping: x = "` `+ x` `                          ``+ ``", y = "` `+ y);` `    ``}` `}`   `// This code is contributed by Sam007`

## PHP

 ``

## Javascript

 ``

Output

`After Swapping: x =5, y=10`

Time Complexity: O(1).
Auxiliary Space: O(1).

Multiplication and division can also be used for swapping.

## C++

 `// C++ Program to swap two numbers without using temporary` `// variable` `#include ` `using` `namespace` `std;`   `int` `main()` `{ ``// NOTE - for this code to work in a generalised sense, y` `  ``// !- 0 to prevent zero division` `    ``int` `x = 10, y = 5;`   `    ``// Code to swap 'x' and 'y'` `    ``x = x * y; ``// x now becomes 50` `    ``y = x / y; ``// y becomes 10` `    ``x = x / y; ``// x becomes 5` `    ``cout << ``"After Swapping: x ="` `<< x << ``", y="` `<< y;` `}`   `// This code is contributed by Aditya Kumar (adityakumar129)`

## C

 `// C Program to swap two numbers without using temporary` `// variable` `#include ` `int` `main()` `{` `    ``int` `x = 10, y = 5;`   `    ``// Code to swap 'x' and 'y'` `    ``x = x * y; ``// x now becomes 50` `    ``y = x / y; ``// y becomes 10` `    ``x = x / y; ``// x becomes 5`   `    ``printf``(``"After Swapping: x = %d, y = %d"``, x, y);`   `    ``return` `0;` `}`   `// This code is contributed by Aditya Kumar (adityakumar129)`

## Java

 `// Java Program to swap two numbers without using temporary` `// variable` `import` `java.io.*;`   `class` `GFG {` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``int` `x = ``10``;` `        ``int` `y = ``5``;`   `        ``// Code to swap 'x' and 'y'` `        ``x = x * y; ``// x now becomes 50` `        ``y = x / y; ``// y becomes 10` `        ``x = x / y; ``// x becomes 5`   `        ``System.out.println(``"After swapping:"` `                           ``+ ``" x = "` `+ x + ``", y = "` `+ y);` `    ``}` `}`   `// This code is contributed by Aditya Kumar (adityakumar129)`

## Python3

 `# Python3 program to ` `# swap two numbers` `# without using ` `# temporary variable` `x ``=` `10` `y ``=` `5`   `# code to swap ` `# 'x' and 'y'`   `# x now becomes 50` `x ``=` `x ``*` `y`   `# y becomes 10` `y ``=` `x ``/``/` `y; `   `# x becomes 5` `x ``=` `x ``/``/` `y; `   `print``(``"After Swapping: x ="``, ` `              ``x, ``" y ="``, y);`   `# This code is contributed ` `# by @ajit`

## C#

 `// C# Program to swap two` `// numbers without using` `// temporary variable` `using` `System;`   `class` `GFG {` `    ``static` `public` `void` `Main()` `    ``{` `        ``int` `x = 10;` `        ``int` `y = 5;`   `        ``// Code to swap 'x' and 'y'` `        ``x = x * y; ``// x now becomes 50` `        ``y = x / y; ``// y becomes 10` `        ``x = x / y; ``// x becomes 5`   `        ``Console.WriteLine(``"After swapping:"` `                          ``+ ``" x = "` `+ x + ``", y = "` `+ y);` `    ``}` `}`   `// This code is contributed by ajit.`

## PHP

 ``

## Javascript

 ``

Output

`After Swapping: x =5, y=10`

Time Complexity: O(1).
Auxiliary Space: O(1).

Method 2 (Using Bitwise XOR)
The bitwise XOR operator can be used to swap two variables. The XOR of two numbers x and y returns a number that has all the bits as 1 wherever bits of x and y differ. For example, XOR of 10 (In Binary 1010) and 5 (In Binary 0101) is 1111, and XOR of 7 (0111) and 5 (0101) is (0010).

## C++

 `// C++ code to swap using XOR` `#include `   `using` `namespace` `std;`   `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)` `    ``cout << ``"After Swapping: x ="` `<< x << ``", y="` `<< y;` `    ``return` `0;` `}`   `// This code is contributed by mohit kumar.`

## C

 `// C code to swap using XOR` `#include ` `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;` `}`

## Java

 `// Java code to swap using XOR` `import` `java.io.*;`   `public` `class` `GFG {`   `    ``public` `static` `void` `main(String a[])` `    ``{` `        ``int` `x = ``10``;` `        ``int` `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)`   `        ``System.out.println(``"After swap: x = "` `                           ``+ x + ``", y = "` `+ y);` `    ``}` `}`   `// This code is contributed by Mayank Tyagi`

## Python3

 `# Python3 code to swap using XOR`   `x ``=` `10` `y ``=` `5`   `# Code to swap 'x' and 'y'` `x ``=` `x ^ y; ``# x now becomes 15 (1111)` `y ``=` `x ^ y; ``# y becomes 10 (1010)` `x ``=` `x ^ y; ``# x becomes 5 (0101)`   `print` `(``"After Swapping: x = "``, x, ``" y ="``, y)`   `# This code is contributed by` `# Sumit Sudhakar`

## C#

 `// C# program to swap using XOR` `using` `System;`   `class` `GFG {` `    ``public` `static` `void` `Main()` `    ``{` `        ``int` `x = 10;` `        ``int` `y = 5;`   `        ``// Code to swap 'x' (1010)` `        ``// and 'y' (0101)`   `        ``// x now becomes 15 (1111)` `        ``x = x ^ y;`   `        ``// y becomes 10 (1010)` `        ``y = x ^ y;`   `        ``// x becomes 5 (0101)` `        ``x = x ^ y;`   `        ``Console.WriteLine(``"After swap: x = "` `+ x + ``", y = "` `+ y);` `    ``}` `}`   `// This code is contributed by ajit`

## PHP

 ``

## Javascript

 ``

Output

`After Swapping: x =5, y=10`

Time Complexity: O(1).
Auxiliary Space: O(1).

Problems with the above methods
1) The multiplication and division-based approach doesn’t work if one of the numbers is 0 as the product becomes 0 irrespective of the other number.
2) Both Arithmetic solutions may cause an arithmetic overflow. If x and y are too large, addition and multiplication may go out of the integer range.
3) When we use pointers to variable and make a function swap, all the above methods fail when both pointers point to the same variable. Let’s take a look at what will happen in this case if both are pointing to the same variable.

// Bitwise XOR based method
x = x ^ x; // x becomes 0
x = x ^ x; // x remains 0
x = x ^ x; // x remains 0
// Arithmetic based method
x = x + x; // x becomes 2x
x = x – x; // x becomes 0
x = x – x; // x remains 0

Let us see the following program.

## C++

 `#include ` `using` `namespace` `std;` `void` `swap(``int``* xp, ``int``* yp)` `{` `    ``*xp = *xp ^ *yp;` `    ``*yp = *xp ^ *yp;` `    ``*xp = *xp ^ *yp;` `}`   `// Driver code` `int` `main()` `{` `    ``int` `x = 10;` `    ``swap(&x, &x);` `    ``cout << ``"After swap(&x, &x): x = "` `<< x;` `    ``return` `0;` `}`   `// This code is contributed by rathbhupendra`

## C

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

## Java

 `class` `GFG {` `    ``static` `void` `swap(``int``[] xp, ``int``[] yp)` `    ``{` `        ``xp[``0``] = xp[``0``] ^ yp[``0``];` `        ``yp[``0``] = xp[``0``] ^ yp[``0``];` `        ``xp[``0``] = xp[``0``] ^ yp[``0``];` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``int``[] x = { ``10` `};` `        ``swap(x, x);` `        ``System.out.println(``"After swap(&x, &x): x = "` `+ x[``0``]);` `    ``}` `}`   `// This code is contributed by Aditya Kumar (adityakumar129)`

## Python3

 `def` `swap(xp, yp):`   `    ``xp[``0``] ``=` `xp[``0``] ^ yp[``0``]` `    ``yp[``0``] ``=` `xp[``0``] ^ yp[``0``]` `    ``xp[``0``] ``=` `xp[``0``] ^ yp[``0``]`     `# Driver code` `x ``=` `[``10``]` `swap(x, x)` `print``(``"After swap(&x, &x): x = "``, x[``0``])`   `# This code is contributed by SHUBHAMSINGH10`

## C#

 `// C# program to implement` `// the above approach` `using` `System;` `class` `GFG {`   `    ``static` `void` `swap(``int``[] xp, ``int``[] yp)` `    ``{` `        ``xp = xp ^ yp;` `        ``yp = xp ^ yp;` `        ``xp = xp ^ yp;` `    ``}`   `    ``// Driver code` `    ``static` `void` `Main()` `    ``{` `        ``int``[] x = { 10 };` `        ``swap(x, x);` `        ``Console.WriteLine(``"After swap(&x,"` `                          ``+ ``"&x): x = "` `+ x);` `    ``}` `}`   `// This code is contributed by divyeshrabadiya07`

## PHP

 ``

## Javascript

 ``

Output

`After swap(&x, &x): x = 0`

Time Complexity: O(1).
Auxiliary Space: O(1).

Swapping a variable with itself may be needed in many standard algorithms. For example, see this implementation of QuickSort where we may swap a variable with itself. The above problem can be avoided by putting a condition before swapping.

## C++

 `#include ` `using` `namespace` `std;` `void` `swap(``int``* xp, ``int``* yp)` `{`   `    ``// Check if the two addresses are same` `    ``if` `(xp == yp)` `        ``return``;` `    ``*xp = *xp + *yp;` `    ``*yp = *xp - *yp;` `    ``*xp = *xp - *yp;` `}`   `// Driver Code` `int` `main()` `{` `    ``int` `x = 10;` `    ``swap(&x, &x);` `    ``cout << ``"After swap(&x, &x): x = "` `<< x;` `    ``return` `0;` `}`   `// This code is contributed by rathbhupendra`

## C

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

## Java

 `// Java program of above approach` `class` `GFG {`   `    ``static` `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;` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``int` `x = ``10``;` `        ``swap(x, x);` `        ``System.out.println(``"After swap(&x, &x): x = "` `+ x);` `    ``}` `}`   `// This code is Contributed by Code_Mech.`

## Python3

 `# Python3 program of above approach` `def` `swap(xp, yp):`   `    ``# Check if the two addresses are same` `    ``if` `(xp[``0``] ``=``=` `yp[``0``]):` `        ``return` `    ``xp[``0``] ``=` `xp[``0``] ``+` `yp[``0``]` `    ``yp[``0``] ``=` `xp[``0``] ``-` `yp[``0``]` `    ``xp[``0``] ``=` `xp[``0``] ``-` `yp[``0``]`     `# Driver Code` `x ``=` `[``10``]` `swap(x, x)` `print``(``"After swap(&x, &x): x = "``, x[``0``])`   `# This code is contributed by SHUBHAMSINGH10`

## C#

 `// C# program of above approach` `using` `System;` `class` `GFG {`   `    ``static` `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;` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `Main()` `    ``{` `        ``int` `x = 10;` `        ``swap(x, x);` `        ``Console.WriteLine(``"After swap(&x, &x): x = "` `+ x);` `    ``}` `}`   `// This code is Contributed by Code_Mech.`

## PHP

 `

## Javascript

 ``

Output

`After swap(&x, &x): x = 10`

Time Complexity: O(1).
Auxiliary Space: O(1).

Method 3 (A mixture of bitwise operators and arithmetic operators)
The idea is the same as discussed in Method 1 but uses Bitwise addition and subtraction for swapping.

Below is the implementation of the above approach.

## C++

 `// C++ program to swap two numbers` `#include ` `using` `namespace` `std;`   `// Function to swap the numbers.` `void` `swap(``int``& a, ``int``& b)` `{` `    ``// same as a = a + b` `    ``a = (a & b) + (a | b);` `    ``// same as b = a - b` `    ``b = a + (~b) + 1;` `    ``// same as a = a - b` `    ``a = a + (~b) + 1;` `}`   `// Driver Code` `int` `main()` `{` `    ``int` `a = 5, b = 10;` `    ``// Function Call` `    ``swap(a, b);` `    ``cout << ``"After swapping: a = "` `<< a << ``", b = "` `<< b;` `    ``return` `0;` `}`   `// This code is contributed by Aditya Kumar (adityakumar129)`

## C

 `// C program to swap two numbers` `#include `   `// Function to swap the numbers.` `void` `swap(``int` `a, ``int` `b)` `{` `    ``// same as a = a + b` `    ``a = (a & b) + (a | b);` `    ``// same as b = a - b` `    ``b = a + (~b) + 1;` `    ``// same as a = a - b` `    ``a = a + (~b) + 1;` `      ``printf``(``"After swapping: a = %d , b = %d "``,a,b);` `}`   `// Driver Code` `int` `main()` `{` `    ``int` `a = 5, b = 10;` `    ``// Function Call` `    ``swap(a, b);` `    ``return` `0;` `}`   `// This code is contributed by Aditya Kumar (adityakumar129)`

## Java

 `// Java program to swap two numbers` `import` `java.io.*;`   `class` `GFG {` `    ``public` `static` `void` `swap(``int` `a, ``int` `b)` `    ``{` `        ``// same as a = a + b` `        ``a = (a & b) + (a | b);` `        ``// same as b = a - b` `        ``b = a + (~b) + ``1``;` `        ``// same as a = a - b` `        ``a = a + (~b) + ``1``;` `        ``System.out.print(``"After swapping: a = "` `+ a + ``", b = "` `+ b);` `    ``}` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``int` `a = ``5``, b = ``10``;` `        ``// Function Call` `        ``swap(a, b);` `    ``}` `}`   `// This code is contributed by Aditya Kumar (adityakumar129)`

## Python3

 `# Python3 program to swap two numbers`   `# Function to swap the numbers`     `def` `swap(a, b):`   `    ``# Same as a = a + b` `    ``a ``=` `(a & b) ``+` `(a | b)`   `    ``# Same as b = a - b` `    ``b ``=` `a ``+` `(~b) ``+` `1`   `    ``# Same as a = a - b` `    ``a ``=` `a ``+` `(~b) ``+` `1`   `    ``print``(``"After Swapping: a = "``, a, ``", b = "``, b)`     `# Driver code` `a ``=` `5` `b ``=` `10`   `# Function call` `swap(a, b)`   `# This code is contributed by bunnyram19`

## C#

 `// C# program to swap two numbers` `using` `System;` `class` `GFG {`   `    ``static` `void` `swap(``int` `a, ``int` `b)` `    ``{` `        ``// same as a = a + b` `        ``a = (a & b) + (a | b);`   `        ``// same as b = a - b` `        ``b = a + (~b) + 1;`   `        ``// same as a = a - b` `        ``a = a + (~b) + 1;`   `        ``Console.Write(``"After swapping: a = "` `+ a` `                      ``+ ``", b = "` `+ b);` `    ``}`   `    ``static` `void` `Main()` `    ``{` `        ``int` `a = 5, b = 10;`   `        ``// Function Call` `        ``swap(a, b);` `    ``}` `}`   `// This code is contributed by divyesh072019`

## Javascript

 ``

## PHP

 `"``);` `// same as a = a + b` `    ``\$a` `= (``\$a` `& ``\$b``) + (``\$a` `| ``\$b``);` ` `  `    ``// same as b = a - b` `    ``\$b` `= ``\$a` `+ (~``\$b``) + 1;` ` `  `    ``// same as a = a - b` `    ``\$a` `= ``\$a` `+ (~``\$b``) + 1;`   `echo``(``"After swap(a and b) "` `. ``\$a``. ``"and"``. ``\$b``);` `return` `0;`   `?>`

Output

`After swapping: a = 10, b = 5`

Time Complexity: O(1)

Auxiliary Space: O(1), since no extra space has been taken.

Method 4 (One Line Expression)

We can write only one line to swap two numbers.

• x = x ^ y ^ (y = x);
• x = x + y – (y = x);
• x = (x * y) / (y = x);
• x , y = y, x (In Python)

## C++

 `#include ` `using` `namespace` `std;` ` `  `int` `main(){` `    ``int` `x = 10, y = 5;` `    ``x = (x * y) / (y = x);` `    ``cout << x << ``" "` `<< y;` `    ``return` `0;` `}`   `// This code is contributed by isha307`

## C

 `#include `   `int` `main() {` `    ``int` `x = 10, y = 5;` `    ``x = (x * y) / (y = x);` `    ``printf``(``"After Swapping: x = %d, y = %d"``, x, y);` `    ``return` `0;` `}`   `// This code is contributed by isha307`

## Java

 `/*package whatever //do not write package name here */` `import` `java.io.*;`   `class` `GFG {` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``int` `x = ``10``;` `        ``int` `y = ``5``;` `        ``x = (x * y) / (y = x);` `        ``System.out.println(``"After swapping:"` `                           ``+ ``" x = "` `+ x + ``", y = "` `+ y);` `    ``}` `}`   `// This code is contributed by isha307`

## Python3

 `# Python3 program to swap two numbers`   `# Function to swap the numbers ` `def` `swap(x, y):` `  ``x , y ``=` `y, x ` `  ``print``(``"After Swapping: x = "``, x, ``", y = "``, y)` `  `  `# Driver code` `x ``=` `10` `y ``=` `5` ` `  `# Function call` `swap(x, y)` ` `  `# This code is contributed by kothavvsaakash`

## C#

 `// C# program to swap two numbers`   `using` `System;`   `public` `class` `GFG` `{` `    ``static` `public` `void` `Main ()` `    ``{` `        ``int` `x = 10;` `        ``int` `y = 5;` `        ``x = (x * y) / (y = x);` `        ``Console.Write(``"After swapping:"`  `+ ``" x = "` `+ x + ``", y = "` `+ y);` `    ``}` `}`   `// This code is contributed by kothavvsaakash`

## Javascript

 ``

Output

`5 10`

Time Complexity: O(1)

Auxiliary Space: O(1)