# An Algorithm to Swap Two Variables Synchronously, Without Creating a Temporary Variable

• March 23, 2021

## Introduction

Let's say you want to swap the values of two integer variables, `a`, and `b`. Simply setting `a` equal to `b` and then `b` equal to `a` does not work, since `a` and `b` would just end up both equaling the initial value of `b`.

``````# doesn't work (both a and b end up equaling b):
a = b
b = a``````

So, typically, you'd create another variable — let's call it `c` — and set that variable to the value of `a`, and then do something like this:

``````# the simplest solution, with a temporary variable:
c = a
a = b
b = c``````

This is very simple, but the extra variable is not actually necessary.

Note that some programming languages, for example Python, provide the ability to swap two variables in a single line, like `a, b = b, a`. I will explain how to swap two variables without a temporary variable without utilizing this feature.

## The Algorithm

By summing the two variables and adding a few subtraction operations, this same swapping operation can be done without a temporary variable, like this:

``````a = a + b
b = a - b
a = a - b``````

To see that this works, let's test it out with `a = 100` and `b = 5`.

``````a = a + b # a = 100 + 5 = 105
b = a - b # b = 105 - 5 = 100
a = a - b # a = 105 - 100 = 5``````

As we can see, after running these operations, `a = 5` and `b = 100`, so the values were swapped, as expected.

This can also be similarly done with multiplication and division, like this:

``````a = a * b
b = a / b
a = a / b``````

This version is generally less efficient because most (if not all) programming languages take longer to calculate products and quotients in comparison to sums and differences.

## Conclusion

Overall, this is an interesting algorithm that can be used in programs where you are swapping two integer values. Since it only saves a very small amount of space by not creating the temporary variable, it is not particularly useful in smaller projects and programs. However, on a larger scale when working with millions of variables and values at a time, and you'd like to save as much space and storage as possible, this can be useful.

I hope you enjoyed this article and found this to be an interesting algorithm.

Thanks for scrolling.

— Gabriel Romualdo, March 23, 2021