## 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*