## DEV Community is a community of 623,823 amazing developers

We're a place where coders share, stay up-to-date and grow their careers. # An Algorithm to Swap Two Variables Synchronously, Without Creating a Temporary Variable Gabriel Romualdo Originally published at xtrp.io ・2 min read

Originally published here at xtrp.io, my blog about computer science and just about anything programming.

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

This post is originally from my blog at xtrp.io.

— Gabriel Romualdo, March 23, 2021

## Discussion (11)  Roman

Hello,
Nice article and correct algo. But while you are using python here, there is a trick about this. Python supports tuple assignments. it means you can swap the values with just:

``````a, b = b, a
`````` Ben Sinclair

I can't imagine this being useful even at an enormous scale unless you're talking about processing millions of threads, and if you're doing that, you presumably have a spare megabyte or two of RAM to cope with it.

All it really does is obfuscate the code a little. It's an interesting puzzle for people who are learning about algorithms but it has no role in the real world except for that one programmer your friend met one time. Mundo

It might be some close to metal thing that needs to happen in metofs we use daily.

I can see the benefit of not needing to reservu, use and clean up some variable, remmber io ooerations are slower than just adding and subtracting. thecosmicsound1

Interesting algo. Liked the creative approach - can be a good trick interview question. One case where it won't work, for example with ints in Java, a and b are very large ints and summing them would cause an overflow. Pavel Morava

Nice article. Now it comes the challenge:

Switch these two variables using that method:

``````a = "Hello"
b = "World"
``````

I am genuinely curious if you can manage it.