[Question]
  [
Imagine travelling to a point lying **A** miles away horizontally and **B** miles away vertically from your current position. Or in other words, travelling from `(0, 0)` to point `(a, b)`. How far would you need to end up travelling? This seems like a straightforward question, but the answer depends on who you ask. If you're a crow, and you can travel *as the crow flies*, the distance travelled is just the [Euclidean distance](https://en.wikipedia.org/wiki/Euclidean_distance) to `(a, b)`. This is
```
sqrt(a^2 + b^2)
```
But if you're just a boring human, you don't really want to walk that far, so you'll need to take a taxi. Most taxis wont drive in a straight line towards your destination because they generally try to stay on the roads. So the real distance you'll end up travelling is the sum of the vertical distance and the horizontal distance. Or the formula is:
```
abs(a) + abs(b)
```
This is called the [Taxicab Distance](https://en.wikipedia.org/wiki/Taxicab_geometry). This picture nicely demonstrates the difference between the two:
[![enter image description here](https://i.stack.imgur.com/PwxcY.jpg)](https://i.stack.imgur.com/PwxcY.jpg)
To travel to `(6, 6)`, a crow can just fly on the green line, and this gives a distance of `6 * sqrt(2)` or roughly 8.49. A taxicab can take the red, blue or yellow paths, but they will all take 12.
This leads to the real question I'm asking. If a crow and a taxicab both leave from point `(0, 0)`, and travel to point `(a, b)`, how much longer is the taxicab's path? Or, in more math jargon,
> 
> Given a two dimensional vector, determine the difference between the norm2 of the vector, and the norm1 of the vector.
> 
> 
> 
You must write the shortest possible program or function to answer this question. You may choose to take 'a' and 'b' as two separate inputs, or as a two item tuple. You can take input and output in any reasonable format. If the difference is a non integer, you must be accurate to at least two decimal places. 
You can always assume that 'a' and 'b' will be integers, and that they won't both be 0. (Though it is possible that either one of them will be zero)
As usual, standard loopholes apply and try to make your program as short as possible, counted in bytes.
I will upvote any answer that posts an explanation of how the code works, and demonstrates any cool tricks used to save bytes. 
Here are some examples for you to test your code on:
```
#input    #output
3, 4      2
-3, 4     2
-3, -4    2
6, 6      3.51
42, 0     0
10, 10    5.86
3, 3      1.76
```
Have fun golfing! :)
  
[Answer]
# [Taxi](http://esolangs.org/wiki/Taxi), ~~7394~~ 3773 bytes
```
Go to Post Office:w 1 l 1 r 1 l.Pickup a passenger going to Tom's Trims.Pickup a passenger going to Tom's Trims.Go to Tom's Trims:n.[a]Pickup a passenger going to The Babelfishery.Go to The Babelfishery:s 1 l 1 r.Pickup a passenger going to Cyclone.Go to Cyclone:n 1 l 1 l 2 r.Pickup a passenger going to Addition Alley.Pickup a passenger going to Multiplication Station.1 is waiting at Starchild Numerology.Go to Starchild Numerology:s 2 l 2 r.Pickup a passenger going to Cyclone.Go to Cyclone:w 1 r 4 l.Pickup a passenger going to Addition Alley.Go to Addition Alley:n 2 r 1 r.Pickup a passenger going to The Underground.Go to Cyclone:n 1 l 1 l.Pickup a passenger going to Multiplication Station.Go to The Underground:n 2 r 2 r.Switch to plan "b" if no one is waiting.Pickup a passenger going to Charboil Grill.Go to Charboil Grill:s 2 r 1 l 1 l 2 r.-1 is waiting at Starchild Numerology.Go to Starchild Numerology:e 2 r.Pickup a passenger going to Multiplication Station.Go to The Underground:w 1 r 2 r 1 r 2 l.[b]Go to Multiplication Station:s 1 l 1 r.Go to Tom's Trims:s 1 r 3 r.Switch to plan "c" if no one is waiting.Switch to plan "a".[c]Go to Multiplication Station:s 1 l 3 l.Pickup a passenger going to Cyclone.Pickup a passenger going to Cyclone.Go to Cyclone:s 1 r 2 l 2 r.Pickup a passenger going to Addition Alley.Pickup a passenger going to Cyclone.Pickup a passenger going to Addition Alley.Go to Addition Alley:n 2 r 1 r.Pickup a passenger going to Multiplication Station.-1 is waiting at Starchild Numerology.Go to Starchild Numerology:n 1 l 1 l 1 l 3 l.Pickup a passenger going to Multiplication Station.Go to Multiplication Station:w 1 r 2 r 1 r 4 l.Pickup a passenger going to Rob's Rest.Go to Rob's Rest:s 1 r 2 l 1 l 1 r 1 r.Go to Cyclone:s 1 l 1 l 1 l 1 r.Pickup a passenger going to Cyclone.[d]Pickup a passenger going to Multiplication Station.Pickup a passenger going to Multiplication Station.Go to Multiplication Station:s 1 l 2 r 4 l.Pickup a passenger going to Addition Alley.Go to Cyclone:s 1 r 2 l 2 r.Switch to plan "e" if no one is waiting.Switch to plan "d".[e]Go to Addition Alley:n 2 r 1 r.Pickup a passenger going to Cyclone.99 is waiting at Starchild Numerology.Go to Starchild Numerology:n 1 l 1 l 1 l 3 l.Pickup a passenger going to The Underground.Go to Cyclone:e 1 l 2 r.Pickup a passenger going to Trunkers.Pickup a passenger going to Sunny Skies Park.Go to Sunny Skies Park:n 1 r.Go to Trunkers:s 1 l.[f]Pickup a passenger going to Cyclone.Go to Cyclone:w 2 r.Pickup a passenger going to Divide and Conquer.Pickup a passenger going to Trunkers.Go to Trunkers:s 1 l.Go to Sunny Skies Park:w 1 r.Pickup a passenger going to Cyclone.Go to Cyclone:n 1 l.Pickup a passenger going to Divide and Conquer.Go to Zoom Zoom:n.Go to Divide and Conquer:w 1 l 2 r 1 r.Pickup a passenger going to Addition Alley.Go to Cyclone:e 1 l 1 l 2 l.Pickup a passenger going to Addition Alley.Go to Addition Alley:n 2 r 1 r.Pickup a passenger going to Divide and Conquer.2 is waiting at Starchild Numerology.Go to Starchild Numerology:n 1 l 1 l 3 l 2 r.Pickup a passenger going to Divide and Conquer.Go to Divide and Conquer:w 1 r 2 r 1 r 2 l 3 l.Pickup a passenger going to Sunny Skies Park.Go to Sunny Skies Park:e 1 l 1 l 2 l 1 l.Go to The Underground:s 1 l 1 r 2 l.Switch to plan "g" if no one is waiting.Pickup a passenger going to The Underground.Go to Trunkers:s 2 r 1 l.Switch to plan "f".[g]Go to Rob's Rest:n 3 l 2 l 1 l 2 r 1 r.Pickup a passenger going to What's The Difference.Go to Sunny Skies Park:s 1 l 1 l.Pickup a passenger going to What's The Difference.Go to What's The Difference:n 1 r 1 l.Pickup a passenger going to The Babelfishery.Go to The Babelfishery:e 3 r.Pickup a passenger going to Post Office.Go to Post Office:n 1 l 1 r.
```
# [Try it online!](https://tio.run/##vVdNj5swEL33V4xy6alIm@xlc9vuSntqG21SVWrEwcAAVhw7tU1pfn3KZwIEjPOhPRAUY49n3nszHmvyjx4ObwK0gIVQGn6EIfVxnsIDsOyR@dtZUH@T7IDAjiiFPEIJkaA8yletxPazgpWkW2U9r9yvMTLnzpq4xuUxwlfiIQupilHuaxud4bmqHTc687L3meBYGan@zXm1lsF0ZP1zEFBNBYdnxnBvnPotYZruGPVJsWCpi7fzAFRBSjIr2TSi83Hpx5QF8D3ZohRMRHWMfZ@yOKcWfvbHmRbEPo4Q24mxNNEezBCbFhIxe5GT9JMHKCMpEh4MoX4NjCcVNDao3MrBWaZU@3E@Z8cIh4k3ARoCF5Dt3GDADGJMpCcogzdJGau9bw0WdMiWfL7cyjCOsnsRJiXpFV25eJy155ZT@@00Uuk8X1VhZdaDsD@AcHcemThr38aB2Ygyao1fngeqhuKe@W7jzv1Sa0ACN4vvVAptKDAKcYDcth7HitG78DLtvaPSldXTQIPG05kle6hmjceubK4D94qw742UqmvKdSW7X@3ddETLtA2ytEX3BsXW2D49fahEzWcQWp36K5nwDUpzn7NMON/DckNRwYLITR1CZ7hw/1hZK8Ml1c46dK851Mfcf6V/aYBAeAAvgv9J0DLaXh8Hokpvab0u9b408VuIbfEzr/PofGrVz9ro05hD2DjiP6p76gl8erfUmVnIfhD5AZxbXcZoYtrmSwv6hgS7fc6xayko6pav6Ir@r790NPKhav3ONguzWhm5Z@cVr1Bn1pr8FROdt16ZI680DFEi93EIKGXVT5tM9n4rC9b4ddDynoZF82iy1LiOOucXVH48yA@H2afH/w "Taxi – Try It Online")
[Engineer Toast](https://codegolf.stackexchange.com/users/38183/engineer-toast), a much more experienced Taxi golfer, decided to take some time (probably a lot less than I did) and golf down my Taxi program by basically rewriting it. You can find my old answer body and links to my old TIOs in the edit history.
Engineer Toast's ungolfed square root algorithm: [Try it online!](https://tio.run/##rVbbbhoxEH3nK0ap1CatujRErRTe0kSK@tA0KulLEUVmd2AtjL3xJQtv/ZZ@Wn8knfEutxQCSFkJErye8cyZM2fsxVQ@PnbhW/BF8ODug7AI1hgPZghCg9S83mt0Ife@cO1mE3VSyrEsMJMiMXbU5F/Nr@hzk7m@GfZTMyEbqUf9yl2f3blXn8VgpoyWQvcncTN5bXRvZToOBTifSd1rXBvwBm6N8/BtOJQptks4BUUfy3@TRr1dQCGcQz1CCyNDR7HZXY5Ah6AaSpejnSW1u6frbTf3@by/y1lK8WKyjNIECymtIqQmaI@WcPni3zhIcxQF2ZJVRmfm0tEXoUe/6VU6BhRpDpIshJdGk8WDUAFBOEDCSPFGT2Eq4Tz5vKOqQEr2RqsZkKOMjpR0IMXngAKh7a1fZ6fvT8EZOD9fenZAR7vA2EnUPuk1@K2DUkiuCAgPHS9smkuVwU2YoDXKjBZQbXrX1jVc1ae1Txl@6AztyBJIGcN3FQolU@GxqjPvGvD/xmLGGHQ4rjsb9Jjzo3R5cfohRhu0nkFnLNHBrbBjQkfAaxgA81SoUszcEhkCY@GlJJg95MF6dk8uZSyUMg6hlD6n4F1u6K0WE2TL@H5kiJdDw@kQXfRoTsmaC22sMdhBnXkUz@96mtuiCk/WYwXsgs6174rGDC9BLmPhmZ@OShhLXRgnmRJt2P5wX8Pf339guglr2PUszNcLuO@zMI98P9jD0pwYV3UAFY6Ysw8tIaqP6K2xs8M8KJF6mLkTqSKpH/cSiXWelLs5ciUfZIaRmpdG3wfcm1PbeHAl54lMI4czOsERA6qOyrJIh942kpUHKOJ6snq3Nm9KttG9pmKVUqmoBoEFVE4K6kmhPbBMMK2VMcU85p/GTOJXW0dVRktpTuB4Cu@g05yeNFvMieNm6wR8sJobwtdiI2CIJQxmntKNfc9qzRJ9/Db5eALzE/6Ps55ArTiBduBzUWMMF0rhLNmoHXtp6GZH66sE@15BbYK@9XIz4WwfPdwUw7OA23lujBWf8UJKulaDirbdG1Ny0@fiAeMQ1jj1y4nK96Apy8RlHOR@RWt6KxeMFWlZ3i@qQndo3ND0p42FIsIdDY5ADkEbmu64UoeDp@p3dOira8NKj6zIQmt@a3oagTgi@0Z3wGnVNz92Y9EF5bcKxMLhbs4dfhXb7XPlVphsuCjqRWSPj6ef/gE "Taxi – Try It Online")
Ungolfed, with explanations: 
```
[ Crow vs. Taxi ]
[ GET THE NEGATIVE ABSOLUTE VALUES OF BOTH STDINS ]
[Move the stdin values to Tom's Trims b/c:]
[1) Stdin doesn't count as a passenger waiting]
[2) Checking for no one waiting is shorter that keeping tracker of a count for just 2 iterations OR repeating all the code over again]
Go to Post Office:w 1 l 1 r 1 l.
Pickup a passenger going to Tom's Trims.
Pickup a passenger going to Tom's Trims.
Go to Tom's Trims:n.
[a]
[Clone the first waiting value]
[If we've already picked up both, move to the next process]
[Switch to plan "c" if no one is waiting.]
Pickup a passenger going to The Babelfishery.
Go to The Babelfishery:s 1 l 1 r.
Pickup a passenger going to Cyclone.
Go to Cyclone:n 1 l 1 l 2 r.
Pickup a passenger going to Addition Alley.
Pickup a passenger going to Multiplication Station.
[Add one to the value]
1 is waiting at Starchild Numerology.
Go to Starchild Numerology:s 2 l 2 r.
Pickup a passenger going to Cyclone.
Go to Cyclone:w 1 r 4 l.
Pickup a passenger going to Addition Alley.
Go to Addition Alley:n 2 r 1 r.
Pickup a passenger going to The Underground.
[Pick up a clone of that one to feed into Multiplication Station]
Go to Cyclone:n 1 l 1 l.
Pickup a passenger going to Multiplication Station.
[Subtract one and see if that's more than zero]
Go to The Underground:n 2 r 2 r.
Switch to plan "b" if no one is waiting.
[It was more than zero so we make it negative]
[First, though, get rid of the pesky result from The Underground]
Pickup a passenger going to Charboil Grill.
Go to Charboil Grill:s 2 r 1 l 1 l 2 r.
-1 is waiting at Starchild Numerology.
Go to Starchild Numerology:e 2 r.
Pickup a passenger going to Multiplication Station.
Go to The Underground:w 1 r 2 r 1 r 2 l.
[b]
[Make sure it's a negative value and leave it at Multiplication Station]
[Either it was already negative OR we now have -1 as a passenger]
Go to Multiplication Station:s 1 l 1 r.
[Get the next stdin unless we've already gotten them both]
Go to Tom's Trims:s 1 r 3 r.
Switch to plan "c" if no one is waiting.
Switch to plan "a".
[ ADD THE TWO NEGATIVES AND INVERT TO GET THE TAXI DISTANCE]
[c]
[Pickup the two negative absolute values and clone them]
Go to Multiplication Station:s 1 l 3 l.
Pickup a passenger going to Cyclone.
Pickup a passenger going to Cyclone.
Go to Cyclone:s 1 r 2 l 2 r.
Pickup a passenger going to Addition Alley.
Pickup a passenger going to Cyclone.
Pickup a passenger going to Addition Alley.
[Add the two clones values to get the negative Taxi distance]
Go to Addition Alley:n 2 r 1 r.
Pickup a passenger going to Multiplication Station.
[Invert to get the Taxi distance and store it at Rob's Rest]
-1 is waiting at Starchild Numerology.
Go to Starchild Numerology:n 1 l 1 l 1 l 3 l.
Pickup a passenger going to Multiplication Station.
Go to Multiplication Station:w 1 r 2 r 1 r 4 l.
Pickup a passenger going to Rob's Rest.
Go to Rob's Rest:s 1 r 2 l 1 l 1 r 1 r.
[ FIND THE CROW DISTANCE ]
[Uses the Babylonian method: https://en.wikipedia.org/wiki/Methods_of_computing_square_roots#Babylonian_method ]
[Square and Sum the cloned values]
Go to Cyclone:s 1 l 1 l 1 l 1 r.
Pickup a passenger going to Cyclone.
[d]
Pickup a passenger going to Multiplication Station.
Pickup a passenger going to Multiplication Station.
Go to Multiplication Station:s 1 l 2 r 4 l.
Pickup a passenger going to Addition Alley.
Go to Cyclone:s 1 r 2 l 2 r.
Switch to plan "e" if no one is waiting.
Switch to plan "d".
[e]
Go to Addition Alley:n 2 r 1 r.
Pickup a passenger going to Cyclone.
[Pickup our cycle counter]
[It's cheaper to do this than to check each iteration's value as equal to the last]
[Taxi can only handle integers up to 2^31-1 so 99 iterations is sufficient.]
99 is waiting at Starchild Numerology.
Go to Starchild Numerology:n 1 l 1 l 1 l 3 l.
Pickup a passenger going to The Underground.
[Duplicate stdin to be stored as S at Trunkers and as x0 at Sunny Skies Park]
[a & b are always integers so Trunkers won't hurt S and it's close with a short name so it's good for golfing]
Go to Cyclone:e 1 l 2 r.
Pickup a passenger going to Trunkers.
Pickup a passenger going to Sunny Skies Park.
Go to Sunny Skies Park:n 1 r.
Go to Trunkers:s 1 l.
[ This is our starting position for square root:           ]
[  • x at Sunny Skies Park                                 ]
[  • S at Trunkers                                         ]
[  • Taxi at Trunkers                                      ]
[  • The iterator as a passenger going to The Underground  ]
[f]
[Duplicate S so we don't lose it]
Pickup a passenger going to Cyclone.
Go to Cyclone:w 2 r.
Pickup a passenger going to Divide and Conquer.
Pickup a passenger going to Trunkers.
Go to Trunkers:s 1 l.
[Diplicate x for division and addition]
Go to Sunny Skies Park:w 1 r.
Pickup a passenger going to Cyclone.
Go to Cyclone:n 1 l.
Pickup a passenger going to Divide and Conquer.
[Gas will be super important in this loop]
Go to Zoom Zoom:n.
[Perform (x + S/x)/2]
[(/2) turns out to be a few bytes shorter than (*.5), mostly due to place names]
Go to Divide and Conquer:w 1 l 2 r 1 r.
Pickup a passenger going to Addition Alley.
Go to Cyclone:e 1 l 1 l 2 l.
Pickup a passenger going to Addition Alley.
Go to Addition Alley:n 2 r 1 r.
Pickup a passenger going to Divide and Conquer.
2 is waiting at Starchild Numerology.
Go to Starchild Numerology:n 1 l 1 l 3 l 2 r.
Pickup a passenger going to Divide and Conquer.
Go to Divide and Conquer:w 1 r 2 r 1 r 2 l 3 l.
Pickup a passenger going to Sunny Skies Park.
Go to Sunny Skies Park:e 1 l 1 l 2 l 1 l.
[Now we have the next iteration of x]
[Check the iterator]
Go to The Underground:s 1 l 1 r 2 l.
Switch to plan "g" if no one is waiting.
Pickup a passenger going to The Underground.
[Reset the loop]
Go to Trunkers:s 2 r 1 l.
Switch to plan "f".
[ ADD THE NEGATIVE SUM TO THE SQUARE ROOT TO GET THE NEGATIVE DIFFERENCE ]
[g]
Go to Rob's Rest:n 3 l 2 l 1 l 2 r 1 r.
Pickup a passenger going to What's The Difference.
Go to Sunny Skies Park:s 1 l 1 l.
Pickup a passenger going to What's The Difference.
Go to What's The Difference:n 1 r 1 l.
Pickup a passenger going to The Babelfishery.
Go to The Babelfishery:e 3 r.
Pickup a passenger going to Post Office.
Go to Post Office:n 1 l 1 r.
```
[Answer]
# Javascript (ES6), 36 bytes
-1 byte thanks to @dtkaias
```
(x,y,s=Math.hypot)=>s(x)+s(y)-s(x,y)
```
**Example code snippet:**
```
f=
(x,y,s=Math.hypot)=>s(x)+s(y)-s(x,y)
for(i=0;i<7;i++)
  a=[3,-3,-3,6,42,10,3][i],
  b=[4,4,-4,6,0,10,3][i],
  console.log(`f(${a},${b}) = ${f(a,b)}`)
```
[Answer]
# Julia, 20 bytes
```
x->norm(x,1)-norm(x)
```
Takes `a` and `b` as a list.
Julia's `norm` second argument defaults to 2 - hence this would be equivalent to `norm(x, 1) - norm(x, 2)`.
[Answer]
# Java 8, 47 bytes
Golfed:
```
(a,b)->(a<0?-a:a)+(b<0?-b:b)-Math.sqrt(a*a+b*b)
```
This is about as basic as it gets: subtract the two calculated values to find the difference. This uses ternary logic instead of `Math.abs()` to save one byte each occurrence. Unfortunately, the parentheses are required due to operator precedence.
The output is whatever Java's `double` can hold, which is accurate to more than two decimal places and satisfies the accuracy requirement of the question.
Ungolfed:
```
public class TheCrowVsTheTaxicab {
  public static void main(String[] args) {
    int[][] inputs = new int[][] { { 3, 4 }, { -3, 4 }, { -3, -4 }, { 6, 6, }, { 42, 0 }, { 10, 10 }, { 3, 3 } };
    double[] outputs = new double[] { 2, 2, 2, 3.51, 0, 5.85, 1.76 };
    for (int i = 0; i < inputs.length; ++i) {
      double actual =
        f((a, b) -> (a < 0 ? -a : a) + (b < 0 ? -b : b) - Math.sqrt(a * a + b * b), inputs[i][0], inputs[i][1]);
      System.out.println("Input:    " + inputs[i][0] + ", " + inputs[i][1]);
      System.out.println("Expected: " + outputs[i]);
      System.out.println("Actual:   " + actual);
      System.out.println();
    }
  }
  private static double f(java.util.function.BiFunction<Integer, Integer, Double> f, int a, int b) {
    return f.apply(a, b);
  }
}
```
Output:
```
Input:    3, 4
Expected: 2.0
Actual:   2.0
Input:    -3, 4
Expected: 2.0
Actual:   2.0
Input:    -3, -4
Expected: 2.0
Actual:   2.0
Input:    6, 6
Expected: 3.51
Actual:   3.5147186257614305
Input:    42, 0
Expected: 0.0
Actual:   0.0
Input:    10, 10
Expected: 5.85
Actual:   5.857864376269049
Input:    3, 3
Expected: 1.76
Actual:   1.7573593128807152
```
[Answer]
# [R](https://www.r-project.org/), 30 bytes
```
function(v)norm(v)-norm(v,'f')
```
Takes `v` as a 1-column matrix. `norm` computes a particular norm of a matrix, with the default being the L1 norm (taxicab), and `f` the L2 norm (`'f'` for Frobenius/Euclidean).
[Try it online!](https://tio.run/##K/qfZvs/rTQvuSQzP0@jTDMvvygXSOlCaB31NHXN/2kauYklRZkVGskahgY6hgaaOkaamv8B "R – Try It Online")
[Answer]
# Mathematica, 32 bytes
```
N[Tr@Abs[a={##1}]-Sqrt@Tr[a^2]]&
```
or
# Mathematica, 31 bytes
```
N[Abs@#+Abs@#2-Sqrt[#^2+#2^2]]&
```
or @Not a tree's suggestion
# Mathematica, 26 bytes
```
N[Tr@Abs@{##}-Abs[#+I#2]]&
```
or @alephalpha's suggestion
# Mathematica, 19 bytes
```
N[#~Norm~1-Norm@#]&
```
[Answer]
# Dyalog APL, 13 bytes
```
+/∘|-.5*⍨+.×⍨
```
[Try it online!](http://tryapl.org/?a=%28+/%u2218%7C-.5*%u2368+.%D7%u2368%29%20%AF3%20%AF4&run)
Explanation (input X):
```
+/∘|     - Sum of the element-wise absolute value of X
-        - Minus
.5*⍨+.×⍨ - Euclidean distance = sqrt(X . X)
```
[Answer]
# [Python 2](https://docs.python.org/2/), ~~40~~ ~~38~~ 36 bytes
*-2 bytes thanks to vaultah. -2 bytes thanks to sTertooy.*
Fun fact, 11 bytes of this code were just copied from the question and golfed.
```
lambda a,b:abs(a)+abs(b)-abs(a+b*1j)
```
[Try it online!](https://tio.run/##Xc1BDoMgEAXQPaf4S9EhETUuTDyJZQFpSWlaNMKmp6cWowtnM//lZzLLNz5n3yQ73tJbf8xdQ5MZtAmF5tV/GS6yKlPKF0/xEWLAiIlhm6kldIr2LK4Qp3pCf@SuIdQHZE2Qp7abVjHFmJ1XODiP/G7I7bI6H2GL0vH0Aw "Python 2 – Try It Online")
[Answer]
# [Japt](https://github.com/ETHproductions/japt), ~~11~~ 9 bytes
*-2 bytes thanks to @ETHproductions*
```
Nxa -MhUV
```
[Try it online!](http://ethproductions.github.io/japt/?v=1.4.5&code=TnhhIC1NaFVW&input=NiA2)
## Explained
```
Nxa -MhUV   // implicit: U and V are input integers, N = [U,V]
N a         // get absolute value of both inputs
 x          // sum those values
    -MhUV   // subtract hypot(U, V) -> sqrt(U^2 + V^2)
```
[Answer]
# Scheme - 58 bytes.
```
(define (f a b) (-(+(abs a)(abs b))(sqrt(* a a)(* b b))))
```
[Answer]
# Pyth, 8 bytes
```
-s.aMQ.a
```
[Try it online.](https://pyth.herokuapp.com/?code=-s.aMQ.a&input=6%2C+6&test_suite_input=3%2C+4%0A-3%2C+4%0A-3%2C+-4%0A6%2C+6%0A42%2C+0%0A10%2C+10%0A3%2C+3&debug=0) [Test suite.](https://pyth.herokuapp.com/?code=-s.aMQ.a&input=6%2C+6&test_suite=1&test_suite_input=3%2C+4%0A-3%2C+4%0A-3%2C+-4%0A6%2C+6%0A42%2C+0%0A10%2C+10%0A3%2C+3&debug=0)
### Explanation
```
-s.aMQ.aQ      Q (input) appended implicitly
  .aMQ         absolute values of input vector
 s             sum
-              subtract
      .aQ      norm2 of input vector
```
[Answer]
# [APL (Dyalog)](https://www.dyalog.com/), 14 bytes
Takes argument in the form `xJy`, e.g. `3J4`
```
||-2+/∘|9 11○⊢
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///P@VR24SaGl0jbf1HHTNqLBUMDR9N737UtQgoc2iFcZaJwqH1xl4Q8tB6EwUzLzMFEyMvAwVDAy9DAwVjL2MA "APL (Dyalog Unicode) – Try It Online")
`|` the magnitude of[Doc](http://help.dyalog.com/16.0/Content/Language/Primitive%20Functions/Magnitude.htm)
`|` the argument's magnitude
`-` minus
`2+/` the pair-wise sum
`∘` of
`|` the magnitudes of
`9 11.○⊢` the the argument's real and the imaginary parts.[Doc](http://help.dyalog.com/16.0/Content/Language/Primitive%20Functions/Circular.htm)
Special trick for golfing was the use of the pairwise reduction (`2+/`) to supply `+/` with a no-op left argument, thereby avoiding parentheses: `||-(+/∘|9 11○⊢)`
[Answer]
# J, 13 bytes
```
+/@:|-+/&.:*:
```
This is a function that takes the coordinates as an array, e.g.:
```
   (+/@:|-+/&.:*:) _3 4
2
```
Explanation:
```
+/             sum
  @:           of
    |          absolutes
     -         minus
      +/       sum
        &.:    under
           *:  square
```
[Answer]
# [J](http://jsoftware.com/), ~~9~~ 8 bytes
-1 thanks to my colleague Marshall.
```
+&|-|@j.
```
[Try it online!](https://tio.run/##y/r/P83WSlutRrfGIUvv/39jhXgwMlMwMVIwNFAwVkhTMAHCeBOgkAFYBAA "J – Try It Online")
Takes **A** as left argument and **B** as right argument.
`+` the sum
`&` of
`|` the magnitudes
`-` minus
`|` the magnitude
`@` of
`j.` **A** + **B** *i*
Golfing trick: combine the values to a single complex number because the diagonal is easy to get like that, while also keeping them separate because the sum is easy to get like that.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 7 bytes
```
ÄO¹nOt-
```
[Try it online!](https://tio.run/##MzBNTDJM/f//cIv/oZ15/iW6//9Hm@mYxQIA "05AB1E – Try It Online")
**Explanation**
```
Ä        # absolute value of inputs
 O       # sum
  ¹      # push input again
   n     # square
    O    # sum
     t   # sqrt
      -  # subtract
```
[Answer]
# TI-Basic (TI-84 Plus CE), 10 bytes
```
sum(abs(Ans))-√(sum(Ans2
```
Program that input as a list of two integers in `Ans`, e.g. call with `{3,4}:prgmCROW` (replacing `3,4` with the input and `CROW` with the name of the program).
Explanation:
```
sum(abs(Ans))-√(sum(Ans2
        Ans               # The input list of two integers
    abs(   )              # Absolute value of each item in the list
sum(        )             # Sum of the list
                    Ans   # The input list of two integers
                       2  # Square of each item in the list
                sum(      # Sum of the list
              √(          # Square root of the sum
             -            # Difference of the two values
```
[Answer]
# [MATL](https://github.com/lmendo/MATL), ~~8~~ 7 bytes
```
|sG2&|-
```
[**Try it online!**](https://tio.run/##y00syfn/v6bY3UitRvf//2hDAwVDg1gA "MATL – Try It Online")
### Explanation
```
|    % Implicit input: vector of two numbers. Absolute value, element-wise
s    % Sum of vector
G    % Push input again
2    % Push 2
&|   % 2-norm of input
-    % Subtract. Implicit display
```
[Answer]
# Common Lisp, 57 bytes
```
(defun g(a b)(+(abs a)(abs b)(-(sqrt(+(* a a)(* b b))))))
```
[Try it online!](https://tio.run/##HchLCsAgEAPQq2QZLYX2SDP9iCBi1Z7fTg2BkHek2MoYPK/7zQgUqONC0QZxc@yvbE/txh7ys4cazwyWGnMHA/bNavIB)
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 7 bytes
```
²S½ạAS$
```
[Try it online!](https://tio.run/##y0rNyan8///QpuBDex/uWugYrPL///9oMx0Fs1gA "Jelly – Try It Online")
Format is list of two numbers.
[Answer]
# GNU APL 1.2, 24 bytes
```
∇f P
(+/|P)-(+/P*2)*.5
∇
```
`∇f P` declares a function `f` that takes a vector `P` containing the distances as an argument (e.g. `[3, 4]`)
APL operates on vectors, so `+/|P` applies the `|` operator (`abs` function) to each element in the vector and then evaluates `+` on each element (so add all the elements). This gives the taxi distance.
`P*2` yields a vector that is the same as `P` but with each element squared. `+/P*2` to add those together and then (with parentheses for precedence because APL is right-to-left) `*.5` to get the square root. This gives the crow distance.
Add an extra pair of parentheses for the taxi distance for precedence and compute the difference.
`∇` to end the function.
[Answer]
# [Add++](https://github.com/SatansSon/AddPlusPlus), ~~59~~ 57 bytes
```
D,f,@@,|@|+
D,g,@@,d*@d*+
_
$f>G>G
V
$g>?>?
S
-G
$f>x>0
O
```
[Try it online!](https://tio.run/##S0xJKSj4/99FJ03HwUGnxqFGm8tFJx3ETtFySNHS5ornUkmzc7dz5wrjUkm3s7ez5wrm0nUHCVbYGXD5////3@y/GQA "Add++ – Try It Online")
This took me ages to solve. It doesn't round the final answer as that isn't possible in Add++. This is how the program works with the inputs `-3` and `-4` (`ACC` is the accumulator value)
```
D,        Define a function
  f,      called f
  @@,     that takes 2 arguments (e.g. -3, -4)
     |    absolute value;   STACK = [-3, 4]
     @    reverse stack;    STACK = [4, -3]
     |    absolute value;   STACK = [4, 3]
     +    sum;              STACK = [7]
          implicitly return the top of the stack
D,        Define a function
  g,      called g
  @@,     that takes 2 arguments (e.g. -3, -4)
     d    duplicate;  STACK = [-3, -4, -4]
     *    multiply;   STACK = [-3, 16]
     @    reverse;    STACK = [16, -3]
     d    duplicate;  STACK = [16, -3, -3]
     *    multiply;   STACK = [16, 9]
     +    sum;        STACK = [25]
          implicitly return the top of the stack
_         store the inputs in the second stack;  ACC = 0;  STACK = [-3, -4]
$f>G>G    apply f with -3 and -4 as arguments;   ACC = 7;  STACK = []
V         store ACC in the stack;                ACC = 7;  STACK = [7]
$g>?>?    apply g with -3 and -4 as arguments;   ACC = 25; STACK = [7]
S         square root the ACC;                   ACC = 5;  STACK = [7]
-G        subtract the stack value from the ACC; ACC = -2; STACK = []
$f>x>0    apply f with ACC and 0 as arguments;   ACC = 2;  STACK = []
O         output ACC as a number
```
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), 7 bytes
```
a.aQsa0
```
[Try it here](https://pyth.herokuapp.com/?code=a.aQsa0&input=%5B6%2C+6%5D&debug=0)
---
**[Pyth](https://github.com/isaacg1/pyth), ~~25~~ 23 bytes**
THis is the initial solution, my first not-so-trivial Pyth solution and you can see just how bad I used to be at golfing in Pyth :)
```
K.aswJ.asw-+KJ^+^K2^J2 .5
```
[Try it online!](https://tio.run/##K6gsyfj/31svsbjcC0Toant7xWnHeRvFeRkp6Jn@/69rzGUCAA "Pyth – Try It Online")
[Answer]
# [Pip](https://github.com/dloscutoff/pip), 15 bytes
```
ABa+ABb-RT$+g*g
```
Takes input from command-line arguments. [Try it online!](https://tio.run/##K8gs@P/f0SlR29EpSTcoREU7XSv9////xv91TQA "Pip – Try It Online")
### Explanation
In pseudocode, this is `abs(a) + abs(b) - sqrt(fold+(g*g))`. `a` and `b` are the first two cmdline args, and `g` is the list of cmdline args (i.e. argv). The `*` operator vectorizes, like many Pip operators, so `$+g*g` is the same thing as `a*a + b*b`. The rest is pretty straightforward.
Unfortunately, I can't save any bytes with `$+ABg`, because the precedence of operators with fold doesn't work like it should yet. `$+` ought to be slightly higher precedence than binary `-`, but at the moment it parses as `$+(ABg-RT$+g*g)`, giving the wrong answer. Doing `($+ABg)-RT$+g*g` doesn't save any bytes over the less-obfuscated version above.
[Answer]
# PHP>=7.1, 54 bytes
```
[,$x,$y]=$argv;echo abs($x)+abs($y)-sqrt($x**2+$y**2);
```
[PHP Sandbox Online](http://sandbox.onlinephpfunctions.com/code/19a9481c72fc8df777304388d703b02945e9de45)
# [PHP](https://php.net/), 55 bytes
```
<?=abs($x=$argv[1])+abs($y=$argv[2])-sqrt($x**2+$y**2);
```
[Try it online!](https://tio.run/##K8go@G9jX5BRwKWSWJReZhutpKuko2QMxrHWXPZ2QFnbxKRiDZUKW7CKaMNYTW2wQCVUwChWU7e4sKgEqERLy0hbpRJIalr//w8A "PHP – Try It Online")
# [PHP](https://php.net/), 60 bytes
with an function instead of a full program
```
function f($x,$y){return abs($x)+abs($y)-sqrt($x**2+$y**2);}
```
[Try it online!](https://tio.run/##K8go@G9jXwAk00rzkksy8/MU0jRUKnRUKjWri1JLSovyFBKTioEimtpgulJTt7iwqAQooKVlpK1SCSQ1rWv/pyZn5AM1GusYa1r/BwA "PHP – Try It Online")
[Answer]
# Excel VBA, 34 Bytes
Anonymous VBE immediate window function that takes input from range `[A1:B1]` and outputs the difference between the Euclidean and Taxicab distances to the VBE immediate window.
```
?[ABS(A1)+ABS(B1)-SQRT(A1^2+B1^2)]
```
[Answer]
# [,,,](https://github.com/totallyhuman/commata/), 18 [bytes](https://github.com/totallyhuman/commata/wiki/Code-page)
Essentially a port of my Python answer.
```
a:↔a:0•2*⇆2*+√↔+↔-
```
[Answer]
## Forth (gforth), 68 bytes
```
abs swap abs 2dup + s>d d>f dup * swap dup * + s>d d>f fsqrt  f- f.s
```
[Try it online](https://tio.run/##S8svKsnQTU8DUf/NFMz@JyYVKxSXJxYogBhGKaUFCtoKxXYpCil2aQognhZEFsJESKUVFxaVKCik6Sqk6RX//w8A) !
The coordinates are two numbers on the stack. 
PS my first code golf... don't hit too hard ;-)! 
[Answer]
# [Ruby](https://www.ruby-lang.org/), 31 bytes
Creates a complex number to calculate the distance with.
```
->x,y{x.abs+y.abs-(x+y*1i).abs}
```
[Try it online!](https://tio.run/##KypNqvyfZhvzX9euQqeyukIvMalYuxJE6mpUaFdqGWZqgji1/wsU0qK1UssSczTSU0uKNWP/Rxsa6BgaxAIA "Ruby – Try It Online")
[Answer]
# Ruby (2.0.0 - 2.3.0), 57bytes
```
x,y=$*.map(&:to_i);puts x.abs+y.abs-Math.sqrt(x**2+y**2)
```
This assumes taking input from ARGV e.g.
```
ruby -e 'x,y=$*.map(&:to_i);puts x.abs+y.abs-Math.sqrt(x**2+y**2)' -- -3 4
```
This feels like a cheat since Ruby comes with a math lib that has abs and sqrt functions (unlike the guy who wrote his own abs and sqrt functions, though I didn't see anything specifically forbidding the use of such functions).
The first trick is using `.map` instead of `.each` which saves a byte, then using the `&:symbol` notation to pass map a proc we execute `to_i` on each item in the array, and use multiple assignment to assign values to x and y.
A longer version would be:
```
(x, y) = ARGV.map{ |string| string.to_i }
```
(since map returns an array, multiple assignment is probably the way to do it, this does throw away any additional parameters, but we're assuming only two inputs anyway)
Then I just removed all of the spaces in the equation.
Here's a longer version, 84 bytes
```
$*.map!(&:to_i);puts$*.inject(0){|x,y|x+y.abs}-Math.sqrt($*.inject(0){|x,y|x+y**2})
```
The goal here was to not repeat myself, e.g. having to write `x` or `abs` twice and my squaring twice `x**2 + y**2`
It did not work.
But what's interesting is that puts doesn't need a space, I guess the lexer is smart enough to see the special char and know it's a special var.
`inject` and `reduce` are synonyms, inject has a signature of
```
inject(initial) {| memo, obj | block }
```
In our case we need to set the initial to 0, then we have our accumulator (i.e.: memo = 0) and the object from each iteration.
The down side to this method is that it will take more than two inputs and will either sum or square, add, then sqrt all the values in the array. 
I *think*--though I don't have a Ruby 2.4.0 to test with--that this will work as well, which comes in at 72 bytes:
```
$*.map!(&:to_i);puts$*.sub{|x,y|x+y.abs}-Math.sqrt($*.sum{|x,y|x+y**2})
```
Sum defaults to 0 and as far as I can tell, works the same as inject/reduce.
[Answer]
# Google Sheets, 31 Bytes
Worksheet function that takes input from range `[A1:B1]` and outputs the difference between the Euclidean and Taxicab distances
```
=ABS(A1)+ABS(B1)-SQRT(A1^2+B1^2
```
# Excel, 32 bytes
Same as above but formatted for MS Excel
```
=ABS(A1)+ABS(B1)-SQRT(A1^2+B1^2)
```
]