An Algorithm to Swap Two Variables Synchronously, Without Creating a Temporary Variable
Tags: algorithms, python
Published: 2021-03-24 02:19:34

---
title: "An Algorithm to Swap Two Variables Synchronously, Without Creating a Temporary Variable"
published: true
description: "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. 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. 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"
tags: #algorithms, #python
cover_image: "https://xtrp.io/api/content/static_files/an-algorithm-to-swap-two-variables-synchronously-without-creating-a-temporary-variable/photo_dev.jpg?t=1"

---

## 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`.

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

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

```python
# 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:

```python
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`.

```python
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:

```python
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.

*&mdash; Gabriel Romualdo, March 23, 2021*