Here's my code snippet showing how we can swap two numbers without using temporary variable at coderseditor.com/?id=185

using System;

namespace CodeSample
{
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Swap Number Sample");
int number1, number2;
Console.WriteLine("Enter the First Number : ");
number1 = int.Parse(Console.ReadLine());
Console.WriteLine("Enter the Second Number : ");
number2 = int.Parse(Console.ReadLine());
number1 = number1 - number2;
number2 = number1 + number2;
number1 = number2 - number1;
Console.WriteLine("First Number is " + number1);
Console.WriteLine("Second Number is " + number2);
Console.Read();
}
}
}

Here's a warm-up interview question that I ask every candidate.

I've seen this question come up a lot, along with fizzbuzz or "write a sorting function" and I'm not sure it's useful anymore.

It's a purely academic problem that touches on several different concepts, none of which are going to be used by 99% of programmers these days.

Why do you ask this question? What do people's different answers tell you, or are you more looking for how people attempt to solve it (if they've not heard it before) or how quickly they regurgitate a stock solution (if they have?)

If I asked this, and someone answered quickly (they already know why the dead man in the desert is lying next to an unopened pack...) then I'd follow up with something asking when they had ever had to do this in real life, or even if they could come up with three examples of situations where it would be a useful thing to do in real life. If they couldn't, then I don't think I would have learned anything useful about them.

What do you get out of it?

JAVA

int a=5;
int b=10;
a=a+b;
b=a-b;
a=a-b;
System.out.println(a);//10
System.out.println(b);//5
String s1="java1";
String s2="java2";
s1=s1+s2;
s2=s1.substring(0,(s1.length()-s2.length()));
s1=s1.substring(s2.length());
System.out.println(s1);//java2
System.out.println(s2);//java1

If there are two variables a and b we could destructure them.

var a = 12;
var b = 21;
[a, b] = [b, a];

Values are interchanged :)

A = 00000000000000000000000000101010
B = 00000000000000000000000001111110

A = A or B = 00000000000000000000000001111110
B = A and B = 00000000000000000000000000101010

With non-blocking assignment to describe hardware in Verilog:

x <= y;
y <= x;

asic-world.com/tidbits/blocking.html

No need to go very far... and it will never cause overflow

x.__proto__.y = y
y.__proto__.x = x
x = x.y 
y = y.x

Move data to upper and lower RAX then ROL by 32

Your comments appear incorrect.

y = y-x is basically the difference between y and x and not -x.

You might want to try this solution in code for correctness.

The Law of Gravity is also just an observation :)

if (y > x){
x += (y-x)/2;
y = 2*(y-x)
x += x-y

}
else if (y < x){
y += (y-x)/2;
x = 2*(y-x)
y += x-y

}

Probably not the best way ...

By using the ES6 destructuring assignment, that's how I would do it.

You could use the K combinator to swap any value, not just numbers!

let a = "hello"
let b = "goodbye"

a = (x => () => x)(b)(b = a)

a // => "goodbye"
b // => "hello"