text:
Fastest tweetable integer factorizer
The task is to find a non-trivial factor of a composite number.
Write code that finds a non-trivial factor of a composite number as quickly as possible subject to your code being no more than 140 bytes long.  The output should just be the factor you have found.
Your code can take input and give output in any way that is convenient including for example as arguments to a function.
Test cases which list all the factors (you only need to output  one)
187: 11 17
1679: 23 73
14369648346682547857: 1500450271 9576890767
34747575467581863011: 3628273133 9576890767
52634041113150420921061348357: 2860486313 5463458053 3367900313
82312263010898855308580978867: 264575131106459 311111111111113
205255454905325730631914319249: 2860486313 71755440315342536873
1233457775854251160763811229216063007: 1110111110111 1000000000063 1111111999999
1751952685614616185916001760791655006749: 36413321723440003717 48112959837082048697

I won't score your answer on the following difficult test case which may be of interest for testing:
513231721363284898797712130584280850383: 40206835204840513073 12764787846358441471

Score
Your score is the combined time to factor all the test cases above with a penalty of 10 minutes for each failed factorization (all rounded to the nearest second).  Your code should work for other integers too, that is shouldn't just hardcode these answers.
I will stop your code after 10 minutes.
If two people get the same score then the first answer wins.
Restrictions
Your code can't use any builtin or library function that performs integer factorization. You can assume the input takes less than 256 bits.  All input numbers will be composite.
How will I time?
I will literally run time ./myprog on my Ubuntu system  to do the timing so please also supply a complete program for me to run that includes any function you have defined.
A note for compiled languages
Compilation time must take no more than 1 minute on my machine.
Is it actually possible?
If you ignore the space constraints, then  each one can be factored in less than 2 seconds on my computer using pure Python code + pypy.
So what is a non-trivial factoring algorithm?
Pollard's rho algorithm is fast and suitable for golfing. Of course there are plenty of other ways to factor an integer as well.
Even faster is the Quadratic sieve.  It looks like a serious challenge to squeeze that into 140 bytes.
Leading scores

SEJPM, 10 minutes penalty for the last test case + 16 seconds in Haskell

So, we may be given a number like 2 ** 1024?

@ConorO'Brien You won't be given anything with more digits than the test cases.

So, in terms of precision, nothing more than 256 bits.

For an input like 4, should the output be 2 or 2, 2?

Are you sure that the last test case is possible in 10 minutes?

@LegionMammal978 msieve (a dedicated C/C++ factoring tool) can solve the last test case in about 2 seconds. sage needs about the same time with a simple call to factor. Whether it is feasible to put the algorithms used in these tools into 140 chars is a different question...

The only answer so far breaks the specification by merely finding a factor of a composite number, and not a full prime factorization. However, perhaps that would a better challenge, so that one doesn’t need to squeeze both factoring and primality testing into the same tweet? (By themselves, I think the fastest factoring algorithms will tend to run slowly or loop infinitely trying to factor the remaining primes after all the proper factors have been found.)

@AndersKaseorg I updated the question following your suggestion. Thanks.

Why the downvote? Please add an explanation.  I may even be able to fix what you don't like.

@Lembik I suppose in the Haskell solution the 1751952685614616185916001760791655006749 would be the number not factored in 10 minutes; so I suppose you say that for factoring 82312263010898855308580978867 Haskell code take 16 seconds? How is possible than in Tio that code in 1 minute (I suppose) not factored it?

Haskell, 100 97 91 89 87 72 67 Bytes
Try It Online!
-3 bytes thanks to @flawr
-6 bytes thanks to @flawr again
-2 bytes thanks to @flawr yet again
-2 bytes thanks to an optimized set of parameters
-1 byte thanks to @flawrs yet another time
-14 bytes thanks to requirement to only having to output one factor
-5 bytes thanks to @AndersKaseorg
f n|let s x=mod(x*x+7)n;a#b|d<-gcd(b-a)n,d>1=d|c<-s b=s a#s c=5#s 5

This works for the first 5 test cases in unnoticable time.
This will probably time-out on the largest test case.
In general this will usually return one non-trivial factor in time proportional to the square root of the smallest factor.
It will not work on every input because it doesn't vary the polynomial and detection of the exceptional case is hard to do in 140 bytes.
It will also not output the full factorization, but rather a non-trivial factor and the division of the input by this factor.
It will also not sort the factors by size.
The method used is Pollard-Rho-Factoring with the standard starting value of 2 (with the standard x^2+1 polynomial applied once) and the non-standard polynomial constant factor of 7 (because 1 didn't work with 1679) for all further evaluations.
Full program (factor.hs):
import System.Environment(getArgs)

f n|let s x=mod(x*x+7)n;a#b|d<-gcd(b-a)n,d>1=d|c<-s b=s a#s c=5#s 5

main= do
      args <- getArgs
      print$f (read $ head args :: Integer)

Compile as $ ghc factor.hs (needs ghc installed).
Run as $ ./factor <number>.
Example run:
$ ./factor 187
11

Ungolfed code:
f n=g 5 (s 5)
   where s x=mod(x*x+7)n
         g a b = if d>1 then d else g(s a)(s(s b))
               where d=gcd(b-a)n

Computes the non-trivial factor by calling g with initial values. The polynomial is pre-applied on 2 here and re-applied on the result (5) so that the input to g (in a "where" clause) can always be readily used for the gcd-test. g (golfed version uses infix #) then tries to compute a non-trivial factor d (in the where clause in the un-golfed version, in-line in the golfed one) as the difference between the two inputs to g, if it succeeds returns said factor, else retries. Here it may generate n as the output if a==b and thus returns only a trivial factor, the proper approach to handle this would be to either vary the starting values upon this event or change the polynomial.

|1<2=s a#(s$s b) could be replaced with |c<-s b=s a#s c I think :) (also: why don't you post a TIO link?)

I updated the question following the comment suggestions.  Now you only need to output one factor and the numbers are guaranteed to be composite.

PS: why are we golfing, this isn't even [tag:code-golf]

You now have 53 bytes in which to implement an even more sophisticated factoring algorithm :)

Using |let rather than where for local declarations saves a byte.

Also you can take out abs , since b is always nonnegative. (Perhaps you meant abs$b-a, but gcd accepts negative arguments and always produces a nonnegative result.) That brings this down to less than half a tweet!

"It will also not work on the last test case because it is not semi-prime" but the last case IS semi-prime! And you only need to output one factor!

@NieDzejkob in the first version of the question the last test case had 4 factors (three large ones and 2), which is what I was referring to with that line, which is now removed (you may flag this for "no longer needed" once read).

Pari/GP, 137 bytes, ~5 seconds
Using GP's built-in elliptic curve operations (and some underhanded parameter tuning):
ecm(n)=iferr(if(n%2==0,2,n%3==0,3,for(a=1,n,ellmul(ellinit(Mod([a,a^2-a-1],n)),[1,a],lcm([1..ceil(4^a^0.5)])))),e,gcd(n,lift(Vec(e)[3])))

ecm is a function that (ought to) return a factor. Try it online!
Test:
ecm(n)=iferr(if(n%2==0,2,n%3==0,3,for(a=1,n,ellmul(ellinit(Mod([a,a^2-a-1],n)),[1,a],lcm([1..ceil(4^a^0.5)])))),e,gcd(n,lift(Vec(e)[3])))

{
ns = [
  187,
  1679,
  14369648346682547857,
  34747575467581863011,
  52634041113150420921061348357,
  82312263010898855308580978867,
  205255454905325730631914319249,
  1233457775854251160763811229216063007,
  1751952685614616185916001760791655006749
  ]
}

test(n) = {
    d = ecm(n);
    if (!(1<d && d<n && n%d==0), error(d));
    print(n, ": ", d)
}

apply(test, ns)

quit

Ungolfed:
ecm(n) = {
  iferr(if(n%2 == 0, 2,
           n%3 == 0, 3,
           for(a = 1, n,
               /* x^3 + A*x + B = y^2 */
               E = ellinit(Mod([a, a^2-a-1], n)); /* [A, B] */
               x0 = [1, a]; /* [x, y] */
               B = ceil(4^a^0.5); /* ~ exp(sqrt(log(p))), p ~= exp(a) */
               print("a=", a, ", B=", B);
               ellmul(E, x0, lcm([1..B]))
              )
          ),
         ERR, gcd(n, lift(Vec(ERR)[3] /* = Mod(d, n) */)),
         errname(ERR)=="e_INV")
}

Sadly, handling the factors 2 and 3 uses many bytes. Bytes that could have been used to add a stage 2:
ecm(n)=iferr(for(a=1,n,Y=X=ellmul(E=ellinit(Mod([a,1],n)),[0,1],(B=ceil(4^a^0.5))!);for(z=0,9*B,Y=elladd(E,Y,X))),e,gcd(n,lift(Vec(e)[3])))

Wolfram Language (Mathematica), 81 bytes, 22 sec +10min(penalty)
uses Pollards ρ-algorithm x(0)=33, f(x)=x^8+1 and searches only x(2k)-x(k)
(x@0=33;n=#;v=1;x@k_:=x@k=Mod[x[k-1]^8+1,n];While[(r=GCD[x[2v]-x@v,n])<2,v++];r)&

Try it online!

Axiom, 137 bytes 9 minutes
p(n:PI):PI==(j:=1;a:=3;s:=n^.2;repeat(b:=j:=nextPrime(j);repeat(b<s=>(b:=b*j);break);a:=powmod(a,b,n);d:=gcd(a-1,n);d>1 or j>n=>break);d)

above the function p() that would implement p-1 algo for factoring
below what to copy in a file for test on p() function
-- one has to copy this below text in a file name for example file.input
-- in one window where there is Axiom one could write
-- )read C:\absolutepathwherethereisthatfile\file
-- and call the function test()
-- test()
-- the first character of all function and array must be afther a new line "\n"
)cl all
)time on
vA:=[187,1679,14369648346682547857,34747575467581863011,52634041113150420921061348357,82312263010898855308580978867,205255454905325730631914319249,1233457775854251160763811229216063007, 1751952685614616185916001760791655006749]

p(n:PI):PI==(j:=1;a:=3;s:=n^.2;repeat(b:=j:=nextPrime(j);repeat(b<s=>(b:=b*j);break);a:=powmod(a,b,n);d:=gcd(a-1,n);d>1 or j>n=>break);d)

-- this would try to factor n with p-1 Pollard method
pm1(n:PI):PI==
   j:=1;a:=3;s:=n^.2
   repeat
      b:=j:=nextPrime(j)
      repeat(b<s=>(b:=b*j);break)
      a:=powmod(a,b,n)
      d:=gcd(a-1,n);d>1 or j>n=>break
   d

test()==(for i in 1..#vA repeat output [vA.i, p(vA.i)])

results here:
(5) -> test()
   [187,11]
   [1679,73]
   [14369648346682547857,9576890767]
   [34747575467581863011,9576890767]
   [52634041113150420921061348357,2860486313]
   [82312263010898855308580978867,311111111111113]
   [205255454905325730631914319249,2860486313]
   [1233457775854251160763811229216063007,1111111999999]
   [1751952685614616185916001760791655006749,36413321723440003717]
                                                               Type: Void
                              Time: 496.78 (EV) + 53.05 (GC) = 549.83 sec

Could you spell out exactly how to run this code from the command line in ubuntu please? I have installed axiom and made a file called foo.ax with your non-golfed code in it.

@Lembik 1)rename fop.ax in foo.input 2) run Axiom in one terminal or xterm 3) write in that Axiom terminal the follow command ")read C:absolutepath\foo" 4) write in the terminal of Axiom the call to function test(). This is how to do in Windows, the clue it seems to me open one Axiom session and load the file with ")read" command

@Lembik if there are problem with files I think it would be ok too: 1) run Axiom 2) write )time on  in Axiom program 3) copy paste and press return in each "copy paste" in Axiom  program: the array vA, the function p() and test() 4) in the Axiom program write test()

@Lembik so what time it takes?

Axiom, 10 minutes + 31 seconds
A(a)==>a:=(a*a+7)rem n;z(n)==(p:=a:=b:=101;for i in 1..repeat(A(a);A(b);A(b);p:=mulmod(p,a-b,n);i rem 999<9=>(p:=gcd(p,n);p>1=>break));p)

z() is the function rho, one 137 bytes function; ungolfed z() and call it as rho(). It would suppose that gcd(0,n)=n so the loop stop and return for fail n.
)time on
rho(n)==
  p:=a:=b:=101
  for i in 1..repeat
          A(a);A(b);A(b)
          p:=mulmod(p,a-b,n)
          i rem 999<9=>(p:=gcd(p,n);p>1=>break)
  p

va1:=[187,1679,14369648346682547857,34747575467581863011,52634041113150420921061348357,82312263010898855308580978867,205255454905325730631914319249,1233457775854251160763811229216063007, 1751952685614616185916001760791655006749]
p1()==(for i in 1..#va1-1 repeat output [va1.i,z(va1.i)])

results (z() is ok to all but the last number 1751952685614616185916001760791655006749 remain not factored (10 minutes) )
(6) -> p1()
   [187,17]
   [1679,23]
   [14369648346682547857,1500450271]
   [34747575467581863011,3628273133]
   [52634041113150420921061348357,2860486313]
   [82312263010898855308580978867,264575131106459]
   [205255454905325730631914319249,2860486313]
   [1233457775854251160763811229216063007,1111111999999]
                                                               Type: Void
                                 Time: 30.38 (EV) + 1.38 (GC) = 31.77 sec

(8) -> z(1679)
   (8)  23
                                                    Type: PositiveInteger
                                                              Time: 0 sec

Python 3, 100 99 bytes, 45 40 39 seconds + 10 minute penalty
import math
def f(n):
 x=y=2;d=1
 while d<2:y=y*y+1;x,y=1+x*x%n,y*y%n+1;d=math.gcd(x-y,n)
 return d

Try it online!
Uses Pollard-Rho with initial value 2 and polynomial x^2+1.

You could use pow (with the 3rd argument) to improve your execution speed.


text:
The Crow vs The Taxicab
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 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. This picture nicely demonstrates the difference between the two:

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! :)

can we take input as complex number?

I think the testcase for 10,10 needs to be 5.86, since it comes out to 5.85786... and you rounded the one below it.

I first read the title as The Cow vs The Taxicab and was hoping to find something involving collision physics...

May we give negative results?

@Adám No. (Since conceptually, you're returning a distance, which is always positive)

@Uriel Sorry I didn't respond earlier. I guess I don't have any problem with giving the input as a complex number.

@DJMcMayhem Then how can the input be negative‽

@Adám because the input represents points on a Cartesian coordinate system.

@DJMcMayhem And the output represents a distance on a Cartesian coordinate system.

@Adám the Lp norms are always positive

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

This is insane...

@Gryphon the insane thing is I am 100% sure I can remove like two thousand bytes once I revisit my logic while I'm not half asleep

Explanations added - let me know if you have questions

4 hours is deserving of the +1 in itself!

I'm sure the number of golfers who'll read the entire explanation will be smaller than your bytes :D

+1 for -1 is waiting at Starchild Numerology.

This is absolutely the best language for the job. To help you cut it down in size, take a look at the Babylonian method for calculating square roots. I did a quick test and Equal's Corner returns false for 1/1000000000 = 2/1000000000 but converting them to strings and comparing at Crime Lab returns true. I bet it's shorter to repeatedly apply the method, check if it equal's the last result, and escape once it does. I'll try to write up just a square root function using the method and see what comes out.

@EngineerToast thanks :) Yup, you're probably right - I didn't completely understand the Babylonian method when I looked at it, so I didn't try it. I'm going to be gone for a week in the woods - if you get it working, feel free to edit it in. You're probably much better at Taxi then I am, I learned it as I went. The biggest thing to cut down on bytes would be reusing the absolute value bit, since that's just copied and pasted with changed labels. (Not saying you should do it, just saying that that's how I would golf it :P )

I understood it enough to replicate the method in Excel but it's proving to be a pain in Taxi. For Excel, put the value in A1 and the following formula in A2: =(A1+($A$1/A1))/2. Drag that down and you'll see it iterate towards the square root. I'm not in a mental stae to keep track of those passengers right now, though, so I'll give it a go tomorrow.

Now here's the real question: What is the taxicab distance of the route you travel in this answer itself? :P Nice job btw!

@DJMcMayhem If someone wants to modify the C++ interpreter on the developer's site, they could have it output miles_driven since it's already being tracked to make sure you don't run out of gas.

I got the square root function but the TIO link is way too big to paste here. The comments version is at https://goo.gl/PjdepM (check the link safety at http://wheredoesthislinkgo.com if you wish). The golfed version is 1,590 bytes and can be tested here: https://goo.gl/6TKwfV. I'll work on integrating it to yours to see if it's shorter.

OK, I have a Taxi answer that comes in at 3,773 bytes. I want to give it to you. Golfed version: https://pastebin.com/D2UuUCVp  Ungolfed version with comments: https://pastebin.com/yJt1iwUj  For future reference, he's my ungolfed square root function, too: https://pastebin.com/n4b24h3V Please keep golfing in Taxi. You're only the 4th user to ever post an answer in Taxi. One quick hint: You don't have to go back to the garage unless OP specifically restricts output to stderr.

@EngineerToast thanks! I just got back, I'll edit it in. After reading it, that's so much smarter than what I was trying to do - I really didn't utilize the "If no passenger are waiting", or The Underground.

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)}`)

ES6 doesn't have **.

A true ES6 version would probably be 41 bytes: (x,y,s=Math.sqrt)=>s(x*=x)+s(y*=y)-s(x+y).

@DanEsparza It clearly used to. This is what revision history is for...

Why not a=>b=>a+b-Math.hypot(a,b)?

@dtkaias a=>b=>a+b-Math.hypot(a,b) would not work for negative numbers.

Right, how about (x,y,s=Math.hypot)=>s(x)+s(y)-s(x,y), for 36 bytes, ES6 compatible too

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

I also thought about using Julia!

Very similar to the MATLAB answer I was about to post.

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

You can use currying to save a byte: a->b->.

R, 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!

Wow, R has both built-in, nice!

Python 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!

I have been ninja'd

@Mr.Xcoder I wouldn't be too worried about it, I'll probably be out-golfed. :P

@vaultah Oh, good point. Thanks!

abs(a+b*1j) should work instead of (a*a+b*b)**.5

@totallyhuman bruh golf it alr

@ASCII-only ok :)

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@#]&

Nice work! You can save a few bytes by using complex numbers for the euclidean part: N[Tr@Abs@{##}-Abs[#+I#2]]&

N[#~Norm~1-Norm@#]&.

@alephalpha #~Norm~1-N@Norm@#& maybe?

Dyalog APL, 13 bytes
+/∘|-.5*⍨+.×⍨

Try it online!
Explanation (input X):
+/∘|     - Sum of the element-wise absolute value of X
-        - Minus
.5*⍨+.×⍨ - Euclidean distance = sqrt(X . X)

Japt, 11 9 bytes
-2 bytes thanks to @ETHproductions
Nxa -MhUV

Try it online!
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)

Nice, I think this is the first time I've seen Mh used. I believe you can shorten Ua +Va to Nxa (sum of inputs, running a on each)

@ETHproductions Oh right, forgot that sum had the optional map parameter. Thanks!

So there *is" a use for Mh! :D Most methods in Japt can take what @ETHproductions calls an "auto-function" as an argument. See this tip for more on them. And I'll be writing up a tip tomorrow on using auto-functions with array reduction to achieve some interesting results (e.g., rw will return the largest integer in an array).

@Shaggy Thanks, I had the basic idea of "auto-functions" but didn't realize there was a post for Japt tips. Gonna definitely look through that post.

We still have a good bit of work to do on that question so if you have something that you feel could be added, please do. Or if you have a query that you think would fit in there, let us know in the comments or join us in the chatroom.

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

Nice use of &.: -- I wasn't aware of the : of Under.

Scheme - 58 bytes.
(define (f a b) (-(+(abs a)(abs b))(sqrt(* a a)(* b b))))

Welcome to PPCG!

You can remove two spaces - one between the define and the (, and one between the ) and the (.

Error: sqrt: too many arguments (at most: 1 got: 2) [f, sqrt]

(lambda(a b)(...)) should be sufficient instead of binding it to a name. Also, (sqrt(* a a b b)) would save a couple bytes.

J, 9 8 bytes
-1 thanks to my colleague Marshall.
+&|-|@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.

APL (Dyalog), 14 bytes
Takes argument in the form xJy, e.g. 3J4
||-2+/∘|9 11○⊢

Try it online!
| the magnitude ofDoc
| 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
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○⊢)

Pyth, 8 bytes
-s.aMQ.a

Try it online. Test suite.
Explanation
-s.aMQ.aQ      Q (input) appended implicitly
  .aMQ         absolute values of input vector
 s             sum
-              subtract
      .aQ      norm2 of input vector

05AB1E, 7 bytes
ÄO¹nOt-

Try it online!
Explanation
Ä        # absolute value of inputs
 O       # sum
  ¹      # push input again
   n     # square
    O    # sum
     t   # sqrt
      -  # subtract

MATL, 8 7 bytes
|sG2&|-

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

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

That looks like 24-26 bytes to me, depending on how √ and $Ans^2$ are encoded .  10 keystrokes, perhaps, but that's not the same thing.

@Ray TI-Basic is a tokenized language.

I'm mostly familiar with TI-89 Basic, where that isn't the case.  Objection withdrawn.

Pyth, 7 bytes
a.aQsa0

Try it here

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!

Common Lisp, 57 bytes
(defun g(a b)(+(abs a)(abs b)(-(sqrt(+(* a a)(* b b))))))

Try it online!

Jelly, 7 bytes
²S½ạAS$

Try it online!
Format is list of two numbers.

Add++, 59 57 bytes
D,f,@@,|@|+
D,g,@@,d*@d*+
_
$f>G>G
V
$g>?>?
S
-G
$f>x>0
O

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

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.

Can't you use an anonymous lambda? {(+/|⍵)-(+/⍵*2)*.5}?

@Adám I don't have a lot of experience with APL and the newest version of the GNU interpreter (1.7) won't compile on Mac, so there might be some limitations. I'll try later to see if it works. Thanks for the tip.

Almost all features of GNU APL are also in Dyalog APL, which is freely available on Mac. You can also try it online.

Also, feel free to join the APL chat room to learn more APL.

Pip, 15 bytes
ABa+ABb-RT$+g*g

Takes input from command-line arguments. 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.

PHP>=7.1, 54 bytes
[,$x,$y]=$argv;echo abs($x)+abs($y)-sqrt($x**2+$y**2);

PHP Sandbox Online
PHP, 55 bytes
<?=abs($x=$argv[1])+abs($y=$argv[2])-sqrt($x**2+$y**2);

Try it online!
PHP, 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!

,,,, 18 bytes
Essentially a port of my Python answer.
a:↔a:0•2*⇆2*+√↔+↔-

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)]

It's two bytes shorter to put it directly in a cell in the sheet: =ABS(A1)+ABS(B1)-SQRT(A1^2+B1^2)

@EngineerToast, I thought that I had already put up my Google Sheets/ Excel Solutions - thanks for pointing this out

Pari/GP, 25 bytes
x->n=normlp;n(x,1)-n(x,2)

Try it online!

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.

The only reason he didn't use builtins was because that language didn't have any available for him to use. Nice answer, and welcome to PPCG! :)

Welcome to PPCG! The TIO Portal has a working Ruby 2.4.0 that you can use to try things out online. Try it here

Taking advantage of the flexible i/o requirements, you could avoid parsing and puts-ing, golfing down to a 35-byte lambda.

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 !
The coordinates are two numbers on the stack.
PS my first code golf... don't hit too hard ;-)!

Ruby, 31 bytes
Creates a complex number to calculate the distance with.
->x,y{x.abs+y.abs-(x+y*1i).abs}

Try it online!

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)

Japt, 7 bytes
Takes input as an array.
x²¬nUxa

Try it (includes all test cases)
x²¬nUxa     :Implicit input of array U
x           :Sum of
 ²          :  Squares
  ¬         :Square root
   n        :Subtract from
    Uxa     :  Sum of absolute values of U

Husk, 7 bytes
-√ṁ□¹ṁa

Try it online!
-√ṁ□¹ṁa
     ṁa     # sum of absolute values
-           # minus
 √ṁ□¹       # square root of sum of squares

Factor, 27 bytes
[ dup l1-norm swap norm - ]

Try it online!

Thunno 2, 6 bytes
ÆH¤AS_

Try it online!
Explanation
ÆH¤AS_  # Implicit input
  ¤AS   # abs(a) + abs(b)
ÆH   _  #                 - hypot(a, b)
        # Implicit output

Vyxal, 6 bytes
₌∆/ȧ∑ε

Try it Online!
Explanation
₌∆/ȧ∑ε  # Implicit input
₌       # Parallel apply:
 ∆/     #  Hypotenuse
   ȧ    #  Absolute value
    ∑   # Sum the absolute values
     ε  # Absolute difference
        # Implicit output

Desmos, 33 bytes
f(a,b)=abs(a)+abs(b)-\sqrt{aa+bb}

Try it on Desmos!

Casio-Basic, 27 bytes
abs(a)+abs(b)-norm([a,b]

Turns out you can just leave off that last bracket and it'll work fine. Having norm as a built-in makes it even shorter!
24 bytes for the code, 3 bytes to add a,b as parameters.

QBIC, 27 bytes
?abs(:)+abs(:)-sqr(a^2+b^2)

ExtraC, 82 bytes
import math
lambda dbl f,x,y,abs(x)plus abs(y)minus sqrt(x times x plus y times y)

Try it online!
Presenting my new language, ExtraC! It's supposed to look like python, but it's really just C. Oh, and it has almost no symbols available to it.
Simply put, this imports the math library (for sqrt), and defines a function f which takes two integers and returns a double.
Example usage:
import math
lambda dbl f,x,y,abs(x)plus abs(y)minus sqrt(x times x plus y times y)
// end submission
let x be readint, y be readint
disp(f(x, y))

Which, for input 3 3 would output: 1.75736 Try it online!

Java 7,   92 73 bytes
double c(int a,int b){return Math.abs(a)+Math.abs(b)-Math.sqrt(a*a+b*b);}

Ungolfed, I think it is self explanatory:
double c(int a,int b){
    return Math.abs(a)+Math.abs(b)-Math.sqrt(a*a+b*b);
}

Suggest return(a<0?-a:a)+(b<0?-b:b)-Math.hypot(a,b); instead of return Math.abs(a)+Math.abs(b)-Math.sqrt(a*a+b*b);

Scala 8, 48 bytes
a=>b=>Math.abs(a)+Math.abs(b)-Math.sqrt(a*a+b*b)

Explained:
a=>b=>                   A curried function with two parameters, 'a' and 'b'.
Math.abs(a)              The absolute value of 'a'.
+Math.abs(b)             Plus the absolute value of 'b'.
-Math.sqrt(a*a+b*b)      Minus the squareroot of 'a' squared plus 'b' squared.

I'm not very experienced with Scala for there is probably a few improvements that could be made.

PHP 7, 109 bytes (insane variant)
$a[0]=($s=array_sum)($a=($m=array_map)(function($n){return$n*$n;},$argv));
$a=$m(sqrt,$a);
echo$s([-$a[0]]+$a);

linebreaks are for reading convenience only. Run with -nr.

Perl 5, 41 + 2 (-pa) = 43 bytes
$_=abs($F[1])-sqrt($F[0]**2+$F[1]**2)+abs

Try it online!

source: Stack Exchange

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/

sort: votes


text:
Operator precedence: How wrong can I be?
Say I have an expression:
9 * 8 + 1 - 4

This expression can be interpreted in six different ways, depending on operator precedence:
(((9 * 8) + 1) - 4) = 69 (* + -)
((9 * 8) + (1 - 4)) = 69 (* - +)
((9 * (8 + 1)) - 4) = 77 (+ * -)
(9 * ((8 + 1) - 4)) = 45 (+ - *)
((9 * 8) + (1 - 4)) = 69 (- * +)
(9 * (8 + (1 - 4))) = 45 (- + *)

Say I'm a developer, and I don't feel like memorizing precedence tables, etc., so I'm just going to guess.
In this case, the largest margin of error would be 45-77, which is a difference of 32. This means that my guess will only be off by a maximum of 32.
The challenge
Given an expression consisting of numbers and +, -, *, / (integer division) and %, output the absolute difference of the largest and smallest possible value for that expression, based on the precedence of operators.
Specifications

The input expression will not contain parenthesis and every operator is left-associative.
The input expression will only contain nonnegative integers. However, subexpressions may evaluate to negatives (e.g. 1 - 4).
You can take the expression in any reasonable format. For example:

"9 * 8 + 1 - 4"
"9*8+1-4"
[9, "*", 8, "+", 1, "-", 4]
[9, 8, 1, 4], ["*", "+", "-"]

The input will contain at least 1 and at most 10 operators.
Any expression that contains a division or modulo by 0 should be ignored.
You can assume that modulo will not be given negative operands.

Test Cases
9 * 8 + 1 - 4             32
1 + 3 * 4                  3
1 + 1                      0
8 - 6 + 1 * 0              8
60 / 8 % 8 * 6 % 4 * 5    63

@AndersKaseorg It looks like you're treating % as having two different precedences in your second example.

@AndersKaseorg it may be that the second of your equations mixes the precedences of operators - at one point * beats % and at another % beats * (i.e. there should only be 6 equations due to 3 distinct operators, not 120 due to 5 operators (or 6 numbers)). EDIT - ah I see Challenger5's edit said the same.

Three of the 'six' are identical, as are another two. That leaves three actual cases, not six.

how % operator works on negative numbers? The way like C or Python or something else?

Just saying, you don't have to add the "and I'm lazy" part to your description.  Just saying you're a developer is enough.  :)

@EJP That's true, but in the 45 cases, as well as one of the 69 cases, the identical value comes from the semantics of + and -, not because they are equivalent expressions. So really, it can be interpreted in three different ways.

@tsh Any behavior. Do whatever you want. You can make demons fly out of my nose.

((60 / 8) % 8) * (6 % 4) * 5=75, (60/8)%(8*6)%(4*5)=7.5, so the last test case should be 67.5. What am I missing?

@bartavelle Are you using / as real division instead of integer division? I get your answer (67.5) using real division, and the test answer (63) using integer division.

Ah that makes sense!

If you don't feel like memorizing precedence tables, just use APL/J/K!

@Adám My boss says that I can't use those languages, so this is my only hope.

Are you supposed to assume the operators all have different precedences, even though in real languages they don't? It can affect the result. For example, 2 % 3 * 2 % 3 is 1 in most languages, but if % and * have different precedence then it can only be 2 or 4. The top-voted answers disagree on this case: Anders Kaseorg's returns 3 and fireflame241's returns 2.

Python 2, 171 156 bytes
lambda a:max(e(a))-min(e(a))
u=')%s('
def e(a,t=u):
 try:b=[eval(a)]
 except:b=[]
 return sum([e('(%s)'%a.replace(o,t%o),u%t)for o in"+-*/%"if' '+o in a],b)

Try it online!
How it works
We surround each operator with a different number of outward-facing pairs of parentheses to simulate different precedences (in all possible ways), and wrap enough inward-facing pairs of parentheses around the entire string, to get an expression we can eval.  For example, with
+ ↦ )+(
* ↦ ))*((
- ↦ )))-(((
we get
9 * 8 + 1 - 4 ↦ (((9 ))*(( 8 )+( 1 )))-((( 4))) = 77.

You can save 2 bytes by moving the or outside the sum to remove a layer of square brackets: sum([...],[])or[eval(a)] instead of sum([...]or[[eval(a)]],[])

@Strigoides I had been thinking that wasn’t equivalent, because the sum may be empty without its argument being empty—however, it’s actually fine because the eval must fail in that case. Thanks.

Jelly, 126 bytes
"Operator Precedence? Parentheses? Pah, who needs that?" - challenges of using Jelly for an operator precedence challenge.
⁾[]i$€Ḥæ%3+\¬œp¹Ḋ€
ÇµḟØDO%9µÐṀṪɓœṣ⁹,ṚÑj@¥/
ÇµVṾµ1ĿFḟØDḟ”-Lµ?ÐL
5Ḷx@€“]“[”ż⁸j/€,@y³Fɓ³i@€Ṁ’x@“[“]”jÇ
“+_×:%”Œ!Ç€µṾL_L’ỊµÐfV€ṢIS

Try it online!
Input is taken as a string, e.g. "1+2_3×4:5%6". Note multiplication uses "×" instead of "*", division uses ":" instead of "/", and subtraction uses "_" instead of "-".
How it Works
The program is divided into three parts: generating all expressions of different operator precedence, evaluating them, and returning the difference between the maximum and minimum.
All expressions are generated with the code:
5Ḷx@€“]“[”ż⁸j/€,@y³Fɓ³i@€Ṁ’x@“[“]”jÇ (4) helper link: returns all outputs given a permutation. Input e.g. "_+:×%"
5Ḷx@€“]“[”           - repeat outer brackets to get ["",""],["]","["],["]]","[["],["]]]","[[["],["]]]]","[[[["]
          ż⁸j/€      - insert the operations in to get "_","]+[","]]:[[","]]]×[[[","]]]]%[[[["
               ,@    - turn this into a mapping equivalent to "_"↦"_","+"↦"]+[",":"↦"]]:[[","×"↦"]]]×[[[","%"↦"]]]]%[[[["
                 y³F - use this mapping to get the right number of outward brackets on each operation. e.g. "1]+[3]]]×[[[4"
ɓ³i@€Ṁ’x@“[“]”j      - add the right number of brackets to the end to get e.g."[[[1]+[3]]]×[[[4]]]"
               Ç     - this calls the link which evaluates the expression
“+_×:%”Œ!Ç€                          (5a) main link. Input e.g. "1+3×4"
“+_×:%”                                 - the string "+_×:%"
       Œ!                               - all permutations
         Ç€                             - apply link (4) to each permutation

The links are evaluated with this (I could probably improve with a different structure):
⁾[]i$€Ḥæ%3+\¬œp¹Ḋ€      (1) Helper link: Outputs a list of expressions within brackets, e.g. "[[[1]+[3]]]×[[[4]]]"↦"[[1]+[3]]","[[4]]"
⁾[]i$€Ḥæ%3                 - map "[" to 2, "]" to -2, and any other character to 0.
          +\¬              - cumulative sum negated: 1s at characters not in brackets (includes opening brackets), 0s otherwise (includes closing brackets)
             œp¹           - partition the input, not including borders, based on the sum to get "[[[1]+[3]]","[[[4]]"
                Ḋ€         - remove opening brackets
ÇµḟØDO%9µÐṀṪɓœṣ⁹,ṚÑj@¥/ (2) Return the input to this link with one of the expressions from (1) evaluated
ÇµVṾµ1ĿFḟØDḟ”-Lµ?ÐL     (3) link called from part 1: Evaluates expressions
 µ  µ          µ?          - if:
     1ĿFḟØDḟ”-L            - the input contains no operators within brackets:
  VṾ                         - evaluate this one expression with normal Jelly calculation and return to string
                           - otherwise:
Ç                            - evaluate one subexpression using link (2)
                  ÐL       - repeat this until a single output is determined

The difference between the maximum and minimum is computed with the code in link (5):
µṾL_L’ỊµÐfV€ṢIS (5b) determine difference between minimum and maximum
µ      µÐf        - filter out outputs involving division or modulo by 0. Determined with:
 ṾL_L’Ị           - actual numbers have their unevaled form Ṿ no more than one byte longer than the non-unevaled form.
          V€      - evaluate each of these valid numbers to get integers from strings
            Ṣ     - sort
             IS   - return the sum of all difference between consecutive elements.

Probably the longest Jelly answer (without embedded data) I've ever seen. Well done!

@KeyuGan If you want longer Jelly answers, look at this answer. I can't think of any other long Jelly answers without compression.

Python 2, 235 234 233 226 bytes
-1 byte (and a fix) thanks to Anders Kaseorg!
-7 bytes thanks to Step Hen!
from itertools import*
def f(e,a=()):
 for o in permutations("+-*/%"):
	l=e[:]
	for c in o:
	 for i in range(len(l),0,-1):
		if l[i-1]==c:l[i-2:i+1]=["("+l[i-2]+l[i-1]+l[i]+")"]
	try:a+=eval(*l),
	except:0
 print max(a)-min(a)

Try it online!

Function submissions must be reusable. You can fix that problem by letting a be a tuple instead of a list, and even save 1 byte by doing so (a=(), a+=eval(*l),).

Huh, TIL. Thanks for the tip!

Since you're in Python 2, you can save some bytes by alternating spaces and tabs for indentation (in this case, 2 spaces -> tab, three spaces -> tab + space, four spaces -> two tabs) Try it online!

Haskell, 254 bytes
import Data.List.Split
import Data.List
f s=(-)<$>maximum<*>minimum$permutations(zip"+-*/%"[p(+),p(-),p(*),c$div,c$mod])>>=(s!)
p=((pure.).)
c o a b=[o a b|b/=0]
s![]=[read s]
s!((x,o):y)=case splitOn[x]s>>=(!y)of[]->[];l->l?o
[a]?_=[a]
(a:b)?o=b?o>>=o a

Try it online!
Input is a whole string, such as 4+5 * 2. It generates all permutations of operations, and for each permutation splits the string recursively. It filters divisions by 0 with the list monad.

(%) is modulus operator.  It is remainder of a division operation between the left argument and the right argument.

Haskell 582 bytes
This didn't go nearly as well as I hoped it would...
import Data.List
f x=case x of '+'->(+);'-'->(-);'*'->(*);'/'->div;_->rem
e _ s[]=s
e 1 s(')':x:a)|0<-(read$e 0""a),(x=='%'||x=='/')=""|""<-(e 0""s)=""|""<-(e 0""a)=""|0<3=show$(f x)(read$e 0""s)$read$e 0""a
e 1 s")"=e 0""s
e n s(')':a)=e(n-1)(s++")")a
e 0 s('(':a)=e 1 s a
e n s('(':a)=e(n+1)(s++"(")a
e n s(x:a)=e n(s++[x])a
n?s=take n$cycle s
a!b=e 0""(9?"("++(concat$zipWith(++)a(b++[[]]))++9?")")
c#b|l<-[read x|x<-map(c!)(a b),x/=""]=maximum l-minimum l
a c=transpose$map(\x->map((\(Just q)->q).lookup x)$map(\a->zipWith(\x y->(y,x?")"++y:x?"("))[1..5]a)$permutations"+-*%/")c

Try It Online!
Trying to golf a long program just makes me write bad code :(
I tried to use Anders' algorithm in Haskell, but it got out of my control
The function e is like a specific case of eval. (#) takes a list of strings representing integers and a string of operators and returns the difference between the maximum and minimum possible values. e.g
(#) ["9","8","1","4"] "*+-" => 32

If you renamed # to ##, you could rename e to (#), like so: (n#s)(x:a)=...

If you alias the following three commonly used functions you can save a further 6 bytes.  r=read;j=zipWith;o=map and then replace those functions with the letter aliases.

Also I am counting 594 bytes, not 582.

Pyth, 45 bytes
KS.nm.x.vj\ u.nm+*H/kHckHGd]s.iFQY.p_{eQ-eKhK

I'm sure that a lot more optimization can be done, but I like it so far.
Takes input like this: [9, 8, 1, 4], ["*", "+", "-"].
Try it online!

Can you add an explanation?

Javascript, 280 bytes
Note: The integer division rounds using the floor function, which means that negative numbers round away from zero.
This solution is based on this answer.
b=>(Math.max(...(f=(a,h="(",i=")",r=[...a[d="replace"](/[^-+*/%]|(.)(?=.*\1)/g,"")])=>(r[0]?(r.map((c,j)=>s=s.concat(f(h+a[d](RegExp("\\"+(n=r.concat()).splice(j,1),"g"),i+c+h)+i,h+"(",i+")",n)),s=[]),s):(a=eval(`(${a})`[d](/\(/g,"Math.floor(")))==a&&1/a?a:r))(b))-Math.min(...f(b)))

Example code snippet:

g=

b=>(Math.max(...(f=(a,h="(",i=")",r=[...a[d="replace"](/[^-+*/%]|(.)(?=.*\1)/g,"")])=>(r[0]?(r.map((c,j)=>s=s.concat(f(h+a[d](RegExp("\\"+(n=r.concat()).splice(j,1),"g"),i+c+h)+i,h+"(",i+")",n)),s=[]),s):(a=eval(`(${a})`[d](/\(/g,"Math.floor(")))==a&&1/a?a:r))(b))-Math.min(...f(b)))

for(k=0;k<5;k++)
  v=["9*8+1-4","1+3*4","1+1","8-6+1*0","60/8%8*6%4*5"][k],
  console.log(`g(${v}) = ${g(v)}`)

How hard would it be to make it compliant by replacing the a/b case with a/b|0?

@trlkly a/b|0 stops the divide/modulo 0 error check, but Math.floor(a/b) worked

Mathematica, 186 164 159 bytes
eMax@#-Min@#&[Fold[#//.{m___,x_,#2[[0]],y_,n___}:>{m,x~Last@#2~y,n}&,e,#]&/@Permutations@{"+"@Plus,"-"[#-#2&],"*"@Times,"/"@Quotient,"%"@Mod}/. 0/0|1/0->{}]

\[Function] takes 3 bytes.
Some alternatives (keeps bytecount the same)
#2-#&@MinMax[...] to replace Max@#-Min@#&[...]
Head@#2 to replace #2[[0]]
Try it online at http://sandbox.open.wolframcloud.com : enter ( .... )[{60, "/", 8, "%", 8, "*", 6, "%", 4, "*", 5}] with .... replaced  by code above for test case 60 / 8 % 8 * 6 % 4 * 5. Press Shift + enter to evaluate.

Python 2, 262 256 254 bytes
from itertools import*
def r(s,o):
 try:
  while o in s:i=s.index(o)-1;s[i:i+3]=[`eval(''.join(s[i:i+3]))`]
  return s
 except:0
def f(s):
 u=[int(v[0])for v in [reduce(r,O,s.split(' '))for O in permutations('*/%+-')]if v!=None];return abs(max(u)-min(u))

Try it online!

Save some bytes by also using tabs: Try it online!

Save one byte by changing in [ to in[ (space isn't needed)

JavaScript (ES6), 210 bytes
Input as an array of numbers and operators
k=>(m=n=-k,r=(o,k,j=0)=>{for(o||(m=m>k?m:k,n=n<k?n:k);q=o[j++];(q>'%'&q<'/'||z)&&r(o.slice(0,j-1)+o.slice(j),h))for(h=[...k],z=1;i=h.indexOf(q)+1;h.splice(i-2,3,eval(a=h[i-2]+q+h[i])|0))z*=h[i]})('+-*/%',k)|m-n

Less golfed
k=>(
  m = n = NaN,
  r =(o, k, j=0) => {
    // try all operators in o
    for(;q = o[j]; j++)
    {
      // q : current operator,
      // look for q inside the expression to evaluate
      for(h = [...k], z = 1; i = h.indexOf(q) + 1;)
      {
        a = h[i - 2]
        b = h[i]
        z *= b // trace if any second operand is zero
        // subst subexpression with its value
        h.splice(i - 2, 3, eval(a + q + b) | 0)
      }
      // now all subexp involving current operator are evaluated
      // the result is ok if current operator is not % or /
      //  OR if no second operand was zero
      (q > '%' & q < '/' || z) &&
        // try again recursively
        // using the remaining operators and the remaining expression
        r(o.slice(0, j) + o.slice(j+1), h)
    }
    // if no more operators to try, check max and min
    // k is an array with 1 element, can be used like a single number
    o || (
      m = m > k ? m : k,
      n = n < k ? n : k
    )
  },
  r('+-*/%', k),
  m-n
)

Test

var F=
k=>(m=n=-k,r=(o,k,j=0)=>{for(o||(m=m>k?m:k,n=n<k?n:k);q=o[j++];(q>'%'&q<'/'||z)&&r(o.slice(0,j-1)+o.slice(j),h))for(h=[...k],z=1;i=h.indexOf(q)+1;h.splice(i-2,3,eval(a=h[i-2]+q+h[i])|0))z*=h[i]})('+-*/%',k)|m-n

function update() {
  var input = I.value.match(/\d+|\S/g)
  var result = F(input)
  O.textContent = I.value + ' -> ' + result + ' (max:'+m+' min:'+n+')'
}

update()
<input id=I value="60 / 8 % 8 * 6 % 4 * 5" oninput='update()'>

PHP, 316 bytes
<?for(;$t++<54322;)count_chars($t,3)!=12345?:$p[]=$t;foreach($p as$x){for(list($z,$q)=$_GET,$b=1,$i=0;$y=strtr($x,12345,"/%*+-")[$i++];)while(-1<$k=array_flip($q)[$y]){$n=$k+1;if($b&=$z[$n]||ord($y)%10<6)eval("\$z[$k]=$z[$k]$y$z[$n]^0;");($s=array_splice)($z,$n,1);$s($q,$k,1);}$b?$r[]=$z[0]:0;}echo max($r)-min($r);

Try it online!
Expanded
for(;$t++<54322;)
  count_chars($t,3)!=12345?:$p[]=$t;
foreach($p as$x){
  for(list($z,$q)=$_GET,$b=1,$i=0;$y=strtr($x,12345,"/%*+-")[$i++];)
    while(-1<$k=array_flip($q)[$y]){
      $n=$k+1;
      if($b&=$z[$n]||ord($y)%10<6)
        eval("\$z[$k]=$z[$k]$y$z[$n]^0;");
      ($s=array_splice)($z,$n,1);
      $s($q,$k,1);
    }
  $b?$r[]=$z[0]:0;
}
echo max($r)-min($r);

The lase case is 63. Your mistake due to giving the same operator a different precedence in different parts of one expression

Python 3, 284 bytes
Edit: seems like something's wrong with evaluating the last example. I'll look into it tomorrow.
Another Python answer. Couldn't outgolf everyone else, but I spent too long on this to not put it up.
from itertools import*
def f(n,o):
 z=[]
 for p in permutations("+-*/%"):
  try:
   p,x,a=[*p],n[:],o[:]
   while(p):
    for i,d in enumerate(a):
     if d==p[0]:x[i+1]=str(eval(x[i]+d+x[i+1]));x.pop(i);a.pop(i)
    p.pop(0)
   z+=x
  except:0
 z=[*map(float,z)];return max(z)-min(z)

Try it online!

while(p) can become while p for one byte saved.

Clojure (+ combinatorics), 342 377 + 41 = 418 bytes
+35 bytes because of a bug.
(fn[x y](let[l filter s first z #(l(fn[y]y)%)r(sort(z(for[e(q/permutations[+ - * quot mod])](try(loop[t e m y a x](if(=[]t)(s a)(let[j(s t)i(reverse(keep-indexed #(if(= j %2)%)m))](recur(rest t)(l #(not= j %)m)(loop[d 0 h a](if(=(count i)d)h(let[c(nth i d)f(inc c)](recur(inc d)(vec(z(assoc h c(j(nth h c)(nth h f))f nil)))))))))))(catch Exception _ nil)))))](-(last r)(s r))))

Try it online!
For this function to work, you have to use the clojure.math.combinatorics library (41 bytes):
(use '[clojure.math.combinatorics :as q])

Nuances:
This function is an anonymous function, which means you must do  this to use it:
((fn[x y]...) numbers operators)

Also, I'm using the word quot instead of / (since Clojure does fraction division by default), and mod instead of %.
Ungolfed program:
(defn precedence [numbers operators]
  (let [results
        (sort
          (for [permute (c/permutations [+ - * / mod])]
            (loop [p-temp permute
                  o-temp operators
                  n-temp numbers]
              (if (empty? o-temp) (first n-temp)
                (let [first-p (first p-temp)
                      indices (reverse (keep-indexed #(when (= first-p %2) %) o-temp))]
                  (recur
                    (rest p-temp)
                    (filter #(not= first-p %) o-temp)
                    (loop [ind 0
                          n-through n-temp]
                      (if (= ind (count indices)) n-through
                        (let [current-ind (nth indices ind)]
                          (recur
                            (inc ind)
                            (vec
                              (filter #(not (nil? %))
                                (assoc n-through
                                  current-ind (first-p (nth n-through current-ind) (nth n-through (inc current-ind)))
                                  (inc current-ind) nil)))))))))))))]
    (- (last results) (first results))))

I think you can just say "Closure + Combinatorics" and not have to score the use statement.

@Challenger5 I believe you'd better write it in the description, because by default, The characters used to import the library will likely be counted https://codegolf.meta.stackexchange.com/questions/10225/general-rules-for-custom-languages-and-libraries

@KeyuGan You're right - I misunderstood that Meta consensus. I think the require needs to be included in the code and its length should be added to the byte count.

@Challenger5 So I need to add 41 bytes into my bytecount, right? OK.

@Qwerp-Derp Yes, but the import is part of your code, and you can golf it.

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/


text:
Am I a Sophie Germain prime?
A Sophie Germain Prime is a prime number P such that 2P+1 is prime as well. Given a prime number as input, your task is to determine whether it is a Sophie Germain Prime.
Standard Input/Output rules and Default Loopholes apply.
This is a decision-problem, so standard rules for this tag apply (returning two distinct and consistent values for each case, e.g: True/False).

Test Cases
Truthy (Sophie Germain primes)
These are the first few of them (OEIS A005384):
2, 3, 5, 11, 23, 29, 41, 53, 83, 89, 113

Falsy
7, 13, 17, 31, 37, 43, 47

Please note that answers with explanations are encouraged!
It's code-golf, hence the shortest code in bytes in every language wins!

Can I flip the True/False (i.e. output "False" if the prime is a SG prime, "True" otherwise)?

@Qwerp-Derp Of course, any value can be used as long as you specify it.

Personally, I think ir would have been best to not gusrantee primality of the input.

Does "returning two distinct values for each case" imply the values must be consistent rather than the tag text "either truthy or falsy" or may we return inconsistent, but if-testable, values?

You should have a set of values for truthy and their complement for falsy, if you choose to have them inconsistent. Can I define SG primes as truthy values? :P

@Dennis Of course... not

EDIT: The values must be consistent

That is not a problem if we use the tag text of "either truthy or falsey" though (this means the results must be if-testable, which, unless there is some eso-lang out there that has that bizarre feature, S.G. primes wont be).

.. See this meta-post by Peter Taylor regarding that definition.

@JonathanAllan I will keep them consistent though

I'm not going to vote to close because I have a dupe hammer, but this seems like it's a dupe of Is it a prime?, since the only difference is that the input isn't the number you're testing. Adding the offset (2n + 1) is a pretty trivial modification.

@DJMcMayhem I think it is different though... That one also asks for a full program.

@DJMcMayhem this one checks for two numbers?

@NickT No, the input is guaranteed to be prime

x86-64 Machine Code, 24 bytes
01 FF FF C7 6A 01 59 89 F8 FF C1 99 F7 F9 85 D2 75 F5 39 F9 0F 94 C0 C3

The above code defines a function that takes a single parameter (the input value, known to be a prime) in EDI (following the System V AMD64 calling convention used on Gnu/Unix), and returns a Boolean result in AL (1 if the input is a Sophie Germain prime, 0 otherwise).
The implementation is very similar to the solution to this challenge, since all we really have to do is determine whether a number is prime using as little code as possible, which means an inefficient iterative loop.
Basically, we take the input and immediately transform it into 2 × input + 1. Then, starting with a counter set to 2, we loop through and check to see if the counter is a factor. The counter is incremented each time through the loop. As soon as a factor is found, the loop ends and that factor is compared against 2 × input + 1. If the factor is equal to the test value, then that means we didn't find any smaller factors, and therefore the number must be prime. And since we have thus confirmed that 2 × input + 1 is prime, this means that input must be a Sophie Germain prime.
Ungolfed assembly language mnemonics:
IsSophieGermainPrime:
   add   edi, edi            ; input *= 2
   inc   edi                 ; input += 1
   push  1
   pop   rcx                 ; counter = 1

.CheckDivisibility:
   inc   ecx                 ; increment counter
   mov   eax, edi            ; EAX = input (needs to be in EAX for IDIV; will be clobbered)
   cdq                       ; sign-extend EAX into EDX:EAX
   idiv  ecx                 ; EDX:EAX / counter
   test  edx, edx            ; check the remainder to see if divided evenly
   jnz   .CheckDivisibility  ; keep looping if not divisible by this one

   cmp   ecx, edi            ; compare counter to input
   sete  al                  ; set true if first found factor is itself;
   ret                       ;          otherwise, set false

Python,  46 43 41  40 bytes
-1 byte using code suggested elsewhere by Erik the Outgolfer (2*n+1 may be calculated as n-~n - that is, 2*n+1=n-(-1-n))
f=lambda n,p=3:p>n or(n-~n)%p*f(n,p+2)>0

A recursive function.
Returns True if the prime number input, n, is a Sophie Germain prime and False if not.
Try it online!
Works by multiplying the remainders of the division of the candidate number n-~n (which is equal to 2*n+1) after dividing by p, while p is less than n, starting at p=3 and incrementing by 2 at each iteration. This is sufficient since n is greater that the square root of 2*n+1 (n-~n) for n greater than 2. Also, since 2 is a Sophie Germain prime we can start testing with p=3 and add 2 at each iteration rather than 1. If the original n was greater than 2 the product of the resulting remainders is returned, so if the candidate has any factors the resulting 0 forces the result to be 0 too. The final >0 forces all the positive products to return True and the 0s to return False (to fulfil the "distinct and consistent" requirement).
Also beats:
...the 41 byte Python 3 (with sympy):
import sympy
lambda n:sympy.isprime(n-~n)

...and the 42 byte Python 2 full program Try It:
n=2*input()+1
p=3
while n%p:p+=2
print p<n

You do not need the brackets

44 bytes, forgot to remove the space

@Mr.Xcoder was busy editing in for 43...I noticed :)

What is it with these weird looking recursive functions and out-golfing me...

@EriktheOutgolfer I wrote about that in the answer - the OP requests "two distinct values for each case", I had meant to ask, and have now.

@JonathanAllan Actually seems to be allowed to remove >0.

@EriktheOutgolfer yeah I confirmed it, and have now updated the code, thanks!

@JonathanAllan Sorry, I have updated the rules, I'm very sorry for the confusion I created. It was an issue spotted by Dennis, that one may choose the SG primes as the truthy values, and that would be trivial

@Mr.Xcoder righto, I rolled it back.

Python 2, 39 bytes
f=lambda n,k=3:n%k^k/2>0<f(n,k+2)or k>n

Try it online!
Alternate versions
f=lambda n,k=3:n%k^1>0<f(n-1,k+2)or k>n

f=lambda n,k=3:~-n%k>0<f(n-1,k+2)or k>n

f=lambda n,k=3:n%k!=1==f(n-1,k+2)or k>n

I usually don't ask for one on Python answers... But could we have an explanation as to what is going on?

I've recreated the top solution in a more verbose way, altering some of the code but leaving the same logic. Though I'm still not quite sure why it works.

@totallyhuman If (2*n+1)%k gives 0, n%k gives either 0 or (k-1)/2. Since n is prime, n%k cannot give 0, so it suffices to check for the latter case. I'll add a more detailed explanation tomorrow.

MATL, 4 bytes
EQZp

Prints 1 for a Sophie Germain prime and 0 otherwise.
Try it at MATL Online
Explanation
        % Implicitly grab input as a number
E       % Multiply by 2
Q       % Add one
Zp      % Check if this is a prime number
        % Implicitly display the result

Mathematica , 13 bytes
PrimeQ[2#+1]&

TIO link? (mathics)

Pyth, 4 bytes
Almost an anagram for Pyth.
P_hy

Try it online!
Other semi-anagrams: Pt_y, P_tyh.
How?
   y   # Double
  h    # Increment
 _     # Negate
P      # Prime?

P for positive argument factorizes; to test primality one should provide the negation of the number tested.

Why do you need to negate?

@totallyhuman P with negative argument check if -argument is prime, P with positive argument returns list of prime factors

It'd be great if you could find a way to make this an anagram of Pyth...

@daniero You're assumed prime input.

@BetaDecay I can do P_tyh (inc, double, dec)

CJam, 7 bytes
{2*)mp}

Try it online!

05AB1E, 3 bytes
x>p

Prints 1 if the prime number input is a Sophie Germain prime, and 0 if it is not (prints 1 if double the input plus one is prime).
Try it online!
How?
x>p - implicit input: number n
x   - pop n then push n, 2*n
 >  - pop 2*n then push 2*n+1
  p - pop 2*n+1 then push is prime? (2*n+1) {True:1; False:0}
    - implicit print of top of stack

Python 2, 47 43 42 bytes
-4 bytes thanks to Leaky Nun. -1 byte thanks to Erik the Outgolfer.
lambda n:all((n-~n)%i for i in range(2,n))

Try it online!

Do you need to check up to 2*n+1?

(2*n+1) can be (n-~n).

@EriktheOutgolfer Oh, nice, thanks!

Basically (2*n+1) can also be (n+n+1) which can be (n+(n+1)), which in turn is the same as (n+-~n) or (n-~n).

Brachylog, 5 bytes
×₂+₁ṗ

Try it online!

Jelly, 4 bytes
Ḥ‘ÆP

A monadic link returning 1 if the prime number input is a Sophie Germain prime, and 0 if it is not (yields 1 if double the input plus one is prime, 0 otherwise).
Try it online!
How?
Ḥ‘ÆP - Link: number n
Ḥ    - double n
 ‘   - increment
  ÆP - is prime?

Neim, 3 bytes
ᚫ>

Try it online!
-1 thanks to Okx.

Neim has a 1-byte 'check for primality' token.

@Okx Oh I searched for it.

C, 43 bytes
i;f(x){for(x=x*2+1,i=1;x%++i;);return x>i;}

Returns 0 if x is a Sophie Germain prime, 1 otherwise.
Try it online!
C (gcc), 38 bytes
i;f(x){for(x=x*2+1,i=1;x%++i;);x=x>i;}

Try it online!

Shave off 2 bytes by using i=1; at the start.

@G.Sliepen Thanks, but then the function would not be reusable, and therefore not a valid submission.

Suggest x-=~x instead of x=x*2+1

PHP, 39 bytes
prints 1 for true and nothing for false

for($d=$n=$argn*2+1;$n%--$d;);echo$d<2;

Try it online!

Julia 0.6, 20 bytes
x->∉(0,(x-~x)%3:x)

Welcome to PPCG!

Clojure, 60 bytes
#((fn[n](some(fn[a](=(mod n a)0))(range 2 n)))(+(* 2 %)1))

Try it online!
This is an anonymous function - to use the function, do this:
(#(...) {number}) ; This will output a value

Returns False if prime is a Sophie Germain prime, True otherwise.

Japt, 5 bytes
*2Ä j

Test it online! Probably won't get shorter than this...
An alternative solution which might be shorter in other languages:
¤Ä n2 j

Test it online! ¤ converts the input to binary, Ä appends a 1, and n2 converts back from base 2 (Japt doesn't have a built-in for converting from binary).

Python 2, 55 bytes:
lambda n:len(filter(lambda p:(2*n+1)%p,range(2,n)))>n-3

Python 2, 48 bytes, different logic:
lambda n:all(map(lambda p:(2*n+1)%p,range(2,n)))

(2*n+1) can be replaced by (n-~n) in both versions.

Your first version can simply be lambda n:len(filter((n~-n).__mod__,range(2,n)))>n-3. Second version is essentially the same as totallyhuman's.

braingasm, 8 5 bytes
;*+q:

Works like this:
;          Input a number
 *+        Double and increase it
   q:      Print 1 or 0 depending on wether the current number is prime

edit: don't need prime check on input

you don't have to test input for primality

@Uriel Got it :)

Pari/GP, 17 bytes
p->isprime(2*p+1)

Try it online!

Julia 0.4, 17 16 bytes
1 byte saved thanks to @Tanj
x->isprime(x-~x)

isprime was deprecated in Julia 0.5.

Identical to the PariGP submission...

@Mr.Xcoder polyglot then?

you can slightly reduce by computing 2*x+1 with x-~x ?

2x+1 is a bit more readable.

QBIC, 7 bytes
?µ:*2+1

Explanation
?        PRINT
 µ       the result of the prime-test (-1 for true. 0 for false)
  :*2+1  with the input times 2 plus 1 as argument

MATLAB / Octave, 18 bytes
@(x)isprime(2*x+1)

Anonymous function.
Try it online!

Ruby 2.3.1, 44 bytes
lambda{|p|(2...2*p+1).all?{|r|(2*p+1)%r!=0}}

Try it online!

C (gcc), 46 bytes
f(x,i){for(i=2;i<x;)(x-~x)%i++?:(x=i=0);x=!x;}

Try it online!
Returns 0 if SG prime, 1 otherwise.

What does GCC do with the empty "true" portion of the conditional operator? How does that get interpreted?

@CodyGray If the "true" part is empty, the value of the condition is returned instead of it.

@CodyGray Well, it's only returned to nowhere so don't worry.

Yes, I realize this is completely invalid and meaningless code that only just barely "works" if the stars are aligned just-so. I've been told that doesn't bother anyone on Code Golf, so I'm just trying my best to ignore it. I was intrigued, though, by the GCC extension with an empty "true" portion of a conditional operator, because I'd never seen that before and it wasn't immediately obvious to me how it worked. @Steadybox answered that with a reference, so much thanks!

Excel VBA, 59 Bytes
Anonymous VBE immediate window function that takes input from cell [A1] to and outputs to the vbe immediate window
Must be run in a clean module or the value of j must be reset to 0 before use
n=[2*A1-1]:For i=2To n-1:j=IIf(n/i=Int(n/i),i,j):Next:?j<>0

,,,, 5 bytes
2×1+p

Unlike other golflangs, ,,, doesn't have builtins for incrementing and doubling because I thought I'd rather use those bytes for other things. :P
Explanation
Take input 23 for example.
2×1+p

       implicit input                      [23]
2      push 2                              [23, 2]
 ×     pop 23 and 2 and push 23 * 2        [46]
  1    push 1                              [46, 1]
   +   pop 46 and 1 and push 46 + 1        [47]
    p  pop 47 and push whether it is prime [1]
       implicit output                     []

cQuents, 9 bytes
#|2A+1?pz

Had to fix an interpreter bug to get this working, so no TIO link.
Explanation
#|2A+1      The last item in the input, which will become n, equals the first item
            in the input times two, plus one.
      ?     Mode: query. Returns true if n is in the sequence, and false otherwise.
       pz   Sequence: each item is the next prime after the previous item.

Note current version uses Z instead of z


text:
Number Named Regex Groups
Using named matching groups is often easier to understand than numbering groups but takes up more bytes. Given a regular expression as specified below, your program or function must convert named groups to numbered groups.
Task
These specifications are based on python 3's re module.
A named group takes the form of (?P<name>...) where name is replaced with the name of the group and ... is a valid regex.
A reference to a named group takes the form of (?P=name) where name is replaced with the name of the group.
A numbered group takes the form of (...) where ... is a valid regex.
A reference to a numbered group takes the form of \number where number is replaced with the number of the group as follows:

groups are numbered from left to right, from 1 upward. Groups can be nested; to determine the number, just count the opening parenthesis characters, going from left to right.
  (Python howto)

The number of opening parentheses characters includes the group's opening parenthesis.
Thus your program or function must, given a valid regular expression, convert named groups to numbered groups and references to named groups to references to numbered groups with the right number.
Example
The input is s(tar)+t(?P<name1>subre)cd(?P=name1). The (?P=name1) bit refers to the capturing group (?P<name1>subre). It is group 2 because the string s(tar)+t( contains two opening parentheses. Thus (?P=name1) is replaced with \2 to get s(tar)+t(?P<name1>subre)cd\2
The (?P<name1>subre) group can be converted to a non-named group by simply removing the name and identification to get (subre). Applying this into the string so far yields s(tar)+t(subre)cd\2. Since there are no named groups nor named references, the program is done and outputs s(tar)+t(subre)cd\2.
Rules

There are no non-capturing groups in the input regular expression (in other words, all groups are either numbered or named).
You may assume that all input groups are named.
Any further pedantics due to technical specifications of regular expressions should be ignored.

The input will always contain no digits directly after named backreferences.
Every reference to a named group in the input will have an actual named group to reference to.
All parentheses in the input delimit a group
The group names will contain no spaces.

The output may optionally have a trailing newline.
Brownie points for solving this challenge using a regular expression!

Remember Defaults:

This is code-golf, so shortest code in each language wins.
Of course, standard loopholes are forbidden.
The input and output should be taken in standard I/O methods.

Test Cases
Input
Output
-----
this has no* groups \bubbles
this has no* groups \bubbles
-----
this has (?P<name>named)+ groups (?P=name)
this has (named)+ groups \1
-----
this has no(?P<references> sadness*)?
this has no( sadness*)?
-----
I need (?P<reference> very+ much) here is one: (?P=reference)
I need ( very+ much) here is one: \1
-----
t(?P<one>o)n(?P<another>s) of (?P<groups>named) groups (?P=another) (?P=one) (?P=groups)
t(o)n(s) of (named) groups \2 \1 \3
-----
Of course, we need (?P<moregroups>misdirection) (?P<n>n(?P<e>e(?P<s>s(?P<t>t)i)n)g) (?P=n)n(?P=e)e(?P=s)s(?P=t)ing
Of course, we need (misdirection) (n(e(s(t)i)n)g) \2n\3e\4s\5ing
-----
(?P<Lorem>Lorem ipsum dolor sit amet), (?P<consectetur>consectetur adipiscing elit), (?P<sed>sed do eiusmod tempor incididunt ut labore et dolore magna aliqua). (?P<Ut>Ut enim ad minim veniam, (?P<quis>quis) nostrud exercitation ullamco laboris nisi ut (?P<aliquip>aliquip ex ea commodo consequat.)) Duis aute irure dolor in (?P<finale>reprehenderit in voluptate velit esse cillum dolore eu fugiat (?P<null>null)a pariatur. (?P<Except>Excepteur (?P<sin>sin)t occae(?P<cat>cat) )cupidatat non proident, sunt) in culpa qui officia deserunt mollit anim id est laborum. (?P=cat)(?P=sin)(?P=Except)(?P=null)(?P=finale)(?P=aliquip)(?P=quis)(?P=Ut)(?P=sed)(?P=consectetur)(?P=Lorem)
(Lorem ipsum dolor sit amet), (consectetur adipiscing elit), (sed do eiusmod tempor incididunt ut labore et dolore magna aliqua). (Ut enim ad minim veniam, (quis) nostrud exercitation ullamco laboris nisi ut (aliquip ex ea commodo consequat.)) Duis aute irure dolor in (reprehenderit in voluptate velit esse cillum dolore eu fugiat (null)a pariatur. (Excepteur (sin)t occae(cat) )cupidatat non proident, sunt) in culpa qui officia deserunt mollit anim id est laborum. \11\10\9\8\7\6\5\4\3\2\1

(Above, I was referring to numbered groups as being disjoint from named groups, when named groups are also numbered. Pretend that I meant non-named groups when I said numbered groups.)

"There are no escaped opening parentheses in the input string." What about parentheses inside character classes? "Any further pedantics due to technical specifications of regular expressions should be ignored." Does that include the assumption that there won't be digits after a group reference? (Which would mess up the backreference when converted to numbers.)

Several of your test cases violate the "You may assume that all groups are named." rule (the second, fifth and sixth).

regex101.com says that your fifth example is invalid in multiple ways (spaces inside group name, <>s around backreference name).

JavaScript (ES6), 91 bytes

f=
s=>s.replace(/\(\?P=(\w+)\)|\(\?P<(\w+)>|\(/g,(_,b,n)=>b?`\\`+r[b]:(r[n]=++c,`(`),c=0,r={})
<textarea cols=30 rows=5 oninput=o.textContent=f(this.value)></textarea><div id=o>

If I'm not mistaken, it doesn't work for I need (?P<a reference> very+ much) here is one: (?P=<a reference>), for two reasons: \w+ doesn't allow spaces in the group name; and P=(\w+) doesn't allow <> around the group name in the reference.

@Dada On the other hand, regex101.com says that those aren't valid...

Spaces aren't valid in the group name of a reference. The question has already been edited to fix that

PHP, 198 bytes
preg_match_all("#\(\?P<.+?>|\(\?P=.+?\)|\(#",$a=$argn,$t);foreach($t[0]as$x)$x[1]?$x[3]=="<"?$a=strtr($a,[$x=>"("]).!$n[substr($x,4,-1)]=++$k:$a=strtr($a,[$x=>"\\".$n[substr($x,4,-1)]]):++$k;echo$a;

Try it online!


text:
Conways's Game of Life: Most newborn generating starting pattern
General rules
The universe of the Game of Life is an infinite two-dimensional orthogonal grid of square cells, each of which is in one of two possible states, alive or dead. Every cell interacts with its eight neighbours, which are the cells that are horizontally, vertically, or diagonally adjacent. At each step in time, the following transitions occur:

Any live cell with fewer than two live neighbours dies, as if caused by underpopulation.
Any live cell with two or three live neighbours lives on to the next generation.
Any live cell with more than three live neighbours dies, as if by overpopulation.
Any dead cell with exactly three live neighbours becomes a live cell, as if by reproduction.

The initial pattern constitutes the seed of the system. The first generation is created by applying the above rules simultaneously to every cell in the seed—births and deaths occur simultaneously. The rules continue to be applied repeatedly to create further generations. (Source: Wikipedia )

Specific rules
For this challenge, we will modify a few rules:

The grid is not infinite. We will provide in the inputs the size of the grid. It will not act as a Torus either.
The game stops when the grid reach a state it has already reached before. This prevents patterns infinite loop and can manage empty grids too.

Challenge
Write a program/function that takes four positive integer as input:

x: starting pattern width
y: starting pattern height
n: grid width
m: grid height

and finds the starting pattern that will generate the most amount of cells through the whole game, and outputs that number. (You can also outputs the corresponding pattern if needed)
The patterns is always centered on the grid. If you need to center with odd numbers, the pattern should be slightly closer to the upper left corner. Refer to that drawing for better understanding where the green area is the pattern already centered:

Specifications

Standard I/O rules apply.
Standard loopholes are forbidden.
This challenge is not about finding the shortest approach in all languages,  rather, it is about finding the shortest approach in each language.
Your code will be scored in bytes, usually in the encoding UTF-8, unless  - specified otherwise.
Explanations, even for "practical" languages, are encouraged.

Example
Let's do a small example together. For this example, the pattern size will be x = y = 3 and the grid size will be n = m = 3
The program will test any possible starting pattern. After running it, we find that the maximum amount of generated cells during one whole game is 11.
It is obtained following those steps:

Green cells are alive, lime cells are newborn and brown cells just died. One out of two grid is just the transition between two states. The starting pattern is the first state of the game, in the upper left corner. The game ended when there was no living cells left, but most of the time the game end with a repeating infinite pattern.
Here we can get to 11 by counting every lime cells during the transitions. It corresponds to the total amount of generated cells through the whole game.

Test cases
Input            Output

3 3 3 3          11,    *[[0, 0, 1], [1, 1, 0], [0, 0, 1]]
3 3 5 5          46,    *[[0, 0, 1], [1, 1, 1], [0, 0, 1]]
3 3 12 12        596,   *[[1, 0, 1], [1, 1, 1], [1, 1, 1]]
2 3 6 3          18,    *[[0, 1], [1, 1], [0, 1]]
3 2 5 5          34,    *[[0, 1, 0], [1, 1, 1]]
4 4 9 9          1067,  *[[1, 0, 1, 1], [1, 1, 0, 1], [0, 0, 0, 1], [1, 0, 1, 1]]

* not needed, just here to help you debugging
Good luck..

Disclaimer
Thank you @totallyhuman for your Fibonacci Sequence post, from which I borrowed the presentation style. I found it very clear and I hope you don't mind me using the same layout ;)

This challenge differs from basic Game of Life implementation since
it asks to test out every starting pattern possible, count the number of
generated cells for each of those and check for infinite repeating
pattern.

The pattern is centered in the grid, that's what I meant. I'll make the title more precise

Oh, no problem. I'm glad to see you thought my question was laid out well. :D

I got 594 changes for 3, 3, 12, 12 with the same grid. Could you double check?

Pyth, 65 63 bytes
M}3-BGHeSm+F.n<VVM.:.ugVVuCmsM.:++0k03G2NNd)2muCm.[Hk0GQd^^U2EE

Test suite
Input is taken as:
n,m
x
y

On the input 3,3,12,12, I got 594, not 596, with the same grid as the OP, so I'm not sure what's up.
How it works:
^^U2EE: Generate all possible patterns
muCm.[Hk0GQd: Pad them to the appropriate size. Written as pad, rotate, repeat.
uCmsM.:++0k03G2N: Generate the number of live neighbors for each cells. Written as pad, take subsequences of size 3, sum them, rotate, repeat.
M}3-BGH ... gVV ... N: Pair that with the original grid, use both to calculate the new cells. We do this by checking whether live neighbors including the center, optionally minus whether it was alive, contains a 3. I really like this VV trick, so I wrote a helper function (M}3-BGH) so I could do it twice. (see below)
.u ... d): Do that until it stops changing, return all intermediate steps.
.: ... 2: Take all consecutive pairs.
<VVM: Map each pair to the number of new cells born. I'm particularly proud of <VVM, I thought that was very clever.
m+F.n: Map each grid to its total number of cells born.
eS: Max

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/