text:
Calculate the Mean mean of two numbers
disclaimer: the Mean mean is made up by me
Define the arithmetic mean of \$n\$ numbers as
$$M_1(x_1,...,x_n)=\frac{x_1+x_2+...+x_n}{n}$$
Define the geometric mean of \$n\$ numbers as
$$M_0(x_1,...,x_n)=\root{n}\of{x_1x_2...x_n}$$
Define the harmonic mean of \$n\$ numbers as
$$M_{-1}(x_1,...,x_n)=\frac{n}{\frac{1}{x_2} + \frac{1}{x_2} + ... + \frac{1}{x_n}}$$
Define the quadratic mean of \$n\$ numbers as
$$M_2(x_1,...,x_n)=\root\of{\frac{x_1^2+x_2^2+...+x_n^2}{n}}$$
The Mean mean (\$M_M\$) is defined as follows:
Define four sequences (\$a_k, b_k, c_k, d_k\$) as $$a_0=M_1(x_1,...,x_n),\\b_0=M_0(x_1,...,x_n),\\c_0=M_{-1}(x_1,...,x_n),\\d_0=M_2(x_1,...,x_n),\\
a_{k+1}=M_1(a_k,b_k,c_k,d_k),\\b_{k+1}=M_0(a_k,b_k,c_k,d_k),\\c_{k+1}=M_{-1}(a_k,b_k,c_k,d_k),\\d_{k+1}=M_2(a_k,b_k,c_k,d_k)$$
All four sequences converge to the same number, \$M_M(x_1,x_2,...,x_n)\$.
Example
The Mean mean of 1 and 2 is calculated as follows: start with $$a_0 = (1+2)/2 = 1.5, b_0 = \root\of{1 * 2} = \root\of2 \approx 1.4142,\\ c_0 = \frac2{\frac1{1}+\frac1{2}} = \frac4{3} \approx 1.3333, d_0 = \root\of{\frac{1^2+2^2}2} = \root\of{\frac5{2}} \approx 1.5811.$$
Then
$$a_1 = \frac{1.5+1.4142+1.3333+1.5811}4 \approx 1.4571,\\ b_1 = \root^4\of{1.5*1.4142*1.3333*1.5811} \approx 1.4542,\\ c_1 = \frac4{\frac1{1.5}+\frac1{1.4142}+\frac1{1.3333}+\frac1{1.5811}} \approx 1.4512,\\ d_1 = \root\of{\frac{1.5^2+1.4142^2+1.3333^2+1.5811^2}4} \approx 1.4601.$$
The further calculation of the sequences should be clear. It can be seen that they converge to the same number, approximately \$1.45568889\$.
Challenge
Given two positive real numbers, \$a\$ and \$b\$ (\$a<b\$), calculate their Mean mean \$M_M(a,b)\$.
Test cases
1 1 => 1
1 2 => 1.45568889
100 200 => 145.568889
2.71 3.14 => 2.92103713
0.57 1.78 => 1.0848205
1.61 2.41 => 1.98965438
0.01 100 => 6.7483058

Notes

Your program is valid if the difference between its output and the correct output is not greater than 1/100000 of the absolute value of the difference between input numbers.
The output should be a single number.

This is code-golf, so the shortest code wins!

Sandbox link

Somewhat related: Calculate the Arithmetic–Geometric Mean

How precise are we supposed to be?

Closely related

Can we assume the first input is always smaller than the second, as in all your test cases? (If not I'll rollback my Java answer.)

Wolfram Language (Mathematica), 52 bytes
#//.x_:>N@{M@x,E^M@Log@x,1/M[1/x],M[x^2]^.5}&
M=Mean

Try it online!
In my first approach I used these builtins
Mean GeometricMean HarmonicMean and RootMeanSquare
Here are some substitutions for saving bytes
HarmonicMean -->  1/Mean[1/x]  by @Robin Ryder (3 bytes saved)
GeometricMean --> E^Mean@Log@x by @A. Rex (2 bytes saved)
RootMeanSquare --> Mean[x^2]^.5 by @A. Rex (4 bytes saved)
finally we can assign Mean to M (as proposed by @ovs) and save 5 more bytes

Save 2 bytes by recoding GeometricMean

@RobinRyder I believe you mean Harmonic.. nice!

Save 8 more bytes: #//.x_:>N@{Mean@x,E^Mean@Log@x,1/Mean[1/x],Mean[x^2]^.5}&

@ovs  edited.....

R, 70 69 67 bytes
x=scan();`?`=mean;while(x-?x)x=c((?x^2)^.5,?x,2^?log2(x),1/?1/x);?x

Try it online!
-1 byte with better conditioning.-2 bytes by switching to base 2.
Like some other answers, this uses the expression of the geometric mean as an arithmetic mean on the log scale (here in base 2):
$$M_0(x_1,\ldots, x_n) = 2^{M_1(\log_2 x_1,\ldots,\log_2 x_n)}.$$
It also uses the fact that \$\forall k, d_k\geq a_k \geq b_k\geq c_k\$, i.e. \$d_k=\max(a_k, b_k, c_k, d_k)\$. The condition \$a_k=b_k=c_k=d_k\$ is therefore equivalent to \$d_k = M_1(a_k, b_k, c_k, d_k)\$, which is what I use in the while loop; this is achieved by abusing the syntax of while which only considers the first element when the condition is a vector, hence the order in which the means are stored. (Note that we could also use \$c_k\$ instead since it is the minimum of the four, but we could not use \$a_k\$ or \$b_k\$ in the condition.)
When we exit the while loop, x is a constant vector. The final ?x computes its mean to reduce it to a scalar.

Shouldn't it be $ln x_n$ instead of $log x_n$ ?

@Tau Yes, I was denoting natural logarithm by $ log$, which is the default in R. Anyway, I have now changed it to base 2 logarithm for -2 bytes.

J, 34 bytes
(31 as an expression without the assignment to variable f)
f=:1{(^.z,%z,*:z,[z=:(+/%#)&.:)^:_

Try it online!
For functions a and b, a &.: b ("a under b" (related challenge)) is equivalent to (b inv) a b -- apply b, then a, then inverse of b. In this case, geometric/harmonic/quadratic mean is the arithmetic mean "under" logarithm, inversion, and square respectively.

TI-BASIC, 42 35 34 bytes
-1 byte thanks to @SolomonUcko
While max(ΔList(Ans:{mean(Ans),√(mean(Ans²)),mean(Ans^-1)^-1,e^(mean(ln(Ans:End:Ans(1

Input is a list of two integers in Ans.
Output is stored in Ans and is automatically printed out when the program completes.
Formulas used for geometric, harmonic, and quadratic means are based off of user202729's explanation.
Example:
{1,2
           {1 2}
prgmCDGFB
     1.455688891
{100,200
       {100 200}
prgmCDGFB
     145.5688891

Explanation:
(Newlines have been added for clarification.  They do NOT appear in the code.)
While max(ΔList(Ans           ;loop until all elements of the current list are equal
                              ; the maximum of the change in each element will be 0
{                             ;create a list containing...
 mean(Ans),                   ; the arithmetic mean
 √(mean(Ans²)),               ; the quadratic mean
 mean(Ans^-1)^-1,             ; the harmonic mean
 e^(mean(ln(Ans               ; and the geometric mean
End
Ans(1                         ;keep the first element in "Ans" and implicitly print it

Notes:
TI-BASIC is a tokenized language.  Character count does not equal byte count.
e^( is this one-byte token.
^-1 is used for this one-byte token.
I opted for writing ^-1 instead because the token looks like ֿ¹ when in a code block.
√( is this one-byte token.
ΔList( is this two-byte token.

I think you can save a parenthesis by putting the geometric mean last.

@SolomonUcko ah, thanks for noticing!  Didn't consider that before.

max(DeltaList(Ans -> variance(Ans.

Java 10, 234 229 214 211 215 206 203 196 180 177 bytes
a->{for(;a[1]-a[0]>4e-9;){double l=a.length,A[]={0,0,0,1};for(var d:a){A[2]+=d/l;A[3]*=Math.pow(d,1/l);A[0]+=1/d;A[1]+=d*d;}A[0]=l/A[0];A[1]=Math.sqrt(A[1]/l);a=A;}return a[0];}

-5 bytes thanks to @PeterCordes.
-15 more bytes thanks to @PeterCordes, inspired by @RobinRyder's R answer.
+4 bytes because I assumed the inputs are pre-ordered.
-27 bytes thanks to @OlivierGrégoire.
Try it online.
Explanation:
a->{                        // Method with double-array parameter and double return-type
  for(;a[1]-a[0]            //  Loop as long as the difference between the 2nd and 1st items
                >4e-9;){    //  is larger than 0.000000004:
    double l=a.length,      //   Set `l` to the amount of values in the array `a`
           A[]={0,0,0,1};   //   Create an array `A`, filled with the values [0,0,0,1]
    for(var d:a){           //   Inner loop over the values of `a`:
      A[2]+=d/l;            //    Calculate the sum divided by the length in the third spot
      A[3]*=Math.pow(d,1/l);//    The product of the power of 1/length in the fourth spot
      A[0]+=1/d;            //    The sum of 1/value in the first spot
      A[1]+=d*d;            //    And the sum of squares in the second spot
    }                       //   After the inner loop:
                            //   (the third spot of the array now holds the Arithmetic Mean)
                            //   (the fourth spot of the array now holds the Geometric Mean)
    A[0]=l/A[0];            //   Divide the length by the first spot
                            //   (this first spot of the array now holds the Harmonic Mean)
    A[1]=Math.sqrt(A[1]/l); //   Take the square of the second spot divided by the length
                            //   (this second spot of the array now holds the Quadratic Mean)
    a=A;                    //   And then replace input `a` with array `A`
  }                         //  After the outer loop when all values are approximately equal:
  return a[0];}             //  Return the value in the first spot as result

In C you could f+=Math.abs(d-D)<1e-9; and get implicit conversion from a boolean compare result to a 0 / 1 integer and then double.  Does Java have any compact syntax for that?  Or is it possible to do f+=Math.abs(d-D) and then check that the sum of absolute differences is small enough?

Yup, for your test cases, f>1e-8 works as a loop condition: 229 bytes.  a->{for(double f=1,D,A[],l;f>1e-8;a=A){D=a[0];A=new double[]{f=0,1,0,0};for(var d:a){f+=Math.abs(d-D);A[0]+=d;A[1]*=d;A[2]+=1/d;A[3]+=d*d;}A[0]/=l=a.length;A[1]=Math.pow(A[1],1/l);A[2]=l/A[2];A[3]=Math.sqrt(A[3]/l);}return a[0];}.  With 1e-9, it runs slower (about twice the CPU time), having to do more iterations to get essentially 4 * d-D down that small.  With 1e-7, it's about the same speed as 1e-8.  With 1e-6, some of the trailing digits differ for one case.

another idea: mean(a,b) = mean(a,b, a,b), so before the loop repeat the input elements into the array and then hard-code the length as 4.

@PeterCordes Thanks! As for your first question, there is not implicit conversion between boolean and integers in Java, unlike C or Python. Thanks for the -5 bytes by using f+=Math.abs(d-D); (and I've changed it to 4e-9). As for your last comment, I'm afraid creating a new array of a,b,a,b would be more bytes, since it would be something like t[]={a[0],a[1],a[0],a[1]},, so just a.length would be shorter. Sizes of arrays are fixed in Java, which is why we have an java.util.ArrayList instead. But nice idea regardless. I actually use a hard-coded length in my 05AB1E answer as well. :)

Ah, I thought Java might have something like zip() to interleave 2 arrays, but now that I think about it, that would be a standard library function if it existed and thus have a long name.  I was also thinking that if you took 2 scalar inputs, a,b,a,b is compact, if this style of function declaration allows that.  Anyway, useful trick for some languages, e.g. x86 machine code with SIMD vectors, which I've been working on while looking over existing answers for ideas.  Exactly 4 elements :)

@RobinRyder's answer points out that the quadratic mean is always the largest, and harmonic always the smallest, so perhaps you can ditch f entirely and only check a[3]-a[2]<4e-9.

@PeterCordes Thanks, -15 bytes again. :) I did have to fill the means at different spots in the array however, so I could check the a[1]-a[0] before the first iteration when the array-length is still 2.

I think that introduces a bug, unfortunately.  The question doesn't guarantee the inputs are sorted (even though all the examples are), so a[1]-a[0] could be large and negative. :/  I don't see a simple fix for that in your code.  A do{}while() loop structure would make this easy.

@PeterCordes Ah, good point. I've asked OP to ask if we can assume they are sorted, since all the test cases are. I've also been able to save 3 more bytes by hard-coding the length as you mentioned earlier, but slightly different. I initially set it as 2, and change it to 4 after the first iteration.

Yeah, I saw that, nice one.  l==2&&a[1]-a[0]>4e-9 could be a workaround to always run the first iteration, still cheaper than making it a do{}while() I think.

@PeterCordes l==2|| you mean (golfed to l<3|). But yes, good point; I've added it. :)

double[]A={0,0,0,1}; saves 8 bytes.

@OlivierGrégoire Wow, I'm an idiot.. I had double A[],l=2; and A={0,0,0,1}; and changed it to var l=2d; and var A=new double[4];A[3]=1; to save bytes.. Why didn't I just use double[]A={0,0,0,1}; instead. >.< ffs

180 bytes by aggregating aggregable reducers.

@OlivierGrégoire Smart, thanks!

And finally 3 more bytes saved. I'm stopping here.

Finished the x86 SIMD machine code version of this I mentioned working on. :)  float is just barely precise enough to pass the test cases according to the criteria in the question, but it's not good and get stuck in an infinite loop, especially with a hard-coded fixed threshold instead of a threshold relative to b-a.

Charcoal, 40 bytes
Ｗ‹⌊θ⌈θ≔⟦∕ΣθＬθＸΠθ∕¹Ｌθ∕ＬθΣ∕¹θ₂∕ΣＸθ²Ｌθ⟧θＩ⊟θ

Try it online! Link is to verbose version of code. Takes input as an array of numbers. Explanation:
Ｗ‹⌊θ⌈θ

Repeat while the array contains different values...
≔⟦....⟧θ

... replace the array with a list of values:
∕ΣθＬθ

... the mean...
ＸΠθ∕¹Ｌθ

... the geometric mean...
∕ＬθΣ∕¹θ

... the harmonic mean...
₂∕ΣＸθ²Ｌθ

... and the root mean square.
Ｉ⊟θ

Cast an element of the array to string and implicitly print it.

Jelly, 25 24 bytes
Wẋ4¹ÆlÆeƭ²½ƭİ4ƭÆm$€⁺µÐLḢ

Try it online!
Explanation
                    µÐL | Repeat until unchanged:
W                       |   Wrap as a list
 ẋ4                     |   Copy list 4 times
                   ⁺    |   Do twice:
                 $€     |     For each copy of the list:
             4ƭ         |     One of these functions, cycling between them:
   ¹                    |       Identity
    ÆlÆeƭ               |       Alternate between log and exp
         ²½ƭ            |       Alternate between square and square root
            İ           |       Reciprocal
               Æm       |    Then take the mean
                       Ḣ| Finally take the first item

I am fairly bad at Jelly, but could something similar to P*İL work for the geometric mean?

@someone it would need to be P*Lİ$ so wouldn’t save bytes. It would mean I could bring Æm back down a line without costing bytes, but I quite like the fact each one currently has an arithmetic mean at its core.

Jelly, 24 bytes
;µ*Ɱ-;Ø½¤©Æm*İɼ;P½½ƊµÐLḢ

Try it online!

PowerShell, 182 180 183 bytes
$f={$a=$c=$d=$n=0
$b=1
$m=[math]
$args|%{$n++
$a+=$_
$b*=$_
$c+=1/$_
$d+=+$_*$_}
$p=($a/$n),$m::pow($b,1/$n),($n/$c),$m::sqrt($d/$n)|%{$m::round($_,9)}
if($p-ne$p[0]){$p=&$f @p}$p[0]}

Try it online!

171 bytes

@mazzy, impressively :)

05AB1E, 26 24 23 bytes
Δ©ÅA®.²ÅAo®zÅAz®nÅAt)}н

Try it online or see the steps of all test cases.
-1 byte thanks to @Grimy.
23 byter alternative for Geometric mean:
Δ©P®gzm®ÅA®zÅAz®nÅAt)}н

Try it online or see the steps of all test cases.
Explanation:
Δ         # Loop until the list no longer changes:
 ©        #  Store the current list in variable `®` (without popping)
          #  (which is the implicit input-list in the first iteration)
          #  Arithmetic mean:
  ÅA      #   Builtin to calculate the arithmetic mean of the list
          #  Geometric mean:
  ®.²     #   Take the base-2 logarithm of each value in the list `®`
     ÅA   #   Get the arithmetic mean of that list
       o  #   And take 2 to the power of this mean
          #  Harmonic mean:
  ®z      #   Get 1/x for each value x in the list `®`
    ÅA    #   Get the arithmetic mean of that list
      z   #   And calculate 1/y for this mean y
          #  Quadratic mean:
  ®n      #   Take the square of each number x in the list from the register
    ÅA    #   Calculate the arithmetic mean of this list
      t   #   And take the square-root of that mean
  )       #  Wrap all four results into a list
}н        # After the list no longer changes: pop and push its first value
          # (which is output implicitly as result)

23: Δ©P®gzm®ÅA®zÅAz®nÅAt)}н

@Grimy Thanks! Can't believe I hadn't thought about using the length instead of Y for 2/4. :)

Another 23 that betters shows the similarity of geometric mean to the other ones: Δ©ÅA®.²ÅAo®zÅAz®nÅAt)}н. Unfortunately, it doesn't look like we can refactor all those ÅAs.

@Grimy Oh, I like this second version. :) EDIT: Oops.. thanks for noticing my mistake in the explanation.. >.>

I don't program in 05ab1e very well, but can you compute sums and then divide them all by the length later?

@someone That's indeed possible, but since we still have to do something different for each after we took the arithmetic mean, it's unfortunately not shorter. Here is a possible 25 byter for that approach. The Δ, ©z®Dn®.²) and н are similar as above; O®g/ does what you suggested: sum and divide by amount of items; ε„z€„Nè.V] maps each mean: it uses the map index into the dictionary string "z to", and evals it as 05AB1E code.

x86 machine code (SIMD 4x float using 128-bit SSE1&AVX) 94 bytes
x86 machine code (SIMD 4x double using 256-bit AVX) 123 bytes
float passes the test cases in the question, but with a loop-exit threshold small enough to make that happen, it's easy for it to get stuck in an infinite loop with random inputs.
SSE1 packed-single-precision instructions are 3 bytes long, but SSE2 and simple AVX instructions are 4 bytes long.  (Scalar-single instructions like sqrtss are also 4 bytes long, which is why I use sqrtps even though I only care about the low element.  It's not even slower than sqrtss on modern hardware).  I used AVX for non-destructive destination to save 2 bytes vs. movaps+op.
 In the double version we can still do a couple movlhps to copy 64-bit chunks (because often we only care about the low element of a horizontal sum).  Horizontal sum of a 256-bit SIMD vector also requires an extra vextractf128 to get the high half, vs. the slow but small 2x haddps strategy for float.  The double version also needs 2x 8-byte constants, instead of 2x 4-byte.  Overall it comes out at close to 4/3 the size of the float version.
mean(a,b) = mean(a,a,b,b) for all 4 of these means, so we can simply duplicate the input up to 4 elements and never have to implement length=2.  Thus we can hardcode geometric mean as 4th-root = sqrt(sqrt), for example.  And we only need one FP constant, 4.0.
We have a single SIMD vector of all 4 [a_i, b_i, c_i, d_i].  From that, we calculate the 4 means as scalars in separate registers, and shuffle them back together for the next iteration.  (Horizontal operations on SIMD vectors are inconvenient, but we need to do the same thing for all 4 elements in enough cases that it balances out.  I started on an x87 version of this, but it was getting very long and not fun.)
The loop-exit condition of }while(quadratic - harmonic > 4e-5) (or a smaller constant for double) is based on @RobinRyder's R answer, and Kevin Cruijssen's Java answer: quadratic mean is always the largest magnitude, and harmonic mean is always the smallest (ignoring rounding errors).  So we can check the delta between those two to detect convergence.  We return the arithmetic mean as the scalar result.  It's usually between those two and is probably the least susceptible to rounding errors.
Float version: callable as float meanmean_float_avx(__m128); with the arg and return value in xmm0.  (So x86-64 System V, or Windows x64 vectorcall, but not x64 fastcall.)  Or declare the return-type as __m128 so you can get at the quadratic and harmonic mean for testing.
Letting this take 2 separate float args in xmm0 and xmm1 would cost 1 extra byte: we'd need a shufps with an imm8 (instead of just unpcklps xmm0,xmm0) to shuffle together and duplicate 2 inputs.
    40  address                    align 32
    41          code bytes         global meanmean_float_avx
    42                             meanmean_float_avx:
    43 00000000 B9[52000000]           mov      ecx, .arith_mean      ; allows 2-byte call reg, and a base for loading constants
    44 00000005 C4E2791861FC           vbroadcastss  xmm4, [rcx-4]    ; float 4.0
    45
    46                                 ;; mean(a,b) = mean(a,b,a,b) for all 4 types of mean
    47                                 ;; so we only ever have to do the length=4 case
    48 0000000B 0F14C0                 unpcklps xmm0,xmm0          ; [b,a] => [b,b,a,a]
    49
    50                                 ; do{ ... } while(quadratic - harmonic > threshold);
    51                             .loop:
    52                             ;;; XMM3 = geometric mean: not based on addition.  (Transform to log would be hard.  AVX512ER has exp with 23-bit accuracy, but not log.  vgetexp = floor(lofg2(x)), so that's no good.)
    53                                 ;; sqrt once *first*, making magnitudes closer to 1.0 to reduce rounding error.  Numbers are all positive so this is safe.
    54                                 ;; both sqrts first was better behaved, I think.
    55 0000000E 0F51D8                 sqrtps   xmm3, xmm0                 ; xmm3 = 4th root(x)
    56 00000011 F30F16EB               movshdup xmm5, xmm3                 ; bring odd elements down to even
    57 00000015 0F59EB                 mulps    xmm5, xmm3
    58 00000018 0F12DD                 movhlps  xmm3, xmm5                 ; high half -> low
    59 0000001B 0F59DD                 mulps    xmm3, xmm5                 ; xmm3[0] = hproduct(sqrt(xmm))
    60                             ;    sqrtps   xmm3, xmm3                 ; sqrt(hprod(sqrt)) = 4th root(hprod)
    61                                 ; common final step done after interleaving with quadratic mean
    62
    63                             ;;; XMM2 = quadratic mean = max of the means
    64 0000001E C5F859E8               vmulps   xmm5, xmm0,xmm0
    65 00000022 FFD1                   call     rcx                ; arith mean of squares
    66 00000024 0F14EB                 unpcklps xmm5, xmm3         ; [quad^2, geo^2, ?, ?]
    67 00000027 0F51D5                 sqrtps   xmm2, xmm5         ; [quad,   geo,   ?, ?]
    68
    69                             ;;; XMM1 = harmonic mean = min of the means
    70 0000002A C5D85EE8               vdivps   xmm5, xmm4, xmm0    ; 4/x
    71 0000002E FFD1                   call     rcx                ; arithmetic mean (under inversion)
    72 00000030 C5D85ECD               vdivps   xmm1, xmm4, xmm5    ; 4/.  (the factor of 4 cancels out)
    73
    74                             ;;; XMM5 = arithmetic mean
    75 00000034 0F28E8                 movaps   xmm5, xmm0
    76 00000037 FFD1                   call     rcx
    77
    78 00000039 0F14E9                 unpcklps  xmm5, xmm1           ;     [arith, harm, ?,?]
    79 0000003C C5D014C2               vunpcklps xmm0, xmm5,xmm2      ; x = [arith, harm, quad, geo]
    80
    81 00000040 0F5CD1                 subps    xmm2, xmm1        ; largest - smallest mean: guaranteed non-negative
    82 00000043 0F2E51F8               ucomiss  xmm2, [rcx-8]     ; quad-harm > convergence_threshold
    83 00000047 73C5                   jae     .loop
    84
    85                                 ; return with the arithmetic mean in the low element of xmm0 = scalar return value
    86 00000049 C3                     ret
    87
    88                             ;;; "constant pool" between the main function and the helper, like ARM literal pools
    89 0000004A ACC52738           .fpconst_threshold:   dd 4e-5    ; 4.3e-5 is the highest we can go and still pass the main test cases
    90 0000004E 00008040           .fpconst_4:    dd 4.0
    91                             .arith_mean:               ; returns XMM5 = hsum(xmm5)/4.
    92 00000052 C5D37CED               vhaddps   xmm5, xmm5         ; slow but small
    93 00000056 C5D37CED               vhaddps   xmm5, xmm5
    94 0000005A 0F5EEC                 divps     xmm5, xmm4        ; divide before/after summing doesn't matter mathematically or numerically; divisor is a power of 2
    95 0000005D C3                     ret

    96 0000005E 5E000000           .size:      dd $ - meanmean_float_avx
       0x5e = 94 bytes

(NASM listing created with nasm -felf64 mean-mean.asm -l/dev/stdout | cut -b -34,$((34+6))-.  Strip the listing part and recover the source with cut -b 34- > mean-mean.asm)
SIMD horizontal sum and divide by 4 (i.e. arithmetic mean) is implemented in a separate function that we call (with a function pointer to amortize the cost of the address).  With 4/x before/after, or x^2 before and sqrt after, we get the harmonic mean and quadratic mean.  (It was painful to write these div instructions instead of multiplying by an exactly-representable 0.25.)
Geometric mean is implemented separately with multiply and chained sqrt.  Or with one sqrt first to reduce exponent magnitude and maybe help numerical precision. log is not available, only floor(log2(x)) via AVX512 vgetexpps/pd.  Exp is sort of available via AVX512ER (Xeon Phi only), but with only 2^-23 precision.
Mixing 128-bit AVX instructions and legacy SSE is not a performance problem.  Mixing 256-bit AVX with legacy SSE can be on Haswell, but on Skylake it just potentially creates a potential false dependency for SSE instructions.  I think my double version avoids any unnecessary loop-carried dep chains, and bottlenecks
on div/sqrt latency/throughput.
Double version:
   108                             global meanmean_double_avx
   109                             meanmean_double_avx:
   110 00000080 B9[E8000000]           mov      ecx, .arith_mean
   111 00000085 C4E27D1961F8           vbroadcastsd  ymm4, [rcx-8]    ; float 4.0
   112
   113                                 ;; mean(a,b) = mean(a,b,a,b) for all 4 types of mean
   114                                 ;; so we only ever have to do the length=4 case
   115 0000008B C4E37D18C001           vinsertf128   ymm0, ymm0, xmm0, 1       ; [b,a] => [b,a,b,a]
   116
   117                             .loop:
   118                             ;;; XMM3 = geometric mean: not based on addition.
   119 00000091 C5FD51D8               vsqrtpd      ymm3, ymm0     ; sqrt first to get magnitude closer to 1.0 for better(?) numerical precision
   120 00000095 C4E37D19DD01           vextractf128 xmm5, ymm3, 1           ; extract high lane
   121 0000009B C5D159EB               vmulpd       xmm5, xmm3
   122 0000009F 0F12DD                 movhlps      xmm3, xmm5              ; extract high half
   123 000000A2 F20F59DD               mulsd        xmm3, xmm5              ; xmm3 = hproduct(sqrt(xmm0))
   124                                ; sqrtsd       xmm3, xmm3             ; xmm3 = 4th root = geomean(xmm0)   ;deferred until quadratic
   125
   126                             ;;; XMM2 = quadratic mean = max of the means
   127 000000A6 C5FD59E8               vmulpd   ymm5, ymm0,ymm0
   128 000000AA FFD1                   call     rcx                ; arith mean of squares
   129 000000AC 0F16EB                 movlhps  xmm5, xmm3         ; [quad^2, geo^2]
   130 000000AF 660F51D5               sqrtpd   xmm2, xmm5         ; [quad  , geo]
   131
   132                             ;;; XMM1 = harmonic mean = min of the means
   133 000000B3 C5DD5EE8               vdivpd   ymm5, ymm4, ymm0    ; 4/x
   134 000000B7 FFD1                   call     rcx                 ; arithmetic mean under inversion
   135 000000B9 C5DB5ECD               vdivsd   xmm1, xmm4, xmm5    ; 4/.  (the factor of 4 cancels out)
   136
   137                             ;;; XMM5 = arithmetic mean
   138 000000BD C5FC28E8               vmovaps  ymm5, ymm0
   139 000000C1 FFD1                   call     rcx
   140
   141 000000C3 0F16E9                 movlhps     xmm5, xmm1            ;     [arith, harm]
   142 000000C6 C4E35518C201           vinsertf128 ymm0, ymm5, xmm2, 1   ; x = [arith, harm, quad, geo]
   143
   144 000000CC C5EB5CD1               vsubsd   xmm2, xmm1               ; largest - smallest mean: guaranteed non-negative
   145 000000D0 660F2E51F0             ucomisd  xmm2, [rcx-16]           ; quad - harm > threshold
   146 000000D5 77BA                   ja      .loop
   147
   148                                 ; vzeroupper ; not needed for correctness, only performance
   149                                 ; return with the arithmetic mean in the low element of xmm0 = scalar return value
   150 000000D7 C3                     ret
   151
   152                             ; "literal pool" between the function
   153 000000D8 95D626E80B2E113E   .fpconst_threshold:   dq 1e-9
   154 000000E0 0000000000001040   .fpconst_4:    dq 4.0            ; TODO: golf these zeros?  vpbroadcastb and convert?
   155                             .arith_mean:                     ; returns YMM5 = hsum(ymm5)/4.
   156 000000E8 C4E37D19EF01           vextractf128 xmm7, ymm5, 1
   157 000000EE C5D158EF               vaddpd       xmm5, xmm7
   158 000000F2 C5D17CED               vhaddpd      xmm5, xmm5      ; slow but small
   159 000000F6 C5D35EEC               vdivsd     xmm5, xmm4        ; only low element matters
   160 000000FA C3                     ret

   161 000000FB 7B000000           .size:      dd $ - meanmean_double_avx

    0x7b = 123 bytes

C test harness
#include <immintrin.h>
#include <stdio.h>
#include <math.h>

static const struct ab_avg {
    double a,b;
    double mean;
} testcases[] = {
    {1, 1, 1},
    {1, 2, 1.45568889},
    {100, 200, 145.568889},
    {2.71, 3.14, 2.92103713},
    {0.57, 1.78, 1.0848205},
    {1.61, 2.41, 1.98965438},
    {0.01, 100, 6.7483058},
};

// see asm comments for order of  arith, harm, quad, geo
__m128 meanmean_float_avx(__m128);       // or float ...
__m256d meanmean_double_avx(__m128d);    // or double ...
int main(void) {
    int len = sizeof(testcases) / sizeof(testcases[0]);
    for(int i=0 ; i<len ; i++) {
        const struct ab_avg *p = &testcases[i];
#if 1
        __m128 arg = _mm_set_ps(0,0, p->b, p->a);
        double res = meanmean_float_avx(arg)[0];
#else
        __m128d arg = _mm_loadu_pd(&p->a);
        double res = meanmean_double_avx(arg)[0];
#endif
        double allowed_diff = (p->b - p->a) / 100000.0;
        double delta = fabs(p->mean - res);
        if (delta > 1e-3 || delta > allowed_diff) {
            printf("%f %f => %.9f but we got %.9f.  delta = %g allowed=%g\n",
                   p->a, p->b, p->mean, res, p->mean - res, allowed_diff);
        }
    }

    while(1) {
        double a = drand48(), b = drand48();  // range= [0..1)
        if (a>b) {
            double tmp=a;
            a=b;
            b=tmp; // sorted
        }
//      a *= 0.00000001;
//      b *= 123156;
        // a += 1<<11;  b += (1<<12)+1;  // float version gets stuck inflooping on 2048.04, 4097.18 at fpthreshold = 4e-5

        // a *= 1<<11 ; b *= 1<<11;   // scaling to large magnitude makes sum of squares loses more precision
        //a += 1<<11; b+= 1<<11;   // adding to large magnitude is hard for everything, catastrophic cancellation
#if 1
        printf("testing float %g, %g\n", a, b);
        __m128 arg = _mm_set_ps(0,0, b, a);
        __m128 res = meanmean_float_avx(arg);
        double quad = res[2], harm = res[1];  // same order as double... for now
#else
        printf("testing double %g, %g\n", a, b);
        __m128d arg = _mm_set_pd(b, a);
        __m256d res = meanmean_double_avx(arg);
        double quad = res[2], harm = res[1];
#endif
        double delta = fabs(quad - harm);
        double allowed_diff = (b - a) / 100000.0; // calculated in double even for the float case.
        // TODO: use the double res as a reference for float res
        // instead of just checking quadratic vs. harmonic mean

        if (delta > 1e-3 || delta > allowed_diff) {
            printf("%g %g we got q=%g, h=%g, a=%g.  delta = %g,  allowed=%g\n",
                   a, b, quad, harm, res[0], quad-harm, allowed_diff);
        }
    }

}

Build with:
nasm -felf64 mean-mean.asm &&
gcc -no-pie -fno-pie -g -O2 -march=native mean-mean.c mean-mean.o

Obviously you need a CPU with AVX support, or an emulator like Intel SDE.  To compile on a host without native AVX support, use -march=sandybridge or -mavx
Run: passes the hard-coded test cases, but for the float version, random test cases often fail the (b-a)/10000 threshold set in the question.
$ ./a.out
 (note: empty output before the first "testing float" means clean pass on the constant test cases)
testing float 3.90799e-14, 0.000985395
3.90799e-14 0.000985395 we got q=3.20062e-10, h=3.58723e-05, a=2.50934e-05.  delta = -3.5872e-05,  allowed=9.85395e-09
testing float 0.041631, 0.176643
testing float 0.0913306, 0.364602
testing float 0.0922976, 0.487217
testing float 0.454433, 0.52675
0.454433 0.52675 we got q=0.48992, h=0.489927, a=0.489925.  delta = -6.79493e-06,  allowed=7.23169e-07
testing float 0.233178, 0.831292
testing float 0.56806, 0.931731
testing float 0.0508319, 0.556094
testing float 0.0189148, 0.767051
0.0189148 0.767051 we got q=0.210471, h=0.210484, a=0.21048.  delta = -1.37389e-05,  allowed=7.48136e-06
testing float 0.25236, 0.298197
0.25236 0.298197 we got q=0.274796, h=0.274803, a=0.274801.  delta = -6.19888e-06,  allowed=4.58374e-07
testing float 0.531557, 0.875981
testing float 0.515431, 0.920261
testing float 0.18842, 0.810429
testing float 0.570614, 0.886314
testing float 0.0767746, 0.815274
testing float 0.118352, 0.984891
0.118352 0.984891 we got q=0.427845, h=0.427872, a=0.427863.  delta = -2.66135e-05,  allowed=8.66539e-06
testing float 0.784484, 0.893906
0.784484 0.893906 we got q=0.838297, h=0.838304, a=0.838302.  delta = -7.09295e-06,  allowed=1.09422e-06

FP errors are enough that quad-harm comes out less than zero for some inputs.
Or with a += 1<<11;  b += (1<<12)+1; uncommented:
testing float 2048, 4097
testing float 2048.04, 4097.18
^C  (stuck in an infinite loop).

None of these problems happen with double.  Comment out the printf before each test to see that the output is empty (nothing from the if(delta too high) block).
TODO: use the double version as a reference for the float version, instead of just looking at how they converging with quad-harm.

Python 3, 152 bytes
from math import*
s=sum
def f(*a):l=len(a);return 2>len({*a})and{*a}or f(s(a)/l,l/s(map(pow,a,l*[-1])),exp(s(map(log,a))/l),(s(map(pow,a,l*[2]))/l)**.5)

Try it online!
Recursive function f, will converge to floating point precision. Works in principle for all lists of positive numbers of any size, but is limited by Python's recursion limit a rounding error for some test cases.

Alternatively, settling for 9 decimals precision:
Python 3, 169 bytes
from math import*
s=sum
def f(*a):l=len(a);return(2>len({round(i,9)for i in a}))*a[0]or f(s(a)/l,l/s(map(pow,a,l*[-1])),exp(s(map(log,a))/l),(s(map(pow,a,l*[2]))/l)**.5)

Try it online!

147 bytes in Python 3.8

C#, 173 bytes
double m(int n,params double[]a)=>(n<1?a[0]:m(n-1,a.Sum()/a.Length,Math.Pow(a.Aggregate((t,x)=>t*x),1.0/a.Length),a.Length/a.Sum(x=>1/x),Math.Sqrt(a.Sum(x=>x*x)/a.Length)));

Try it online!

This seems to really on a variable that must be passed. Also, you have to include using System and using System.Linq in your byte count, since they are required for the program to run. You can change your compiler to the C# Visual Interactive Compiler, which doesn't need those imports. Also, 1.0 -> 1d

C# (Visual C# Interactive Compiler), 177 bytes
double f(double[]g)=>g.All(c=>Math.Abs(c-g[0])<1e-9)?g[0]:f(new[]{g.Sum()/(z=g.Length),Math.Pow(g.Aggregate((a,b)=>a*b),1d/z),z/g.Sum(x=>1/x),Math.Sqrt(g.Sum(x=>x*x)/z)});int z;

Thanks to @KevinCruijjsen for pointing out that using floating point precision was causing problems! Would be 163 bytes if doubles were perfectly precise.
Try it online!

The last two test cases give a StackOverflowException due to floating point precision. Instead of c==g[0] you could do something like Math.Abs(c-g[0])<1e-9. Try it online.

@KevinCruijssen Thanks, it's such a pain dealing with floating point numbers

Japt v2.0a0 -g, 42 38 bytes
â ÊÉ?ß[Ux²÷(V=UÊ)¬Ux÷V U×qV V÷Ux!÷1]:U

There's got to be a shorter way... This is a monstrosity! Saved 4 bytes thanks to @Shaggy!
Try it

38 bytes. But I agree, there must be a shorter way!

Clean, 124 bytes
import StdEnv
f=avg o limit o iterate\l=let n=toReal(length l)in[avg l,prod l^(1.0/n),n/sum[1.0/x\\x<-l],avg[x*x\\x<-l]^0.5]

Try it online!
Performs the operation until the result stops changing.
Hurray for limited precision floating point!

Pyth, 32 bytes
h.Wt{H[.OZ@*FZJlZcJscL1Z@.O^R2Z2

Try it online here, or verify all the test cases (bar two, see note below) at once here. Accepts input as a list.
There seem to be some issues with rounding, as certain inputs don't converge correctly when they otherwise should. In particular, test case 0.01 100 gets stuck at values [6.748305820749738, 6.748305820749738, 6.748305820749739, 6.748305820749738], and test case 1.61 2.41 gets stuck at [1.9896543776640825, 1.9896543776640825, 1.9896543776640827, 1.9896543776640825] - note in both cases that the 3rd mean (harmonic mean) differs from the others.
I'm not sure if this problem invalidates my entry, but I'm posting it anyway as it should work. If this isn't acceptable, it can be fixed by instering .RRT before the [, to round each of the means to 10 decimal places, as seen in this test suite.
h.Wt{H[.OZ@*FZJlZcJscL1Z@.O^R2Z2)Q   Implicit: Q=eval(input())
                                     Trailing )Q inferred
 .W                              Q   Funcitonal while: While condition is true, call inner. Starting value Q
   t{H                               Condition function: current input H
    {H                                 Deduplicate H
   t                                   Discard first value
                                         Empty list is falsey, so while is terminated when means converge
      [.OZ@*FZJlZcJscL1Z@.O^R2Z2)    Inner function: current input Z
              JlZ                      Take length of Z, store in J
       .OZ                             (1) Arithmetic mean of Z
           *FZ                         Product of Z
          @   J                        (2) Jth root of the above
                     L Z               Map each element of Z...
                    c 1                ... to its reciprocal
                   s                   Sum the above
                 cJ                    (3) J / the above
                            R Z        Map each element of Z...
                           ^ 2         ... to its square
                         .O            Arithmetic mean of the above
                        @      2       (4) Square root of the above
      [                         )      Wrap results (1), (2), (3), and (4) in a list
                                         This is used as the input for the next iteration of the loop
h                                    Take the first element of the result, implicit print

Since I'm pretty sure the repeated calculation won't jump around to previous values, you could replace .Wt{H with u for -4 bytes (and change Z to G)

Javascript - 186 bytes
Takes input as an array of numbers. Uses the mean transformations in J42161217's answer to shorten the code.
Try It Online
f=(v,l=[m=(w,k=0)=>w.map(x=>k+=x)&&k/w.length,w=>1/m(w.map(x=>1/x)),w=>Math.E**m(w.map(x=>Math.log(x))),w=>m(w.map(x=>x**2))**.5].map(x=>x(v)).sort((a,b)=>a-b))=>l[3]-l[0]>1e-5?f(l):l[0]

Explanation
f = (
  v,
  l=[
    m=(w,k=0)=>w.map(x=>k+=x)&&k/w.length,  // m = w => arithmetic mean of values in w
    w=>1/m(w.map(x=>1/x)),                  // w => harmonic mean of values in w
    w=>Math.E**m(w.map(x=>Math.log(x))),    // w => geometric mean of values in w
    w=>m(w.map(x=>x**2))**.5                // w => quadratic mean of values in w
  ].map(x=>x(v))                            // get array of each mean using input v, stored in l
  .sort((a,b)=>a-b)                         // sort the outputs
) =>
  l[3] - l[0] > 1e-5 ?                      // is the difference between the largest
                                            // and smallest means > 1/100000?
    f(l) :                                  // if yes, get the mean mean of the means
    l[0]                                    // if no, arbitrarily return the smallest value
                                            // as close enough

I thought I was going to be clever and implement the relationship with logarithms but it looks like you and J42161217 got there first!

@Pureferret I take no credit for that,I blatantly stole it :D

you wrote it in JavaScript though!

That was the easy part. Golfing it was hard.

I'm not getting any output when I try it online Also, it fails entirely in SpiderMonkey

The TIL was not configured correctly. I added a TIL link to the answer.

Oops, there's a bug .sort() sorts lexicographically, not numerically.

173 bytes

Perl 5, 92 72 bytes
sub f{@_=map{$m=$_;sum(map$_**$m/@_,@_)**(1/$m)}1,1e-9,-1,2for 1..9;pop}

Try it online!
...using some dirty tricks.

SNOBOL4 (CSNOBOL4), 296 bytes
	X =INPUT
	Y =INPUT
	A =(X + Y) / 2.
	P =X * Y
	G =P ^ 0.5
	H =P / A
	Q =(2 * (A ^ 2) - P) ^ 0.5
O	OUTPUT =EQ(Q,A) Q	:S(END)
	M =A
	N =G
	O =H
	P =Q
	A =(M + N + O + P) / 4
	G =(M * N * O * P) ^ 0.25
	H =4 / (1 / M + 1 / N + 1 / O + 1 / P)
	Q =((M ^ 2 + N ^ 2 + O ^ 2 + P ^ 2) / 4) ^ 0.5	:(O)
END

Try it online!
Straightforward implementation. Uses a trick from my answer to a related question to golf a bit more.

Sledgehammer, 15 bytes
so I just posted the winning answer to my own question
⡈⠀⣐⢕⠠⢵⠂⡒⡓⠄⠬⢔⣲⣔⢯

Take input as a list of two (or more) machine precision integers.
Mathematica has all the built-ins you could need for this challenge!

FixedPoint for iterating until done
Mean, HarmonicMean, GeometricMean and RootMeanSquare are the built-ins for all four means necessary

Corresponding Mathematica code:
First@FixedPoint[{Mean@#,HarmonicMean@#,GeometricMean@#,RootMeanSquare@#}&,#]&

(golfing in Sledgehammer is noticeably different from golfing in Mathematica; replacing the means with shorter expressions is unlikely to help here, although I haven't actually tried)

Factor, 101 bytes
[ [ { mean geometric-mean harmonic-mean quadratic-mean } [ execute ] with map ] to-fixed-point last ]

Attempt This Online!


text:
Relevant Part for a Badminton Serve
Introduction:
I saw there was only one other badminton related challenge right now. Since I play badminton myself (for the past 13 years now), I figured I'd add some badminton-related challenges. Here the second (first one can be found here):
Challenge:
Some rules about badminton serves:

A serve will always be done diagonally over the net.
You must always serve after the line that's parallel and nearest to the net.
The area in which you are allowed to serve differs depending on whether it's a single (1 vs 1) or double/mix (2 vs 2).

For singles (1 vs 1), the blue area in the picture below is where you are allowed to serve. So this is including the part at the back, but excluding the parts at the side.
For doubles/mix (2 vs 2), the green area in the picture below is where you are allowed to server. So this is excluding the part at the back, but including the parts at the side.

You may not stand on the lines when serving. But the shuttle will still be inside if they land on top of a line.

Here the layout of a badminton field:

Challenge rules:
Input:
You will be given two inputs:

Something to indicate whether we're playing a single or double/mix (i.e. a boolean)
Something to indicate which block you're serving from (i.e. [1,2,3,4] or ['A','B','C','D'] as used in the picture above).

Output:
Only the relevant lines for the current serve (including the net), including an F to indicate where you serve from, and multiple T to indicate where you will potentially serve to.
Although in reality you're allowed to serve from and to anywhere in the designated areas, we assume a person that will serve will always stands in the corner of the serve area closes to the middle of the net, which is where you'll place the F. And they will serve to any of the four corners of the area where they have to serve to, which is where you'll place the Ts.
As ASCII-art, the entire badminton field would be the following (the numbers are added so you don't have to count them yourself):
 2        15              15        2

+--+---------------+---------------+--+
|  |               |               |  |    1
+--+---------------+---------------+--+
|  |               |               |  |
|  |               |               |  |
|  |               |               |  |
|  |               |               |  |
|  |               |               |  |    9
|  |               |               |  |
|  |               |               |  |
|  |               |               |  |
|  |               |               |  |
+--+---------------+---------------+--+
|  |               |               |  |    2
|  |               |               |  |
O=====================================O    37 times '='
|  |               |               |  |
|  |               |               |  |    2
+--+---------------+---------------+--+
|  |               |               |  |
|  |               |               |  |
|  |               |               |  |
|  |               |               |  |
|  |               |               |  |    9
|  |               |               |  |
|  |               |               |  |
|  |               |               |  |
|  |               |               |  |
+--+---------------+---------------+--+
|  |               |               |  |    1
+--+---------------+---------------+--+

Examples:
Here two examples for outputting only the relevant parts of the serve:
Input: Single and serve block A
Output:
                   T---------------T
                   |               |
                   +---------------+
                   |               |
                   |               |
                   |               |
                   |               |
                   |               |
                   |               |
                   |               |
                   |               |
                   |               |
                   T---------------T
                   |               |
                   |               |
O=====================================O
   |               |
   |               |
   +---------------+
   |              F|
   |               |
   |               |
   |               |
   |               |
   |               |
   |               |
   |               |
   |               |
   +---------------+
   |               |
   +---------------+

As you can see, the F is added in the corner within the block, but the T are replacing the + in the ASCI-art output.

Input: Double and serve block C
Output:

+--+---------------+
|  |               |
|  |               |
|  |               |
|  |               |
|  |               |
|  |               |
|  |               |
|  |               |
|  |              F|
+--+---------------+
|  |               |
|  |               |
O=====================================O
                   |               |  |
                   |               |  |
                   T---------------+--T
                   |               |  |
                   |               |  |
                   |               |  |
                   |               |  |
                   |               |  |
                   |               |  |
                   |               |  |
                   |               |  |
                   |               |  |
                   T---------------+--T

Challenge rules:

Leading and trailing newlines are optional (including the leading and trailing two empty lines when the input is single). Trailing spaces are optional as well. Leading spaces are mandatory however.
Any four reasonable distinct inputs to indicate which block we're serving from are allowed (for integers, stay within the [-999,999] range); as well as any two reasonable distinct inputs to indicate whether its a single or double/mix (please note this relevant forbidden loophole, though). Please state the I/O you've used in your answer!
You are allowed to use a lowercase f and t (or mixed case) instead of F and T.
You are allowed to return a list of lines or matrix of characters instead of returning or printing a single output-string.

General rules:

This is code-golf, so shortest answer in bytes wins.
Don't let code-golf languages discourage you from posting answers with non-codegolfing languages. Try to come up with an as short as possible answer for 'any' programming language.
Standard rules apply for your answer with default I/O rules, so you are allowed to use STDIN/STDOUT, functions/method with the proper parameters and return-type, full programs. Your call.
Default Loopholes are forbidden.
If possible, please add a link with a test for your code (i.e. TIO).
Also, adding an explanation for your answer is highly recommended.

Ah, badminton. The one game I’ve always wanted to play but never got around to because forgot/couldn’t find players to play with

@Quintec Feel free to come visit our club in The Netherlands for a free evening ;p

Deal, if you pay for my plane ticket and hotel? :)

@Quintec If you win, I'll pay the flight ticket back, haha xD

I had no idea this was considered a sport in other countries still! Neato. Are there like, professional players too? Can you make millions doing badminton at the highest levels :P?

@MagicOctopusUrn Yes, there are some professional badminton players from The Netherlands. Not sure what rank they have on the world list tbh, I don't watch badminton that often (and usually it's only 5 minutes on the sport news if mentioned at all anyway.. all other time is wasted with soccer). And no, as top player you might barely make an income I think. Definitely not millions.

Charcoal, 81 bytes
ＮθＦ⮌Ｅθ⁺¹⁶×³ιＦ✂541⊖θＵＲι±×³Ｉκ×=¹⁸O⟲Ｏ↙⁴Ｊ¹±³FＦ²Ｆ²«Ｊ×ι±⁺¹²×³θ⁺²×⁻¹⁵×³θκT»Ｆ№ABη‖↑Ｆ№ACη‖

Try it online! Link is to verbose version of code. Takes the first input as 1 or 2 for singles or doubles, second input as one of ABCD as in the question. Explanation:
Ｆ⮌Ｅθ⁺¹⁶×³ιＦ✂541⊖θＵＲι±×³Ｉκ

Loop over the relevant widths and the heights of the D court and draw the rectangles.
×=¹⁸O⟲Ｏ↙⁴

Draw the net and apply rotational symmetry to add the A court.
Ｊ¹±³F

Add the F to the D court.
Ｆ²Ｆ²«Ｊ×ι±⁺¹²×³θ⁺²×⁻¹⁵×³θκT»

Add the Ts to the relevant places in the A court.
Ｆ№ABη‖↑Ｆ№ACη‖

Reflect the output as necessary to serve from the correct court.

@KevinCruijssen Sorry for overlooking that, should be fixed now, thanks.

Python 2, 285 284 bytes
R=str.replace
s,q=input()
A=' '*19
l='| '[s]+'  |'+A[4:]+'|'+A
r=['T--+','   T'][s]+'-'*15+'T'+A
h=[r]+[l,R(r,*'T+')]*s+[l]*8+[l[:18]+'F'+'|'+A,r,l,l,'O'+'='*37+'O']
h+=[R(l[::-1],*'T+')for l in h[-2::-1]]
h[9+2*s]=R(h[9+2*s],*'F ')
for l in[l[::q%2*2-1]for l in h[::q/2*2-1]]:print l

Try it online!
Takes input as 0/1 (or False/True) for game type (Double/Single),
and 0-3 for serving block (0,1,2,3 = C,D,A,B)

That was fast! Nice answer.

@Yeah, I kinda tried it from sandbox last week :P

JavaScript (ES7),  216 ... 205 201  199 bytes
Takes input as (block)(double), where block is either \$-2\$ (top right), \$-1\$ (bottom left), \$1\$ (bottom right) or \$2\$ (top left) and double is a Boolean value.
b=>d=>(g=x=>y<31?`+-| =OTF
`[X=x-19,Y=y-15,p=X*Y*b<0,q=Y>0^b&1,X*=X,Y*=Y,i=x*24%35>2|~16>>Y%62%6&2,x<39?Y?p*X|(d?Y:X-87)>169?3:i?X-1|Y-16|q?i:7:q*(d?X-87:Y)%169&&6:x%38?4:5:++y&&8]+g(-~x%40):'')(y=0)

Try it online!
Formatted version
How?
We iterate from \$y=0\$ to \$y=30\$ and from from \$x=0\$ to \$x=39\$ for each value of \$y\$.
We first define \$X=x-19\$ and \$Y=y-15\$.
The variables p = X * Y * b < 0 and q = Y > 0 ^ b & 1 are used to determine what do draw in each quarter according to the block \$b\$.
From now on, both \$X\$ and \$Y\$ are squared in order to easily test absolute positions within each quarter of the field.
The expression x * 24 % 35 > 2 yields false if \$x\$ belongs to \$\{0, 3, 19, 35, 38\}\$ (the positions of the vertical lines) or true otherwise.
Try it online!
The expression ~16 >> Y % 62 % 6 & 2 yields \$0\$ if \$y\$ belongs to \$\{0, 2, 12, 18, 28, 30\}\$ (the positions of the horizontal lines, excluding the net) or \$2\$ otherwise.
Try it online!
The variable \$i\$ is defined as the result of a bitwise OR between the two values above, and is therefore interpreted as:

3: space
2: |
1: -
0: + or T

The expression (d ? Y : X - 87) > 169 is used to crop the field according to the game type \$d\$ (single or double). The similar expression (d ? X - 87 : Y) % 169 is used to draw the T's at the appropriate positions.

Opens TIO and starts verifying the output Looks good; all eight outputs are correct, as expected. Looks at actual code Huh.. wth is going on¿.. :S Looking forward to that explanation later on, @Arnauld. An unexpected amount of arithmetic, ternary, and bitwise calculations for an ASCII-art challenge. xD

@KevinCruijssen Actually, I wish my formulas were even more freaky so that I could get this under 200 bytes, which was my initial target. ;) But my approach is probably too much optimized towards drawing the full field and not enough towards taking the parameters into account at a reasonable byte cost.

Probably yeah, since I allowed any input-value in the range [-999,999] for the four distinct inputs, so perhaps you could somehow use that to your advantage to golf some bytes. It would mean to partially start over, which is perhaps not be worth the effort. Unfortunately I can't give you any golfing tips to help you under 200 bytes; I can only wish you good luck in your attempts. ;p

@KevinCruijssen Done. :)

Jelly, 108 99 bytes
“¢¥Þ‘Ṭ+þ³ḤN+“¢¤€‘¤ṬḤ;Ø0¤×3R¤¦€³+0x39¤µ‘03³?‘;20¤¦€1,-2¦;565DWx“¢%¢‘¤;UṚ$ị“|-+TO= ””F21¦€³Ḥ_⁵¤¦UṚƭ⁴¡

Try it online!
I’m sure this can be better golfed.
Dyadic link with left argument 0 or 1 for singles/doubles and right argument 0,1,2,3 for different serve quadrants. Returns a list of strings
Thanks to @KevinCruijssen for saving a byte!

I don't know Jelly, so I probably say something stupid here, but with “|-+TO= ”“F”, can't the “F” be golfed to another type of string for single characters? In 05AB1E for example, there are builtins for strings of size 1 ('), 2 („), or 3 (…), so it could be 'F. Don't know if Jelly has something similar, or if you have another reason for it to be “|-+TO= ”“F”?

@KevinCruijssen Thanks, and nice challenge. I don’t think so. There are two character literals (with ⁾), but not one. I could use a number 7 and add the F to the lookup, but it’s the same number of characters because of the need to follow the 7 with a 21 which therefore needs a space to separate the two.

Well, as I said, I don't know Jelly. Thought it might have some builtins for 1 or 2-character strings as well, but if you say not I believe you. :)

@KevinCruijssen I’m happy for someone else to jump in - still learning!

@KevinCruijssen I completely missed that ” could be used for a single character literal - oops! Thanks for saving a byte.

Glad you found it. :)

source: Stack Exchange

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

sort: votes


text:
Words hidden in my phone number
Telephones in the United States (and perhaps some other places) have letters associated with some of the numbers.
2 = A, B, C
3 = D, E, F
4 = G, H, I
5 = J, K, L
6 = M, N, O
7 = P, Q, R, S
8 = T, U, V
9 = W, X, Y, Z

No letters are associated with the number 0 or 1.
Your challenge: Given any phone number in seven-digit or ten-digit format, return English words or phrases into which it could be translated using the code above. Spaces do not matter.
So, for example
873-5377 can be translated to “useless” or “trek-err” and possibly a few others depending on your words list.
For the purposes of this contest,

All digits in the phone number must be used and must be translated into letters. This means that phone numbers containing 0s or 1s can not be translated.
If your operating system or programming environment has a built-in words list (/usr/share/dict/words or the equivalent), go ahead and use it. Otherwise, you can assume that a word list has been downloaded to a convenient directory. However, (a) no-preprocessing of the dictionary to limit it to seven and ten letter words or anything like that, and (b) you have to open the dictionary and load the words yourself; you can’t just pass a variable that contains a list of words.
If your dictionary includes proper nouns, it’s OK to have them in your output.
You can not assume that your input is an integer. The number 213-867-5309 might be input as (213) 867-5409 or 2138675309. Strip all non-numerical characters and make sure what’s left is a seven or ten-digit integer.
Your answer can be a function or a complete program, but no snippets.

FOR EXTRA CREDIT

You may implement a version of the code that replaces rule 1 with a more forgiving test — you may leave up to 2 numbers as numbers while changing all the other numbers to words. If you choose this path, the code must complete a comprehensive search and not do something trivial like leaving the first two numbers as numbers while doing word substitution on the rest. Obviously in this variation, phone numbers with up to two 0s and 1s may be translated.

Using the same test number as above, rule 6 gives us the answers "us-elf-77", "us-ekes-7", and others in addition to the answers above.
TEST NUMBERS
Show us what you get for 868-454-6523 and 323-454-6503.
SCORING
Shortest code wins, but if you’ve implemented rule 6 you can cut your length in half. I also plan to call out interesting solutions or solutions from verbose languages that might have won if their command names were shorter.

Related.

this reminds me of something...oh, yes! I have answered this question here https://mathematica.stackexchange.com/a/186933/46583

So we can assume there is a builtin dictionary at a folder that we specify?

@EmbodimentofIgnorance yes.

Just to be clear point (4) means we must accept any string of characters, remove all non-digit ones and not form any result if the remaining digit list is not length 7?

(...I think it may be the case that none of the three answers so far do this!)

I think the scoring section needs to be deleted on this one... not only does it give a bonus, the criterion is not objective therefore this should not be scored by length.

@MagicOctopusUrn In my opinion, "rule 6" should just be removed, since it constitutes a bonus and detracts from the main point of the challenge.

What do you mean by "you have to open the dictionary and load the words yourself; you can’t just pass a variable that contains a list of words."? Is a function argument that contains the words enough or do we need to read from an I/O stream?

"Strip all non-numerical characters and make sure what’s left is a seven or ten-digit integer." - so leading zeros do not count?

"you can’t just pass a variable that contains a list of words." what about languages without file reading support?

@MagicOctopusUrn What is not objective about rule 6?

@MichaelStern Simply because anyone reading from the linux dictionary may have a shorter byte-count than someone trying to encode words or something. Nobody is writing code that can be objectively compared for this challenge because we may be using different word sources. Therefore the inputs and outputs for each piece of code are not the same, which is basically saying it's not explicitly objective. 6 exacerbates this.

@MagicOctopusUrn Different implementations may produce different output, but the scoring rules are entirely objective.

@MichaelStern scoring based on byte-count on a challenge without explicit inputs and outputs is not objective. I could write a program that always returns empty set. You've not written anything forbidding that, I could just claim I'm using a small dictionary. Meaning, it always parses everything fine by definition, but no words are getting found.

@JonathanAllan Good question! Leading zeroes do not exist in U.S. phone numbers so I had not considered them. To preserve the (tenuous) real world theme of this problem, assume you will never be given a number with leading zeroes.

I like the idea of this, but it feels like there's too many different things going into it here, and having test cases without given outputs doesn't help. It'd be one thing if this was take a phone number in the most convenient format and check a list of phrases from input to see if they fit, but this is clean up and validate a phone number, load a dictionary from the file system, check the number against every possible phrase from it, and output everything that fits, with a -50% bonus for allowing 1 or 2 numbers to be left out of the phrase. Again, I like the idea, but it needs trimming.

(Input validation has been ruled against on meta, and the requirement for file I/O adds very little to the challenge while excluding most esolangs--and when you combine that problem with the lack of a standard wordlist, the need to use a dictionary file actually detracts from the challenge even for languages which can do it, because two programs run on two different systems could come up with two totally different things for no good reason.)

05AB1E, 207 bytes
þ"! ! ABC DEF GHI JKL MNO PQRS TUV WXYZ"S#sSèU
"€‚ƒ„…†‡ˆ‰Š‹ŒŽ•–—™š›œžŸ¡¢£¤¥¦§¨©ª«¬®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîï"©vyV®vYy«"“ÿ“".Vu}})
ʒg¹þgQ}
ʒ´vXNèyåˆ}¯P}
¹þg7Q¹þgTQ&i´¯}

Try it online!
(1) The first line of the code, will replace each number in the input with the corresponding set of possible letters.
þ                                              # Only digits of input.
 "! ! ABC DEF GHI JKL MNO PQRS TUV WXYZ"       # Push keypad letters.
                                        S#     # Split into list and on spaces.
                                          sS   # Split input into digits.
                                            èU # Push indexes of digits and store in X.

(2) The second line of the code, will push every possible dictionary word that is stored in 05AB1E. It accomplishes this by pushing all pairings of the dictionary encrypted characters and converting them to their dictionary stored equivalents. There are 100 unique dictionary characters, and 100*100 unique pairs of them. This means we are getting access to a total of 10,000 words from the 05AB1E dictionary.
(3) The third line of the code, will filter the dictionary by the length of the number of digits in the input.
(4) The fourth line of the code, will filter again the words from the dictionary which match the filter of possible letters outlined by line #1.
(5) The final line of the code, will simply return an empty array provided that the input was not 7 or 10 digits long after parsing.

Using no external libraries/files, this code can detect any word that is in the 05AB1E dictionary. More specifically, if the input is limited to 7 characters the following list:
["ABILITY", "ABRAHAM", "ABSENCE", "ACADEMY", "ACCEPTS", "ACCOUNT", "ACCUSED", "ACHIEVE", "ACQUIRE", "ACROBAT", "ACRYLIC", "ACTIONS", "ACTRESS", "ADAPTED", "ADAPTER", "ADAPTOR", "ADDRESS", "ADOPTED", "ADVANCE", "ADVERSE", "ADVISED", "ADVISOR", "AFFAIRS", "AFFECTS", "AFRICAN", "AGAINST", "AIRFARE", "AIRLINE", "AIRPORT", "ALABAMA", "ALBANIA", "ALBERTA", "ALCOHOL", "ALGEBRA", "ALGERIA", "ALLEGED", "ALLERGY", "ALLOWED", "ALREADY", "ALTERED", "AMATEUR", "AMAZING", "AMBIENT", "AMENDED", "AMERICA", "AMONGST", "AMOUNTS", "AMPLAND", "ANAHEIM", "ANALYST", "ANALYZE", "ANATOMY", "ANCIENT", "ANDORRA", "ANDREAS", "ANDREWS", "ANGELES", "ANIMALS", "ANOTHER", "ANSWERS", "ANTENNA", "ANTHONY", "ANTIGUA", "ANTIQUE", "ANTONIO", "ANXIETY", "ANYBODY", "ANYMORE", "ANYTIME", "APPAREL", "APPEALS", "APPEARS", "APPLIED", "APPLIES", "APPROVE", "AQUATIC", "ARCHIVE", "ARISING", "ARIZONA", "ARMENIA", "ARRANGE", "ARRIVAL", "ARRIVED", "ARRIVES", "ARTICLE", "ARTISTS", "ARTWORK", "ASPECTS", "ASSAULT", "ASSISTS", "ASSUMED", "ASSUMES", "ASSURED", "ATLANTA", "ATTACKS", "ATTEMPT", "ATTRACT", "AUCTION", "AUDITOR", "AUSTRIA", "AUTHORS", "AVERAGE", "AWARDED", "AWESOME", "BACKING", "BAGHDAD", "BAHAMAS", "BAHRAIN", "BALANCE", "BALLOON", "BANGBUS", "BANGKOK", "BANKING", "BANNERS", "BAPTIST", "BARBARA", "BARGAIN", "BARRIER", "BASKETS", "BATTERY", "BEACHES", "BEARING", "BEATLES", "BECAUSE", "BECOMES", "BEDDING", "BEDFORD", "BEDROOM", "BEIJING", "BELARUS", "BELFAST", "BELGIUM", "BELIEFS", "BELIEVE", "BELONGS", "BENEATH", "BENEFIT", "BENNETT", "BERMUDA", "BERNARD", "BESIDES", "BETTING", "BETWEEN", "BEVERLY", "BICYCLE", "BIDDING", "BIGGEST", "BILLING", "BILLION", "BINDING", "BIOLOGY", "BIZARRE", "BIZRATE", "BLANKET", "BLESSED", "BLOCKED", "BLOGGER", "BLOWING", "BLOWJOB", "BOATING", "BOLIVIA", "BONDAGE", "BOOKING", "BOOLEAN", "BORDERS", "BOROUGH", "BOTTLES", "BOULDER", "BOUQUET", "BOWLING", "BRACKET", "BRADLEY", "BRANDON", "BREASTS", "BRIDGES", "BRIEFLY", "BRISTOL", "BRITAIN", "BRITISH", "BRITNEY", "BROADER", "BROKERS", "BROTHER", "BROUGHT", "BROWSER", "BUDGETS", "BUFFALO", "BUILDER", "BUKKAKE", "BURNING", "BUTTONS", "CABINET", "CALCIUM", "CALGARY", "CALLING", "CAMERAS", "CAMERON", "CAMPING", "CANDLES", "CAPABLE", "CAPITAL", "CAPITOL", "CAPTAIN", "CAPTURE", "CARDIAC", "CARDIFF", "CAREERS", "CAREFUL", "CARRIED", "CARRIER", "CARRIES", "CARROLL", "CARTOON", "CASINOS", "CASTING", "CATALOG", "CAUSING", "CAUTION", "CEILING", "CENTERS", "CENTRAL", "CENTRES", "CENTURY", "CERAMIC", "CERTAIN", "CHAMBER", "CHANCES", "CHANGED", "CHANGES", "CHANNEL", "CHAPTER", "CHARGED", "CHARGER", "CHARGES", "CHARITY", "CHARLES", "CHARLIE", "CHARTER", "CHASSIS", "CHEAPER", "CHECKED", "CHELSEA", "CHESTER", "CHICAGO", "CHICKEN", "CHINESE", "CHOICES", "CHRONIC", "CIRCLES", "CIRCUIT", "CITIZEN", "CLAIMED", "CLARITY", "CLASSES", "CLASSIC", "CLEANER", "CLEANUP", "CLEARED", "CLEARLY", "CLIENTS", "CLIMATE", "CLINICS", "CLINTON", "CLOSELY", "CLOSEST", "CLOSING", "CLOSURE", "CLOTHES", "CLUSTER", "COACHES", "COASTAL", "COATING", "COLEMAN", "COLLECT", "COLLEGE", "COLLINS", "COLOGNE", "COLORED", "COLOURS", "COLUMNS", "COMBINE", "COMFORT", "COMMAND", "COMMENT", "COMMONS", "COMPACT", "COMPANY", "COMPARE", "COMPETE", "COMPILE", "COMPLEX", "COMPUTE", "CONCEPT", "CONCERN", "CONCERT", "CONCORD", "CONDUCT", "CONFIRM", "CONNECT", "CONSENT", "CONSIST", "CONSOLE", "CONSULT", "CONTACT", "CONTAIN", "CONTENT", "CONTEST", "CONTEXT", "CONTROL", "CONVERT", "COOKIES", "COOKING", "COOLING", "COPYING", "CORNELL", "CORNERS", "CORRECT", "COSTUME", "COTTAGE", "COUNCIL", "COUNSEL", "COUNTED", "COUNTER", "COUNTRY", "COUPLED", "COUPLES", "COUPONS", "COURAGE", "COURIER", "COURSES", "COVERED", "CREATED", "CREATES", "CREATOR", "CREDITS", "CRICKET", "CRITICS", "CROATIA", "CRUCIAL", "CRUISES", "CRYSTAL", "CUISINE", "CULTURE", "CUMSHOT", "CURIOUS", "CURRENT", "CUSTODY", "CUSTOMS", "CUTTING", "CYCLING", "DAMAGED", "DAMAGES", "DANCING", "DEALERS", "DEALING", "DEBORAH", "DECADES", "DECIDED", "DECIMAL", "DECLARE", "DECLINE", "DEFAULT", "DEFECTS", "DEFENCE", "DEFENSE", "DEFICIT", "DEFINED", "DEFINES", "DEGREES", "DELAYED", "DELETED", "DELIGHT", "DELIVER", "DEMANDS", "DENMARK", "DENSITY", "DEPENDS", "DEPOSIT", "DERIVED", "DESERVE", "DESIGNS", "DESIRED", "DESKTOP", "DESPITE", "DESTINY", "DESTROY", "DETAILS", "DETROIT", "DEUTSCH", "DEVELOP", "DEVIANT", "DEVICES", "DEVOTED", "DIAGRAM", "DIAMOND", "DIETARY", "DIGITAL", "DIPLOMA", "DISABLE", "DISCUSS", "DISEASE", "DISPLAY", "DISPUTE", "DISTANT", "DIVERSE", "DIVIDED", "DIVORCE", "DOCTORS", "DOLLARS", "DOMAINS", "DONATED", "DOUGLAS", "DRAWING", "DRESSED", "DRESSES", "DRIVERS", "DRIVING", "DROPPED", "DURABLE", "DYNAMIC", "EARLIER", "EARNING", "EASTERN", "ECLIPSE", "ECOLOGY", "ECONOMY", "ECUADOR", "EDITING", "EDITION", "EDITORS", "EDWARDS", "EFFECTS", "EFFORTS", "ELDERLY", "ELECTED", "ELECTRO", "ELEGANT", "ELEMENT", "ELLIOTT", "EMBASSY", "EMERALD", "EMPEROR", "ENABLED", "ENABLES", "ENDLESS", "ENEMIES", "ENGAGED", "ENGINES", "ENGLAND", "ENGLISH", "ENHANCE", "ENJOYED", "ENLARGE", "ENQUIRY", "ENSURES", "ENTERED", "ENTRIES", "EPISODE", "EQUALLY", "EROTICA", "ESCORTS", "ESSENCE", "ESTATES", "ESTONIA", "ETERNAL", "ETHICAL", "EVENING", "EVIDENT", "EXACTLY", "EXAMINE", "EXAMPLE", "EXCERPT", "EXCITED", "EXCLUDE", "EXECUTE", "EXHAUST", "EXHIBIT", "EXISTED", "EXPECTS", "EXPEDIA", "EXPENSE", "EXPERTS", "EXPIRED", "EXPIRES", "EXPLAIN", "EXPLORE", "EXPORTS", "EXPOSED", "EXPRESS", "EXTENDS", "EXTRACT", "EXTREME", "FABRICS", "FACTORS", "FACTORY", "FACULTY", "FAILING", "FAILURE", "FALLING", "FANTASY", "FARMERS", "FARMING", "FASHION", "FASTEST", "FATHERS", "FEATURE", "FEDERAL", "FEEDING", "FEELING", "FEMALES", "FERRARI", "FICTION", "FIFTEEN", "FIGHTER", "FIGURED", "FIGURES", "FILLING", "FILTERS", "FINALLY", "FINANCE", "FINDING", "FINDLAW", "FINGERS", "FINLAND", "FINNISH", "FIREFOX", "FISHING", "FISTING", "FITNESS", "FITTING", "FLIGHTS", "FLORIDA", "FLORIST", "FLOWERS", "FOCUSED", "FOCUSES", "FOLDERS", "FOLDING", "FOLLOWS", "FOOTAGE", "FOREIGN", "FORESTS", "FOREVER", "FORMATS", "FORMING", "FORMULA", "FORTUNE", "FORWARD", "FOUNDED", "FOUNDER", "FRAMING", "FRANCIS", "FREEBSD", "FREEDOM", "FREIGHT", "FRIENDS", "FUCKING", "FUJITSU", "FUNDING", "FUNERAL", "FURTHER", "FUTURES", "GABRIEL", "GADGETS", "GALLERY", "GARBAGE", "GARDENS", "GATEWAY", "GAZETTE", "GENERAL", "GENERIC", "GENESIS", "GENETIC", "GENUINE", "GEOLOGY", "GEORGIA", "GERMANY", "GETTING", "GILBERT", "GLASGOW", "GLASSES", "GLUCOSE", "GOURMET", "GRAMMAR", "GRANTED", "GRAPHIC", "GRATUIT", "GRAVITY", "GREATER", "GREATLY", "GREGORY", "GRENADA", "GRIFFIN", "GROCERY", "GROUNDS", "GROWING", "GUITARS", "HABITAT", "HALIFAX", "HAMBURG", "HAMPTON", "HANDJOB", "HANDLED", "HANDLES", "HANGING", "HAPPENS", "HARBOUR", "HARMFUL", "HARMONY", "HARVARD", "HARVEST", "HAZARDS", "HEADERS", "HEADING", "HEADSET", "HEALING", "HEALTHY", "HEARING", "HEATHER", "HEATING", "HEAVILY", "HEIGHTS", "HELPFUL", "HELPING", "HERSELF", "HEWLETT", "HIGHEST", "HIGHWAY", "HIMSELF", "HISTORY", "HITACHI", "HITTING", "HOBBIES", "HOLDERS", "HOLDING", "HOLIDAY", "HOLLAND", "HOPKINS", "HORIZON", "HORMONE", "HOSTELS", "HOSTING", "HOTMAIL", "HOTTEST", "HOUSING", "HOUSTON", "HOWEVER", "HUNDRED", "HUNGARY", "HUNTING", "HUSBAND", "HYGIENE", "HYUNDAI", "ICELAND", "IGNORED", "ILLEGAL", "ILLNESS", "IMAGINE", "IMAGING", "IMPACTS", "IMPLIED", "IMPLIES", "IMPORTS", "IMPOSED", "IMPROVE", "INCLUDE", "INDEXED", "INDEXES", "INDIANA", "INDIANS", "INDICES", "INDUCED", "INFANTS", "INITIAL", "INJURED", "INQUIRE", "INQUIRY", "INSECTS", "INSIDER", "INSIGHT", "INSTALL", "INSTANT", "INSTEAD", "INSULIN", "INSURED", "INTEGER", "INTENSE", "INTERIM", "INVALID", "INVITED", "INVOICE", "INVOLVE", "IRELAND", "ISLAMIC", "ISLANDS", "ISRAELI", "ITALIAN", "JACKETS", "JACKSON", "JAMAICA", "JANUARY", "JEFFREY", "JELSOFT", "JESSICA", "JEWELRY", "JOHNSON", "JOINING", "JOURNAL", "JOURNEY", "JUMPING", "JUSTICE", "JUSTIFY", "KARAOKE", "KATRINA", "KEEPING", "KENNEDY", "KENNETH", "KEYWORD", "KILLING", "KINGDOM", "KISSING", "KITCHEN", "KNIGHTS", "KNOWING", "LABELED", "LANDING", "LAPTOPS", "LARGELY", "LARGEST", "LASTING", "LATINAS", "LAUNDRY", "LAWSUIT", "LAWYERS", "LEADERS", "LEADING", "LEARNED", "LEASING", "LEATHER", "LEAVING", "LEBANON", "LECTURE", "LEGALLY", "LEGENDS", "LEISURE", "LENDERS", "LENDING", "LEONARD", "LESBIAN", "LESSONS", "LETTERS", "LETTING", "LEVITRA", "LEXMARK", "LIBERAL", "LIBERIA", "LIBERTY", "LIBRARY", "LICENCE", "LICENSE", "LICKING", "LIGHTER", "LIMITED", "LINCOLN", "LINDSAY", "LINKING", "LISTING", "LIVECAM", "LIVESEX", "LOADING", "LOCALLY", "LOCATED", "LOCATOR", "LOCKING", "LODGING", "LOGGING", "LOGICAL", "LONGEST", "LOOKING", "LOTTERY", "LUGGAGE", "MACHINE", "MADISON", "MADNESS", "MADONNA", "MAGICAL", "MAILING", "MAILMAN", "MANAGED", "MANAGER", "MANDATE", "MANUALS", "MAPPING", "MARILYN", "MARKERS", "MARKETS", "MARKING", "MARRIED", "MARTIAL", "MASSAGE", "MASSIVE", "MASTERS", "MATCHED", "MATCHES", "MATTERS", "MATTHEW", "MAXIMUM", "MEANING", "MEASURE", "MEDICAL", "MEDLINE", "MEETING", "MELISSA", "MEMBERS", "MEMPHIS", "MENTION", "MERCURY", "MESSAGE", "METHODS", "MEXICAN", "MICHAEL", "MIDWEST", "MILEAGE", "MILLION", "MINERAL", "MINIMAL", "MINIMUM", "MINOLTA", "MINUTES", "MIRACLE", "MIRRORS", "MISSILE", "MISSING", "MISSION", "MISTAKE", "MIXTURE", "MOBILES", "MODULAR", "MODULES", "MOLDOVA", "MOMENTS", "MONITOR", "MONSTER", "MONTANA", "MONTHLY", "MORNING", "MOROCCO", "MOTHERS", "MOUNTED", "MOZILLA", "MUSCLES", "MUSEUMS", "MUSICAL", "MUSLIMS", "MUSTANG", "MYANMAR", "MYSIMON", "MYSPACE", "MYSTERY", "NAMIBIA", "NATIONS", "NATURAL", "NAUGHTY", "NEAREST", "NEITHER", "NERVOUS", "NETWORK", "NEUTRAL", "NEWPORT", "NIAGARA", "NIGERIA", "NIPPLES", "NIRVANA", "NORFOLK", "NOTHING", "NOTICED", "NOTICES", "NOVELTY", "NOWHERE", "NUCLEAR", "NUMBERS", "NUMERIC", "NURSERY", "NURSING", "OAKLAND", "OBESITY", "OBJECTS", "OBSERVE", "OBVIOUS", "OCTOBER", "OFFENSE", "OFFERED", "OFFICER", "OFFICES", "OFFLINE", "OLYMPIC", "OLYMPUS", "ONGOING", "ONTARIO", "OPENING", "OPERATE", "OPINION", "OPPOSED", "OPTICAL", "OPTIMAL", "OPTIMUM", "OPTIONS", "ORDERED", "ORGANIC", "ORIGINS", "ORLANDO", "ORLEANS", "OUTCOME", "OUTDOOR", "OUTLETS", "OUTLINE", "OUTLOOK", "OUTPUTS", "OUTSIDE", "OVERALL", "PACIFIC", "PACKAGE", "PACKARD", "PACKETS", "PACKING", "PAINFUL", "PAINTED", "PANTIES", "PARENTS", "PARKING", "PARTIAL", "PARTIES", "PARTNER", "PASSAGE", "PASSING", "PASSION", "PASSIVE", "PATCHES", "PATENTS", "PATIENT", "PATRICK", "PATTERN", "PAYABLE", "PAYMENT", "PAYROLL", "PENALTY", "PENDANT", "PENDING", "PENGUIN", "PENSION", "PENTIUM", "PEOPLES", "PERCENT", "PERFECT", "PERFORM", "PERFUME", "PERHAPS", "PERIODS", "PERMITS", "PERSIAN", "PERSONS", "PHANTOM", "PHILIPS", "PHOENIX", "PHRASES", "PHYSICS", "PICKING", "PICTURE", "PIONEER", "PIRATES", "PISSING", "PLACING", "PLANETS", "PLANNED", "PLANNER", "PLASTIC", "PLAYBOY", "PLAYERS", "PLAYING", "PLEASED", "PLUGINS", "POCKETS", "PODCAST", "POINTED", "POINTER", "POKEMON", "POLYMER", "PONTIAC", "POPULAR", "PORSCHE", "PORTION", "POSSESS", "POSTAGE", "POSTERS", "POSTING", "POTTERY", "POULTRY", "POVERTY", "POWERED", "PRAIRIE", "PRAYERS", "PRECISE", "PREDICT", "PREFERS", "PREMIER", "PREMIUM", "PREPAID", "PREPARE", "PRESENT", "PRESSED", "PRESTON", "PREVENT", "PREVIEW", "PRICING", "PRIMARY", "PRINTED", "PRINTER", "PRIVACY", "PRIVATE", "PROBLEM", "PROCEED", "PROCESS", "PRODUCE", "PRODUCT", "PROFILE", "PROFITS", "PROGRAM", "PROJECT", "PROMISE", "PROMOTE", "PROPHET", "PROPOSE", "PROTECT", "PROTEIN", "PROTEST", "PROUDLY", "PROVIDE", "PUBLISH", "PULLING", "PURPOSE", "PURSUIT", "PUSHING", "PUTTING", "PUZZLES", "QUALIFY", "QUALITY", "QUANTUM", "QUARTER", "QUERIES", "QUICKLY", "QUIZZES", "RADICAL", "RAILWAY", "RAINBOW", "RAISING", "RALEIGH", "RANGERS", "RANGING", "RANKING", "RAPIDLY", "RATINGS", "RAYMOND", "REACHED", "REACHES", "READERS", "READILY", "READING", "REALITY", "REALIZE", "REALTOR", "REASONS", "REBATES", "REBECCA", "REBOUND", "RECEIPT", "RECEIVE", "RECIPES", "RECORDS", "RECOVER", "REDHEAD", "REDUCED", "REDUCES", "REFINED", "REFLECT", "REFORMS", "REFRESH", "REFUSED", "REGARDS", "REGIONS", "REGULAR", "RELATED", "RELATES", "RELEASE", "RELYING", "REMAINS", "REMARKS", "REMOVAL", "REMOVED", "RENEWAL", "RENTALS", "REPAIRS", "REPLACE", "REPLICA", "REPLIED", "REPLIES", "REPORTS", "REPRINT", "REQUEST", "REQUIRE", "RESERVE", "RESOLVE", "RESORTS", "RESPECT", "RESPOND", "RESTORE", "RESULTS", "RESUMES", "RETIRED", "RETREAT", "RETURNS", "REUNION", "REUTERS", "REVEALS", "REVENGE", "REVENUE", "REVERSE", "REVIEWS", "REVISED", "REWARDS", "RICHARD", "ROBERTS", "ROLLING", "ROMANCE", "ROMANIA", "ROUGHLY", "ROUTERS", "ROUTINE", "ROUTING", "ROYALTY", "RUNNING", "RUNTIME", "RUSSELL", "RUSSIAN", "SAILING", "SAMPLES", "SAMSUNG", "SATISFY", "SAVINGS", "SCANNED", "SCANNER", "SCHEMES", "SCHOLAR", "SCHOOLS", "SCIENCE", "SCORING", "SCRATCH", "SCREENS", "SCRIPTS", "SEAFOOD", "SEASONS", "SEATING", "SEATTLE", "SECONDS", "SECRETS", "SECTION", "SECTORS", "SECURED", "SEEKERS", "SEEKING", "SEGMENT", "SELLERS", "SELLING", "SEMINAR", "SENATOR", "SENDING", "SENEGAL", "SENIORS", "SENSORS", "SERIOUS", "SERVERS", "SERVICE", "SERVING", "SESSION", "SETTING", "SETTLED", "SEVENTH", "SEVERAL", "SHADOWS", "SHAKIRA", "SHANNON", "SHARING", "SHELTER", "SHEMALE", "SHERIFF", "SHERMAN", "SHIPPED", "SHOPPER", "SHORTER", "SHORTLY", "SHOWERS", "SHOWING", "SHUTTLE", "SIEMENS", "SIGNALS", "SIGNING", "SILENCE", "SILICON", "SIMILAR", "SIMPSON", "SINGING", "SINGLES", "SISTERS", "SITEMAP", "SITTING", "SKATING", "SKILLED", "SMALLER", "SMILIES", "SMOKING", "SOCIETY", "SOLARIS", "SOLDIER", "SOLOMON", "SOLVING", "SOMALIA", "SOMEHOW", "SOMEONE", "SOONEST", "SOURCES", "SPANISH", "SPATIAL", "SPEAKER", "SPECIAL", "SPECIES", "SPECIFY", "SPENCER", "SPIRITS", "SPONSOR", "SPRINGS", "SPYWARE", "STADIUM", "STANLEY", "STARTED", "STARTER", "STARTUP", "STATING", "STATION", "STATUTE", "STAYING", "STEPHEN", "STEVENS", "STEWART", "STICKER", "STOMACH", "STOPPED", "STORAGE", "STORIES", "STRANGE", "STREAMS", "STREETS", "STRETCH", "STRIKES", "STRINGS", "STRIPES", "STUDENT", "STUDIED", "STUDIES", "STUDIOS", "STUFFED", "STYLISH", "SUBJECT", "SUBLIME", "SUCCEED", "SUCCESS", "SUCKING", "SUGGEST", "SUICIDE", "SUMMARY", "SUNRISE", "SUPPORT", "SUPPOSE", "SUPREME", "SURFACE", "SURFING", "SURGEON", "SURGERY", "SURNAME", "SURPLUS", "SURVEYS", "SURVIVE", "SUSPECT", "SWEDISH", "SYMBOLS", "SYSTEMS", "TABLETS", "TACTICS", "TALKING", "TARGETS", "TEACHER", "TEACHES", "TEENAGE", "TELECOM", "TELLING", "TENSION", "TERRACE", "TERRAIN", "TESTING", "TEXTILE", "TEXTURE", "THEATER", "THEATRE", "THEOREM", "THERAPY", "THEREBY", "THEREOF", "THERMAL", "THOMSON", "THOUGHT", "THREADS", "THREATS", "THROUGH", "THUNDER", "TICKETS", "TIFFANY", "TIMOTHY", "TOBACCO", "TODDLER", "TONIGHT", "TOOLBAR", "TOOLBOX", "TOOLKIT", "TOPLESS", "TORONTO", "TORTURE", "TOSHIBA", "TOTALLY", "TOUCHED", "TOURING", "TOURISM", "TOURIST", "TOWARDS", "TRACKED", "TRACKER", "TRACTOR", "TRADING", "TRAFFIC", "TRAGEDY", "TRAILER", "TRAINED", "TRAINER", "TRANSIT", "TRAVELS", "TREATED", "TRIBUNE", "TRIBUTE", "TRIGGER", "TRINITY", "TRIUMPH", "TROUBLE", "TRUSTED", "TRUSTEE", "TSUNAMI", "TUESDAY", "TUITION", "TUNISIA", "TURKISH", "TURNING", "TWISTED", "TYPICAL", "UKRAINE", "UNIFIED", "UNIFORM", "UNKNOWN", "UNUSUAL", "UPDATED", "UPDATES", "UPGRADE", "UPSKIRT", "URUGUAY", "USUALLY", "UTILITY", "UTILIZE", "VACCINE", "VAMPIRE", "VANILLA", "VARIETY", "VARIOUS", "VARYING", "VATICAN", "VEHICLE", "VENDORS", "VENTURE", "VERIZON", "VERMONT", "VERSION", "VESSELS", "VETERAN", "VICTIMS", "VICTORY", "VIETNAM", "VIEWERS", "VIEWING", "VILLAGE", "VINCENT", "VINTAGE", "VIOLENT", "VIRTUAL", "VIRUSES", "VISIBLE", "VISITED", "VISITOR", "VITAMIN", "VOLTAGE", "VOLUMES", "WAITING", "WALKING", "WALLACE", "WANTING", "WARMING", "WARNING", "WARRANT", "WARRIOR", "WASHING", "WATCHED", "WATCHES", "WEAPONS", "WEARING", "WEATHER", "WEBCAMS", "WEBCAST", "WEBLOGS", "WEBPAGE", "WEBSITE", "WEBSTER", "WEDDING", "WEEKEND", "WEIGHTS", "WELCOME", "WELDING", "WELFARE", "WESTERN", "WHEREAS", "WHETHER", "WICHITA", "WILLIAM", "WILLING", "WINDOWS", "WINDSOR", "WINNERS", "WINNING", "WINSTON", "WISHING", "WITHOUT", "WITNESS", "WORKERS", "WORKING", "WORKOUT", "WORRIED", "WORSHIP", "WRAPPED", "WRITERS", "WRITING", "WRITTEN", "WYOMING", "YOUNGER", "ZEALAND"]

For 10 characters, you'd be able to detect:
["ABORIGINAL", "ABSOLUTELY", "ABSORPTION", "ACCEPTABLE", "ACCEPTANCE", "ACCESSIBLE", "ACCOMPLISH", "ACCORDANCE", "ACCOUNTING", "ACCREDITED", "ACCURATELY", "ACDBENTITY", "ACTIVATION", "ACTIVITIES", "ADAPTATION", "ADDITIONAL", "ADDRESSING", "ADJUSTABLE", "ADJUSTMENT", "ADMISSIONS", "ADOLESCENT", "ADVANTAGES", "ADVENTURES", "ADVERTISER", "AFFILIATED", "AFFILIATES", "AFFORDABLE", "AFTERWARDS", "AGGRESSIVE", "AGREEMENTS", "ALEXANDRIA", "ALGORITHMS", "ALLOCATION", "AMBASSADOR", "AMENDMENTS", "ANALYTICAL", "ANNOTATION", "ANTARCTICA", "ANTIBODIES", "APARTMENTS", "APPARENTLY", "APPEARANCE", "APPLIANCES", "APPLICABLE", "APPLICANTS", "APPRECIATE", "APPROACHES", "ARCHITECTS", "ARTIFICIAL", "ASSESSMENT", "ASSIGNMENT", "ASSISTANCE", "ASSOCIATED", "ASSOCIATES", "ASSUMPTION", "ATMOSPHERE", "ATTACHMENT", "ATTEMPTING", "ATTENDANCE", "ATTRACTION", "ATTRACTIVE", "ATTRIBUTES", "AUSTRALIAN", "AUTHORIZED", "AUTOMATION", "AUTOMOBILE", "AUTOMOTIVE", "AZERBAIJAN", "BACKGROUND", "BANGLADESH", "BANKRUPTCY", "BASKETBALL", "BEASTALITY", "BEHAVIORAL", "BENEFICIAL", "BESTIALITY", "BIOLOGICAL", "BIRMINGHAM", "BLACKBERRY", "BOUNDARIES", "BRITANNICA", "BURLINGTON", "BUSINESSES", "CALCULATED", "CALCULATOR", "CALIFORNIA", "CAMCORDERS", "CANDIDATES", "CAPABILITY", "CARTRIDGES", "CATEGORIES", "CHALLENGED", "CHALLENGES", "CHANCELLOR", "CHARACTERS", "CHARITABLE", "CHARLESTON", "CHRISTIANS", "CHRONICLES", "CIGARETTES", "CINCINNATI", "CITYSEARCH", "CLASSIFIED", "COLLEAGUES", "COLLECTING", "COLLECTION", "COLLECTIVE", "COLLECTORS", "COLUMNISTS", "COMMENTARY", "COMMERCIAL", "COMMISSION", "COMMITMENT", "COMMITTEES", "COMPARABLE", "COMPARISON", "COMPATIBLE", "COMPLAINTS", "COMPLEMENT", "COMPLETELY", "COMPLETING", "COMPLETION", "COMPLEXITY", "COMPLIANCE", "COMPONENTS", "COMPRESSED", "COMPROMISE", "CONCEPTUAL", "CONCERNING", "CONCLUSION", "CONDITIONS", "CONDUCTING", "CONFERENCE", "CONFIDENCE", "CONFIGURED", "CONNECTING", "CONNECTION", "CONNECTORS", "CONSIDERED", "CONSISTENT", "CONSISTING", "CONSORTIUM", "CONSPIRACY", "CONSTANTLY", "CONSTITUTE", "CONSTRAINT", "CONSULTANT", "CONSULTING", "CONTACTING", "CONTAINERS", "CONTAINING", "CONTINUING", "CONTINUITY", "CONTINUOUS", "CONTRACTOR", "CONTRIBUTE", "CONTROLLED", "CONTROLLER", "CONVENIENT", "CONVENTION", "CONVERSION", "CONVICTION", "COORDINATE", "COPYRIGHTS", "CORRECTION", "CORRUPTION", "COUNSELING", "CREATIVITY", "CUMULATIVE", "CURRENCIES", "CURRICULUM", "CUSTOMIZED", "DECORATING", "DECORATIVE", "DEFINITELY", "DEFINITION", "DELEGATION", "DELIVERING", "DEMOCRATIC", "DEPARTMENT", "DEPENDENCE", "DEPLOYMENT", "DEPRESSION", "DESCENDING", "DESCRIBING", "DESIGNATED", "DETERMINED", "DETERMINES", "DEVELOPERS", "DEVELOPING", "DIAGNOSTIC", "DICTIONARY", "DIFFERENCE", "DIFFICULTY", "DIMENSIONS", "DIRECTIONS", "DISABILITY", "DISCIPLINE", "DISCLAIMER", "DISCLOSURE", "DISCOUNTED", "DISCOVERED", "DISCRETION", "DISCUSSING", "DISCUSSION", "DISPATCHED", "DISPLAYING", "DISTRIBUTE", "DOCUMENTED", "DOWNLOADED", "EARTHQUAKE", "ECOLOGICAL", "EDITORIALS", "EFFICIENCY", "ELECTRICAL", "ELECTRONIC", "ELEMENTARY", "EMPLOYMENT", "ENCOURAGED", "ENCOURAGES", "ENCRYPTION", "ENDANGERED", "ENGAGEMENT", "ENROLLMENT", "ENTERPRISE", "EQUIVALENT", "ESPECIALLY", "ESSENTIALS", "ESTIMATION", "EVALUATING", "EVALUATION", "EVENTUALLY", "EVERYTHING", "EVERYWHERE", "EXCELLENCE", "EXCEPTIONS", "EXCITEMENT", "EXECUTIVES", "EXHIBITION", "EXPERIENCE", "EXPERIMENT", "EXPIRATION", "EXPLAINING", "EXPLICITLY", "EXPRESSION", "EXTENSIONS", "EXTRACTION", "FACILITATE", "FACILITIES", "FAVOURITES", "FEDERATION", "FELLOWSHIP", "FORMATTING", "FORWARDING", "FOUNDATION", "FRAGRANCES", "FREQUENTLY", "FRIENDSHIP", "FUNCTIONAL", "GENERATING", "GENERATION", "GENERATORS", "GEOGRAPHIC", "GEOLOGICAL", "GIRLFRIEND", "GOVERNANCE", "GOVERNMENT", "GRADUATION", "GREENHOUSE", "GREENSBORO", "GUARANTEED", "GUARANTEES", "GUIDELINES", "HARASSMENT", "HEADPHONES", "HEALTHCARE", "HELICOPTER", "HIGHLIGHTS", "HISTORICAL", "HORIZONTAL", "HOUSEHOLDS", "HOUSEWARES", "HOUSEWIVES", "HUMANITIES", "HUNTINGTON", "HYPOTHESIS", "IDENTIFIED", "IDENTIFIER", "IDENTIFIES", "IMMIGRANTS", "IMMUNOLOGY", "IMPORTANCE", "IMPOSSIBLE", "IMPRESSION", "IMPRESSIVE", "INCENTIVES", "INCOMPLETE", "INCREASING", "INCREDIBLE", "INDICATING", "INDICATION", "INDICATORS", "INDIGENOUS", "INDIVIDUAL", "INDONESIAN", "INDUSTRIAL", "INDUSTRIES", "INFECTIONS", "INFECTIOUS", "INFLUENCED", "INFLUENCES", "INITIATIVE", "INNOVATION", "INNOVATIVE", "INSPECTION", "INSTALLING", "INSTITUTES", "INSTRUCTOR", "INSTRUMENT", "INSULATION", "INTEGRATED", "INTERESTED", "INTERFACES", "INTERNSHIP", "INTERSTATE", "INTERVIEWS", "INTRODUCED", "INTRODUCES", "INVESTMENT", "INVITATION", "IRRIGATION", "JAVASCRIPT", "JOURNALISM", "JOURNALIST", "KAZAKHSTAN", "KILOMETERS", "LABORATORY", "LANDSCAPES", "LAUDERDALE", "LEADERSHIP", "LEGITIMATE", "LIKELIHOOD", "LIMITATION", "LIMOUSINES", "LITERATURE", "LITIGATION", "LOUISVILLE", "LUXEMBOURG", "MACROMEDIA", "MADAGASCAR", "MAINSTREAM", "MAINTAINED", "MANAGEMENT", "MANCHESTER", "MASTERCARD", "MEANINGFUL", "MECHANICAL", "MECHANISMS", "MEDICATION", "MEDITATION", "MEMBERSHIP", "METABOLISM", "MICROPHONE", "MILFHUNTER", "MILLENNIUM", "MINISTRIES", "MITSUBISHI", "MODERATORS", "MONITORING", "MONTGOMERY", "MOTIVATION", "MOTORCYCLE", "MOZAMBIQUE", "MULTIMEDIA", "MYSTERIOUS", "NATIONALLY", "NATIONWIDE", "NAVIGATION", "NETWORKING", "NEWSLETTER", "NEWSPAPERS", "NOMINATION", "NOTTINGHAM", "OBITUARIES", "OBJECTIVES", "OBLIGATION", "OCCASIONAL", "OCCUPATION", "OCCURRENCE", "OFFICIALLY", "OPERATIONS", "OPPOSITION", "ORGANIZING", "ORIGINALLY", "PAPERBACKS", "PARAGRAPHS", "PARAMETERS", "PARLIAMENT", "PARTICULAR", "PASSENGERS", "PERCENTAGE", "PERCEPTION", "PERFORMING", "PERIPHERAL", "PERMISSION", "PERSISTENT", "PERSONALLY", "PETERSBURG", "PHARMACIES", "PHENOMENON", "PHILOSOPHY", "PHOTOGRAPH", "PHYSICALLY", "PHYSICIANS", "PHYSIOLOGY", "PITTSBURGH", "POLYPHONIC", "POPULARITY", "POPULATION", "PORTSMOUTH", "PORTUGUESE", "POSSESSION", "POSTPOSTED", "POWERPOINT", "PREDICTION", "PREFERENCE", "PRESCRIBED", "PRESENTING", "PREVENTING", "PREVENTION", "PREVIOUSLY", "PRINCIPLES", "PRIORITIES", "PRIVILEGES", "PROCEDURES", "PROCEEDING", "PROCESSING", "PROCESSORS", "PRODUCTION", "PRODUCTIVE", "PROFESSION", "PROGRAMMER", "PROGRAMMES", "PROHIBITED", "PROJECTION", "PROJECTORS", "PROMOTIONS", "PROPERTIES", "PROPORTION", "PROTECTING", "PROTECTION", "PROTECTIVE", "PROVIDENCE", "PROVINCIAL", "PROVISIONS", "PSYCHIATRY", "PSYCHOLOGY", "PUBLISHERS", "PUBLISHING", "PUNISHMENT", "PURCHASING", "QUALIFYING", "QUANTITIES", "QUEENSLAND", "QUOTATIONS", "REASONABLE", "REASONABLY", "RECIPIENTS", "RECOGNISED", "RECOGNIZED", "RECOMMENDS", "RECORDINGS", "RECREATION", "RECRUITING", "REDUCTIONS", "REFERENCED", "REFERENCES", "REFLECTION", "REGARDLESS", "REGISTERED", "REGRESSION", "REGULATION", "REGULATORY", "RELATIVELY", "RELAXATION", "RELOCATION", "REMARKABLE", "REMEMBERED", "REPOSITORY", "REPRESENTS", "REPRODUCED", "REPUBLICAN", "REPUTATION", "REQUESTING", "RESEARCHER", "RESISTANCE", "RESOLUTION", "RESPECTIVE", "RESPONDENT", "RESPONDING", "RESTAURANT", "RESTRICTED", "RETIREMENT", "REVELATION", "REVOLUTION", "RICHARDSON", "SACRAMENTO", "SCHEDULING", "SCIENTIFIC", "SCIENTISTS", "SCREENSHOT", "SECURITIES", "SELECTIONS", "SEPARATELY", "SEPARATION", "SETTLEMENT", "SIGNATURES", "SIMPLIFIED", "SIMULATION", "SITUATIONS", "SOUNDTRACK", "SPECIALIST", "STATEMENTS", "STATIONERY", "STATISTICS", "STRATEGIES", "STRENGTHEN", "STRUCTURAL", "STRUCTURED", "STRUCTURES", "SUBJECTIVE", "SUBMISSION", "SUBMITTING", "SUBSCRIBER", "SUBSECTION", "SUBSEQUENT", "SUBSIDIARY", "SUBSTANCES", "SUBSTITUTE", "SUCCESSFUL", "SUFFICIENT", "SUGGESTING", "SUGGESTION", "SUNGLASSES", "SUPERVISOR", "SUPPLEMENT", "SUPPORTERS", "SUPPORTING", "SURPRISING", "SURROUNDED", "SUSPENSION", "SYSTEMATIC", "TECHNICIAN", "TECHNIQUES", "TECHNOLOGY", "TELEVISION", "TERRORISTS", "THEMSELVES", "THEREAFTER", "THOROUGHLY", "THREATENED", "THROUGHOUT", "THUMBNAILS", "THUMBZILLA", "TOURNAMENT", "TRACKBACKS", "TRADEMARKS", "TRADITIONS", "TRANSCRIPT", "TRANSEXUAL", "TRANSITION", "TRANSLATED", "TRANSLATOR", "TRAVELLING", "TREATMENTS", "TREMENDOUS", "ULTIMATELY", "UNDERLYING", "UNDERSTAND", "UNDERSTOOD", "UNDERTAKEN", "UNEXPECTED", "UNIVERSITY", "UZBEKISTAN", "VALIDATION", "VARIATIONS", "VEGETABLES", "VEGETARIAN", "VEGETATION", "VETERINARY", "VIETNAMESE", "VIOLATIONS", "VISIBILITY", "VOCABULARY", "VOCATIONAL", "VOLKSWAGEN", "VOLLEYBALL", "VOLUNTEERS", "VULNERABLE", "WALLPAPERS", "WARRANTIES", "WASHINGTON", "WATERPROOF", "WEBMASTERS", "WELLINGTON", "WIDESCREEN", "WIDESPREAD", "WILDERNESS", "WITHDRAWAL", "YUGOSLAVIA"]

It works for other lengths too, but I thought I'd specifically mention the ones within the spec that it will indeed work for. For example 227 results in:
["ABS", "BAR", "BBS", "CAP", "CAR", "CAS", "CBS"]

If the winner of this challenge is being chosen by shortest code, I can make this 140 bytes shorter if needed.

Cool, that's better :D

@JonathanAllan "Yugoslavia" is a better example word anyway :).

Oh, 227 should not result in any words - again point (4) - "Strip all non-numerical characters and make sure what’s left is a seven or ten-digit integer." - not sure what this means for leading zeros.

@JonathanAllan fixed as well.

Using A…!!ÿ•eŒi•5в£€S as keypad letters and lower-case saves 27 bytes.

@Emigna I'm not golfing this yet... I really don't see a point, it's not code-golf.

Well, it does say shortest code wins... There is some confusion about the whole scoring thing though so waiting might be a good idea. Should ideally be changed into allowing the dictionary to be taken as input.

@Emigna I can definitely cut this to 100 bytes. I honestly just liked the competition idea. Personally I have always thought that pop-con's should be a thing. It would kill the idea that "questions without objective criteria" are bad and would open the site to casual users rather than our die-hard user-base. It's half the reason you don't see me anymore. I love puzzles like this. I feel we've become more code-golf than puzzles.

We are definitely mostly code golf. Probably 95%+. Even this is just code-golf with a bonus. Personally I mostly just care about the challenge being fun, but I can understand the need for an objective winning criteria as this is a site for competitions. I feel like some pop-cons do fit this site even if they can't really have objective winning criterias, but it's much harder to make than golf.

VDM-SL, 313 395 385 289 278 bytes
f(i)==let m={'2'|->"abc",'3'|->"def",'4'|->"ghi",'5'|->"jkl",'6'|->"mno",'7'|->"pqrs",'8'|->"tuv",'9'|->"wxyz"},d=IO`freadval[set of ?],q=[i(p)|p in set inds i&i(p) in set dom m]in let r in set d("f").#2 be st forall x in set inds q&len(q)=len(r)and r(x)in set elems m(q(x))in r

Turns out IO is easier than I thought!
Still expensive because of building the map (I'm sure there'll be a good map comprehension for it I've just not thought of it yet) and could save further bytes if the string was guaranteed to only contain values in the domain of the map
Explanation:
f(i)==
let m=...,                           /* m is a map of char to seq of char */
d=IO`freadval[set of ?]            /* d is the file read function that will read a set of something */
q=[i(p)|p in set inds i&i(p) in set dom m] /* q is a sequence comprehension defined by
                                             take the values in i where i is in the domain
                                             of our map m */
let r in set d("f").#2                    /* let r be a value in my dictionary of words (read from the file f) */
be st                                     /* such that */
forall x in set inds q&len(q)=len(r)      /* the length of q and r are the same */
and r(x)in set elems m(q(x))              /* for every char in q the char in
                                                  r at that position is in the range of the
                                                  map for that char in q */
in r         /* return r*/

This language is new to me; what answers do you get for 323 454-6503 and 868-454-6523?

I'll post an explanation soon. Surely answers are dependent on the dictionary?

Yes, any comprehensive answer depends on the dictionary used but I have no way to test your code except by asking for representative output. There are some answers that are going to appear for any reasonable dictionary, and if the code produces words that couldn’t emerge from these numbers then we know there’s a problem.

@MichaelStern It will take a long time to terminate for those inputs with a none toy dictionary, since it scans every value in the dictionary to test whether it is a valid fit for all characters in the input. It'd be better if you gave test cases as valid/invalid so I can construct a dictionary of the valid and invalid and show it gives correct values for each

Does this deal with (4) from the question (throwing away non digit characters and only returning any results if there are exactly 10 or 7 digits)?

Yes, it sets q to be the sequence constructed of the input sequence where the characters are in the domain of my map, so basically removes any characters which aren't in "23456789"

...so if we imagine that 2345678 yields a word then so will 23456780 but according to (4) it should not yield any words because it's not 7 or 10 in length after stripping non-digits.

Good point I'll fix it when I get a chance

C# (Visual C# Interactive Compiler), 217 bytes
n=>n.Where(c=>c>47&c<58).Select(c=>", , abc def ghi jkl mno pqrs tuv wxyz".Split()[c-48]).Aggregate(new[]{""},(a,b)=>a.SelectMany(c=>b.Select(d=>c+d)).ToArray()).Where(x=>File.ReadAllText("a.txt").Contains($@"
{x}
"))

Expects the dictionary in a file named a.txt.
Try it online!

Why not just store it in a file called "a"?

@ExpiredData Not enough storage xD

No I mean... 213 bytes

Does this deal with (4) from the question (throwing away non digit characters and only returning any results if there are exactly 10 or 7 digits)?

@JonathanAllan See the where statement in the beginning?

Yeah I see that, but it's not meeting the "Strip all non-numerical characters and make sure what’s left is a seven or ten-digit integer." but rather it is simply removing non-[2-9] chars (right?), so if 2345678 gave a result then so would 23456780 (which is an eight-digit integer). BTW I think this whole point (4) is OTT.

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