text:
Golf a number bigger than Loader's number
As a follow up to Shortest terminating program whose output size exceeds Graham's number and Golf a number bigger than TREE(3), I present a new challenge.
Loader's number is a very large number, that is kind of hard to explain (since it was itself the result of a code golfing exercise with a flexible goal). There is a definition and explanation here, but for the purposes of self-containment, I will attempt to explain it later in this post as well.
The algorithm Ralph Loader used produces one of the largest numbers of any (computable) algorithm ever written! Indeed, Loader's number is the largest "computable" number on the Googology Wiki. (By "computable" number, they mean a number defined in terms of a computation.) That means that if answer produces a number larger than Loader's number in an interesting way (i.e. not just Loader's number+1), you could go down in Googology history! That being said, programs that produce something like Loader's number+1 are definitely valid answers and contenders to this question; just don't expect any fame.
Your job is to create a terminating program that produces a number larger than Loader's number. This is code-golf, so the shortest program wins!

You aren't allowed to take input.
Your program must eventually terminate deterministically but you can assume the machine has infinite memory.
You may assume your language's number type can hold any finite value but need to explain how this exactly works in your language (ex: does a float have infinite precision?)

Infinities are not allowed as output.
Underflow of a number type throws an exception. It does not wrap around.

You need to provide an explanation of why your number is so big and an ungolfed version of your code to check if your solution is valid (since there is no computer with enough memory to store Loader's number).

So here is an explanation of Loader's number. See http://googology.wikia.com/wiki/Loader%27s_number and the links therein for more precise details. In particular, it contains a program that produces Loader's number exactly (by definition).
The calculus of constructions is essentially a programming language with very particular properties.
First of all, every syntactically valid program terminates. There are no infinite loops. This will be very useful, because it means that if we run an arbitrary calculus of constructions program, our program will not get stuck. The problem is that this implies the calculus of constructions is not Turing complete.
Second of all, among non-Turing complete languages, it is one of the most powerful. Essentially, if you can prove that a Turing machine will halt on every input, you can program a function in the calculus of constructions that will simulate it. (This does not make it turing complete, because there are halting turing machines that you can not prove are halting.)
Loader's number is essentially a busy beaver number for the calculus of constructions, which is possible to compute since all coc programs terminate.
In particular, loader.c defines a function called D. Approximately, D(x) iterates over all bit-strings less than x, interprets them as a coc programs, runs the syntactically valid ones, and concatenates the results (which will also be bitstrings). It returns this concatenation.
Loader's number is D(D(D(D(D(99))))).
A more readable copy of the code from the googolology wiki
int r, a;

P(y,x){return y- ~y<<x;}

Z(x){return r = x % 2 ? 0 : 1 + Z (x / 2 );}

L(x){return x/2 >> Z(x);}

S(v,y,c,t){
   int f = L(t);
   int x = r;
   return f-2 ? f>2 ? f-v ? t-(f>v)*c : y : P(f,P(S(v,y,c,L(x)), S(v+2,t=S(4,13,-4,y),c,Z(x)))) : A(S(v,y,c,L(x)),S(v,y,c,Z(x)));
}

A(y,x){return L(y)-1 ? 5<<P(y,x) : S(4,x,4,Z(r));}

D(x)
{
   int f;
   int d;
   int c=0;
   int t=7;
   int u=14;
   while(x&&D(x-1),(x/=2)%2&&(1)){
      d = L(L(D(x))),
      f = L(r),
      x = L(r),
      c - r||(L(u)||L(r)-f||(x/=2)%2&&(u=S(4,d,4, r),t=A(t,d)),f/2&(x/=2)%2&&(c=P(d,c),t=S(4,13,-4,t),u=S(4,13,-4,u))),
      c&&(x/=2)%2&&(t=P(~u&2|(x/=2)%2&&(u=1<<P(L(c),u)),P(L(c),t)),c=r)
      u/2&(x/=2)%2&&(c=P(t,c),u=S(4,13,-4,t),t=9);
    }
    return a = P( P( t, P( u, P( x, c)) ),a);
}

main(){return D(D(D(D(D(99)))));}

You know Googology Wiki? I'm MilkyWay90 there!

@MilkyWay90 oh, cool.

I would advise against downvoting this for similarity to the TREE(3) question: Loader's number is so much larger than TREE(3) that new and interesting approaches are required.

@Spitemaster Why do you say that? Since this is [tag:code-golf], you need to beat the other answers to be competitive. So if someone else posts a 512 byte answer, you have to beat 512 bytes to win. It's not just whoever posts an answer first. (Also, for the sake of pendantory, the original program is not valid, since answers need to produce a number larger than Loader's number.)

@Spitemaster Some people also participate in languages simply to try and get the minimum possible for that language

The thing is the only interesting answers would be if someone discovers and proves a larger number than loader's number (which isnt just loader's number +x) or if someone uses a language which it is really hard to implement loader's number in.

@fəˈnɛtɪk Well, printing Loader's number + 1 is still interesting from a code golf perspective (for example, can you beat the original 512 bytes?) There are also some natural generalizations of loader's number that might be easier to implement (for example, using ZFC instead of CoC). Also, Greedy clique sequences or finite promise games could be used.

Unfortunately, as I don't understand the construction of Loader's number and there does not seem to be known upper bounds in terms of the fast growing hierarchy, I cannot give any good answers here. I believe that most answers will be either extensions of Loader's number or things such as the greedy clique sequences and finite promise games...

@SimplyBeautifulArt Oh boy, if you don't understand it, that doesn't bode well for this challenge. :P I could try explaining it in more detail to you in chat, but I also do not know any hierarchy upper bounds.

@SimplyBeautifulArt In particular, since Loader's constant was specifically chosen to try to be the biggest number generated by a certain amount of code (where as Graham's number and TREE(3) at just mathematically interesting numbers that just so happen to be large), I think most answers will just be Loader's number + 1.

I added a somewhat more readable copy of the code from the wiki to make it easier to implement loader's number if nothing else

@fəˈnɛtɪk Also see https://github.com/rcls/busy

Yeah. To make the point even more obviously, Loader's number is the last entry given as a number produced by a computable function in the Googology wikia i.e. there are no non-trivial computable functions that beat it.

@SimplyBeautifulArt There are, just no one has made numbers out of them, check e.g. finite promise games

Both greedy clique sequences and finite promise games look very difficult to write an algorithm for. I think for now this is likely going to be a game of who can make a slightly modified Loader's Number implementation in the least bytes

Lately, p進大好きbot posted a computable function that reached f_PTO(ZFC) in FGH on Googology Wiki. I doubt anyone could write it shorter than loader.c and translationa

I'm assuming that this can't be answered with a trivial unsigned long x[-1U/32],c;f(){while(c<-1UL)while(++x[c])x[c+1]++,x[c+1]*=x[c];c++;}?

It should be possible to give a fairly concise extension of CoC to ZFC strength, using a reflection principle. Add a countable ω+1 sequence of universes Type_0, Type_1, .... Type_ω. Then for any finite set S of formula, add an axiom making S equivalent to its relativisation to Type_n. (E.g., Gödel coding, take S to be all formula with Gödel code < n). (But be careful about replacement and separation in an intuitionistic type theory!)

JavaScript, D6(9) (508 501 495 492 487 485 481 478 456 452 bytes)
_='P6x-~x<<c,Z6r=x&1?0:1+Z@/2.L6x/2>>Z@.S=;t,f=Ft.x=rKf-2?f>2?f-v?t-(f>v)*c:y:Cf,CH(v+2E,#y.Z@BB:A(H;Z@B.A6L@)-1?5<<PM):GE,Z(rND=M=0,O7,Q14K_=@&&D@-1.!1B?(d=FFD@B.f=Fr.x=Fr.c-r||(Fu)||Fr)-f||!QG,d,r.OA(t,dNfIdE.O#t.Q#uB.c&&!OC~u&2|!Q1<<CFc.uNCFc.tNc=r.uItE.Q#t.O9.DM,t,uB:CCt,Cu,PMB._.JJJ9BBB!@>>=1)%2&&(#G-8,13,N)..),6=MK;(vE,y,HS;L@NS@(xB))I/2&!c=CCP(M@EE,cFL(GS(4,4JD(D(K)=>Ot=Qu=';for($ of'QOKJGFEMCIB@H;6.N#!')with(_.split($))_=join(pop());eval(_)

This is an encoded code.
_='P6x-~x<<c,Z6r=x&1?0:1+Z@/2.L6x/2>>Z@.S=;t,f=Ft.x=rKf-2?f>2?f-v?t-(f>v)*c:y:Cf,CH(v+2E,#y.Z@BB:A(H;Z@B.A6L@)-1?5<<PM):GE,Z(rND=M=0,O7,Q14K_=@&&D@-1.!1B?(d=FFD@B.f=Fr.x=Fr.c-r||(Fu)||Fr)-f||!QG,d,r.OA(t,dNfIdE.O#t.Q#uB.c&&!OC~u&2|!Q1<<CFc.uNCFc.tNc=r.uItE.Q#t.O9.DM,t,uB:CCt,Cu,PMB._.JJJ9BBB!@>>=1)%2&&(#G-8,13,N)..),6=MK;(vE,y,HS;L@NS@(xB))I/2&!c=CCP(M@EE,cFL(GS(4,4JD(D(K)=>Ot=Qu='; //encoded code
for($ of'QOKJGFEMCIB@H;6.N#!')with(_.split($))_=join(pop()); //decoding
eval(_) //Evaluation of the string

Decoded code:
P=(x,c)=>x-~x<<c,Z=(x,c)=>r=x&1?0:1+Z(x/2),L=(x,c)=>x/2>>Z(x),S=(v,c,y,t,f=L(t),x=r)=>f-2?f>2?f-v?t-(f>v)*c:y:P(f,P(S(v,c,y,L(x)),S(v+2,c,S(4,4-8,13,y),Z(x)))):A(S(v,c,y,L(x)),S(v,c,y,Z(x))),A=(x,c)=>L(x)-1?5<<P(x,c):S(4,4,c,Z(r)),D=(x,c=0,t=7,u=14)=>_=(x&&D(x-1),(x>>=1)%2&&(1))?(d=L(L(D(x))),f=L(r),x=L(r),c-r||(L(u)||L(r)-f||(x>>=1)%2&&(u=S(4,4,d,r),t=A(t,d)),f/2&(x>>=1)%2&&(c=P(d,c),t=S(4,4-8,13,t),u=S(4,4-8,13,u))),c&&(x>>=1)%2&&(t=P(~u&2|(x>>=1)%2&&(u=1<<P(L(c),u)),P(L(c),t)),c=r),u/2&(x>>=1)%2&&(c=P(t,c),u=S(4,4-8,13,t),t=9),D(x,c,t,u)):P(P(t,P(u,P(x,c))),_),D(D(D(D(D(D(9))))))
// We also have _ equal to the code itself.

The logic is the same as the original loader.c, but few non-critical modifications are made to compress the code better.
In this, it is assumed to be:

Infinite call stack
Infinite memory
Infinite precision Number
Infinite magnitude Number
Bitshift and bitwise operators work on infinite bit integers instead of 53 bits. Bitwise negation still negates the sign bit.

Encoding/Decoding algorithm:
The encoding is done as follows:

Take a repeated string, call it S.
Replace all S in the code to a key K.
Put K and S at the end.
Make a list of keys, and also put decoding algorithm so the code actually runs.

The decoding algorithm:

Take list of keys.
Take the earliest key K.
Split the string for each K.
Since last of the array is what to replace K S, pop it, and replace all K by joining the array with the popped value S.

The compression was done with this code.
(d=String.fromCharCode)((c=a.charCodeAt())>>8)+d(c&255)).join``.slice(1))
```

This code will take the 16bit string as a, converts it to 8bit string with same binary(BE), and `eval` it.

The decoded code is the encoded code above. -->
Proof that D6(9)>D5(99)
For this, we would compare D(0) and 99. We find that D(0) is equal to 8646911284551352321 (note that in a normal environment without modifications we won't get a correct result because the higher bits are truncated). So, D(0)>99, and since D is strictly increasing, D6(9)>D6(0)>D5(99).

508B->501B, -7B

-1B for... I don't know why. I did change D(D(D(D(D(99))))) to D(D(D(D(D(D(9)))))). Also that shuffled the letters.
-6B for re-adding &&(1) for D(x)'s loop condition.

501B->495B, -6B

Fixed most /2s to >>1s because Number
6 bytes saved from somewhere
You can see my attempt in this update here

495->492B, -3B

By changing the decoder from for...in to for...of.

492->487B, -5B

Removing unnecessary assignments
Changing argument names

487->485B, -2B

1 byte from using eval for D, removing return.
1 byte compression combining the closing parentheses to a comma.

485->481B, -4B

By compressing different substrings.

481->478B, -3B

Removed unnecessary variable assignment.

478->456B, -22B

You can find me posting updates at Googology Server! (Discord).
2 bytes from changing from D6(9) to D6(0).
1 byte from making D recursive instead of using a loop.
7 bytes from making f and d in D global and not declaring them. It works since they are reassigned every time going through the loop, and D is not called between the assignment and the next iteration.
2 bytes from removing assignment to r. They will be assigned before use.
1 byte from removing an unnecessary assignment corresponding here in the original code. It no longer saved bytes.
1 byte from fixing a typo. I still don't know how it appeared.
2 bytes from swapping the second and the third variable of S. I checked and it should work fine.
1 byte from changing instances of S(4,-4,13, to S(4,4-8,13,.
2 bytes from adding unused variables y to Z and L.
1 byte from changing Z.
2 bytes from reusing _ as the accumulator. It starts out as a String containing the decoded code, and in such a case, it acts as 0 in bitwise operators. Also changed back to D6(9) for good measure.

456->452B -4B

Changed the 1-argument and 2-arguments functions' argument names to (x,c).

Python, q^15(2) = q^13(5), 319 bytes
This is my first time submitting a program to code golf, but certainly not my first time implementing or inventing a large number. I probably won't go down in googology history for this. Anyway, here is my program, the explanation comes later:
_="78b/:!if b==1:&(a+1)%c!9&s(8b-1/,s(81///\n7f(a):!m=[]*True:!#for x in range(65536):!##if a(x)==a(x+k): break!##9 pass'p = 4x:f(4y:s(1,y,x))\n7q(a):*p(k)<2^a:'k = $$$$$2...!\n##    $q(q(q('!#k+=1!&k\n&return *!k=0!while .)))))/,c)4lambda 7def 8s(a,9else:"
for Y in"9874/.*&'$#!":_=_.split(Y);_=_.pop().join(_)
exec(_)

I compressed this code using the same tool which Naruyoko used, here. Here is the uncompressed form:
def s(a,b,c):
    if b==1:return (a+1)%c
    else:return s(s(a,b-1,c),s(s(a,1,c),c),c)
def f(a):
    m=[]
    k=0
    while True:
        for x in range(65536):
            if a(x)==a(x+k): break
            else: pass
        k+=1
    return k
p = lambda x:f(lambda y:s(1,y,x))
def q(a):
    k=0
    while p(k)<2^a:
        k+=1
    return k
k = q(q(q(q(q(q(q(q(q(q(q(q(q(q(q(2)))))))))))))))

Explanation
I had a hard time choosing what to use. I was originally planning to implement my LINEAR(k) function, which I might do another time, but I didn't know if it would produce large enough numbers, and it would be hard to implement, so my next choice was greedy clique sequences, but those didn't work either, so I just ended up using Laver tables.
So, how do Laver tables work? Well the size-n Laver table is a binary operator ab, with the following rules: a0=0, a1=a+1 mod n and ab=(a(b-1))(a1) for b>1. p(n) is defined as the period of the function 1a, which is quite slow-growing.
The first few values of p(n) are 1,1,2,4,4,8,8,8,8,16,16,16,16,... Then q(n) is the least integer so that p(q(n)) is greater than or equal to 2^n. This is very fast-growing, and its totality can only be proven in ZFC+I3, so one could approximate it to f_PTO(ZFC+I3)(n) in FGH, although this doesn't work since there is no system of fundamental sequences associated to PTO(ZFC+I3).
The first few values of q(n) are 0,2,3,5,9. q(5) is approximated to Ack(9,Ack(8,Ack(8,255))) using the Ackermann function, and q(6) is believed to be greater than Graham's number!
So, now that we know how Laver tables work, how does my code work? Well, s(a,b,c) denotes the operator ab where n=c, then the function f(a) uses complex while loops to find the period of the given function a.
p is represented by the lambda which returns f(lambda y:s(1,y,x)), i.e. the period of s(1,y,x) where x is the input to p. q then just uses for loops to find the least integer k s.t. p(k) => 2^a.
My code then returns q^13(5), which has been proven to be greater than f_w(f_w+1(5)); note that this was for q^13(1) but q is strictly increasing so this also acts as a lower bound for q^13(5). This lower bound however is a severe understatement, since, as I mentioned earlier, q(n) cannot be proven total in ZFC while f_w(f_w+1(5)) can be by FAR.
Similarly, this code should return a number greater than Loader's number since, although sadly there is no proof, Loader's function is commonly believed to be provably total in ZFC; I do note however that just because a function which is provably total in a stronger theory doesn't mean that it will eventually dominate the one provably total in the weaker theory. It is usually the case though. So, all said, I WIN!!!
Edit: I lose because the code is completely broken and I can't fix it...

Welcome to the site.

As written, your for loop is dead code—it either breaks out of itself or runs to completion, but either way it has no effect on the surrounding code. There is no way for the while True loop to terminate. How is this function intended to work, and what’s the purpose of the constant 65536?

I'm not that good with loops and breaks and stuff. >What's the purpose of the constant 65536? I chose it to be big enough, to ensure that in something like 2,4,2,6,3,2,4,2,6,3 it doesn't return 2 since the 2 repeats after 2 spaces, instead it should return 5.

As written, your for loop is dead code
Sorry, I will fix it tomorrow.

Why is everyone upvoting this :D It's completely broken...

I was inspired by this answer to post a (hopefully working) implementation of this function as another answer.

Thank you so much benrg!

It's currently not known if q(n) can be proven total in ZFC or not, just known that it can be proven total in ZFC+I3

Python, q15(2), 192 bytes
def q(k,c=0,n=0):
 while c*2<1<<k:
  n+=1;*x,=map(s:=lambda b,a=1:s(a,s(b-1,a))if a*b else(a-~b)%c,range(c:=1<<n))
  while x[:c]==x[-c:]:x=x[:c];c>>=1
 return n
print(eval(15*'q('+'2'+')'*15))

See Binary198's answer for the definition of q and an argument that q15(2) is large enough. If the argument is correct, then this is an impressively concise way to beat Loader's number. Unfortunately their implementation is broken.
This is my attempt at reasonably well golfed code that, I think, actually works. At least, it correctly computes values of q up to q(3)=5. (If you want to test that, you should wrap the definition of s in functools.lru_cache(None)(...).) Computing q(4)=9 may be possible, but will need a lot of stack space.
s(b,a) computes row a, column b+1 of the Laver table of size c, using 0...c-1 as the representatives of Z/cZ instead of the usual (for these tables) 1...c. The period-finding code uses the fact that the period can only be a power of 2. Other than that, there are only standard golfing tricks here.
I deliberately computed the same value as Binary198's answer, though it could be made larger at no cost, because I'm not trying to compete on size; I just wanted a working implementation of this interesting function (for some definition of "working").

Ruby, D6(9) (553 544 535 516 511 507 bytes)
_='a=r=0;P"x-~x<<y};Z"r=x%2B1?0M1+J/2FL"x/2>>JFS=->vEt{f=L(t);x=r;fB2?A*EJ6Mf>2?fBv ?yMf>v ?t-cMtM@f,P*+2,#y8c,J6FA"Cx]B1?Ky,4,Z[r]]M5<<@x,yFD"f=d=c=0;t=7;O14;while[xIHx-18.>0][1];d=CCHx6;f=N;x=N;cBr&&[Cu]B0&&NBf&&.I[OKd,4,rQA[t,d]8fGd,cQ#t8O#u6;cI.&&[t=@~u&2|.I(O1<<@Cc8u]),@Cc8t]8c=r];uGt,c8O#tQ9];end;a=@@t,@u,@x,c6,aF$><<HHHHHH966"=->x,y=0{#K13,-4,*[S[vECx]8S[v.(x/=2)%26]]]8],@P[B==CL[E,y,c,F]};G/2&.I[c=@HD[IB0||JZ[xKS[4,M: NCr]Ou=Q8t=';'QONMKJIHGFECB@86.*#"'.each_char{|y|*_,y=_.split y;_=_*y};eval _

This is an encoded code. Extracted:
a=r=0;P=->x,y=0{x-~x<<y};Z=->x,y=0{r=x%2==1?0: 1+Z[x/2]};L=->x,y=0{x/2>>Z[x]};S=->v,y,c,t{f=L(t);x=r;f==2?A[S[v,y,c,L[x]],S[v,y,c,Z[x]]]: f>2?f==v ?y: f>v ?t-c: t: P[f,P[S[v,y,c,L[x]],S[v+2,S[4,13,-4,y],c,Z[x]]]]};A=->x,y=0{L[x]==1?S[4,y,4,Z[r]]: 5<<P[x,y]};D=->x,y=0{f=d=c=0;t=7;u=14;while[x==0||D[x-1],(x/=2)%2>0][1];d=L[L[D[x]]];f=L[r];x=L[r];c==r&&[L[u]==0&&L[r]==f&&(x/=2)%2==0||[u=S[4,d,4,r],t=A[t,d]],f/2&(x/=2)%2==0||[c=P[d,c],t=S[4,13,-4,t],u=S[4,13,-4,u]]];c==0||(x/=2)%2&&[t=P[~u&2|(x/=2)%2==0||(u=1<<P[L[c],u]),P[L[c],t]],c=r];u/2&(x/=2)%2==0||[c=P[t,c],u=S[4,13,-4,t],t=9];end;a=P[P[t,P[u,P[x,c]]],a]};$><<D[D[D[D[D[D[9]]]]]]

This code is Loader's Number with D6(9) instead.
In this, it is assumed to be:

Infinite call stack
Infinite memory

This is basically a port of my JavaScript answer and Python 3 answer. For more details, check those.
The compression was done with this.
I am a beginner at Ruby, so maybe under 512 is possible, but I doubt it.

553->544B, -9B

Added 3 bytes from fixing a formatting error.
5 bytes from removing an unused print.
4 bytes from changing expression t-(f>v ?1: 0)*c to f>v ?t-c: t
1 byte from removing an unnecessary assignment to t.
2 bytes from removing an assignment to r.

544->535B, -9B

Improved the decoder.

535->516B, -19B

17 bytes from changing functions to lambda expressions.
1 byte each from removing parenthesis from split and eval.
Thanks @Dom Hastings!

516->511B, -5B

Use a and r declared globally, instead of $a and $a.

511->507B, -4B

Change all 1 and 2 argument functions' arguments to x,y=0.

Hey, nice answer! I think you can save a few bytes dropping parens from eval, split, etc, and in the compressed string any calls that are before a ; or ] could probably have parens removed too. Even D D D D D D 9 should work. Not sure if that'll help get closer to 512...

Python, 498 bytes, ???
I don't know how large this program would get.
Okay, I've had a few failed attempts on this, but I think I've got it this time.  First, the code:
from itertools import product as X
C=[1,0]
V=[9]
r=range
L=list
def R(n):
    C[0]=1
    while C[0]:
        C[0]=0
        for m in r(V[0]):P(m,n)
        if(C[0]<1)+(C[1]<len(V)):P(C[1],n,1)
    return sum(V)
def P(m,n,B=0,T=0):
    if m==len(V):V.append(0)
    k=m+n;c=r(k)
    for M in X(*[L(X(*[L(X(c,c,[-1,0,1]))]*k))]*k):
        t={};u=p=s=d=1
        while d:
            s,c,d=M[s][t.get(p,0)];t[p]=c;p+=d;u+=1
            if u>sum(V):u=d=0
        T+=u
    if T>V[m]:C[0]=V[m]=T;C[1]=min(C[1],m+1)
    if B>C[0]:V[m]+=1;P(m,n,1)
z=9**9
exec("z=R(z);"*R(z))
print(z)

Explanation:
This function simulates all Turing machines with n states and n colours for a number of steps (initially 9), then sums the number of steps that it took for any machine that halted to halt, storing that value as the number of steps to take on the next iteration.  It keeps doing this until it reaches a steady state.
We don't just look at machines that have n states and colours, but also n+1, n+2, up to n+V[0], where V[0] is the sum of the halting times for the machines with n states and colours.
So far, I've just described a function which is polynomial at best.  Notably, it grows slower than the busy beaver function on these Turing machines.  Thus, we can be confident that there is at least one machine of size n which halts but we have not yet found.  So we search for that one (this function is undefined on inputs which are too small).
Once we find it, we continue on as we were.  We'll reach another steady state.  This time, we can't be confident that there is another halting Turing machine of size n, but as BB(n+1)>F(BB(n)) for any reasonable polynomial function F (which this is), we can be confident that there is a halting Turing machine of size n+1 which we have not found.  If we then find a halting machine of size n, we know that we can perform this step on n+1 again.
We repeat this process until we've attempted this on every size of machine we're looking at (from n to n+V[0]), and thus can no longer be confident that there is a machine that halts of those sizes that we have not seen.
While this number is certainly less than BB(n), I'm not sure how one would go about determining just how big it is.  The guarantee that it halts is basically "BB(n) grows much faster than this does".  I'm fairly confident that's a safe assumption for values of R(n) greater than, say, R(5).
Here's a less golfed version with comments:
from itertools import product as X
 # C[0] is 1 or 0 representing a change, so keep looping
 # C[1] is the next machine that needs to search.
C=[1,0]
 # V[x] is the total steps taken by the machine with n+x colours and states
V=[9]
def R(n):
    while C[0]:
        C[0]=0
        # Run each set of machines sum(V) steps.
        for m in range(V[0]):P(m,n)
        # Run machine set C[1] sum(V) steps, then run it until one more machine stops.
        if C[0]<1 and C[1]<len(V):P(C[1],n,1)
    return sum(V)
 # Run one set of machines with m+n colours and states.
def P(m,n,B=0):
    if m==len(V):V.append(0)
    # Start our total at 0
    T=0
    # For each machine in the set...
    for M in G(m+n):
        # Step count u starts at 0
        # The tape t starts empty
        # Position p starts at 1
        # State s starts at 1
        # Direction d starts at 1.  These are all 1 because it's shorter and we use d=0 as break
        t={};u=p=s=d=1
        while d:
            s,c,d=M[s][t.get(p,0)];t[p]=c;p+=d;u+=1
            if u>sum(V):u=d=0
        T+=u
    # If the total is greater than the last time we ran this set, increase it and note there's been a change
    if T>V[m]:
        C[0]=V[m]=T
        if m<C[1]:C[1]=m+1
    # If we're running it until there's a change, increment V[m] and try again.
    if B>C[0]:V[m]+=1;P(m,n,1)
 # Generate all the machines of appropriate size.
def G(k):
    L=list
    # List of colours
    c=range(k)
    # List of options for a single state/colour combination - new state, colour written, direction moved (0 being halt)
    O=L(X(c,c,[-1,0,1]))
    # List of options for one state
    S=L(X(*[O]*k))
    # List of options for all states
    return L(X(*[S]*k))
r=9**9
for i in range(R(r)):
    # Reset C[0], as we need to be able to run again.  C[1] will get reset in P().
    C[0]=1;r=R(r)
print(r)

Actually, it occurs to me that there's no reason why (in principle) we can know that R(n) < BB(n) (when BB(n) is defined to be on Turing machines with n colours and states).  Determining exactly how big R(n) is is related to a limited version of the halting problem, as it isn't guaranteed that $$BB(n)*2^{n*2^{3n^2}}<BB(n+1)$$ That's the limit on how quickly R(n) grows without the "look for the next terminating machine" step.  I think it's a pretty safe assumption, though, that it's true with n>5 or so.
while we can know that R(n) halts on big enough inputs, it's certainly possible that the result is in every case larger than BB(n).  Proving such (if true) would be equivalent to the halting problem, of course.

I'm looking at the golfed code and some stuff isn't making sense. if(C[0]sum(V): looks like a typo -- it's not syntactically valid. P and T are undefined. L and X are defined but not used.

@xnor There was an edit fixing formatting; it caused a bunch of stuff to disappear because < was causing issues.  I've corrected it now.

I tried to fix it. Let me know if there's trouble. Code blocks (with Ctrl+K) respect code formatting better than code tags.

It looks like z=9e9 ends up in a range, which only accepts integers, not integer-valued floats. So I think you need something like 9**9 or whatever is big enough.

@xnor and Spitemaster mea culpa. I just put in the tags and didn't even check the output. Lazy editing on a Friday afternoon. That'll teach me to ship code on a Friday.

If we run the n-state TMs for n steps, there will likely be an n-state halting TM we missed that computes F(m), for F a reasonably polynomial function and m "mildly" smaller than n. (I'm thinking something like m=9**8 for n=9**9, but I'm not sure about definability for larger n.) The first machine to halt after checking for n steps should then have halting time $\leq F(n)$. So maybe when comparing sum(V) after checking for n steps, and sum(V) after one more machine halted, it won't be drastically larger?

@C7X Yes, I agree.  But the "search for next halting machine" step is performed at least V[0] times - once per size of Turing machine we consider.  Likely many more times than that, because if we find a new smaller halting machine, we can go back to that point.  I think it quite unlikely that we get small increases all of the time.  And as large increases are likely cause us to find smaller machines, a small proportion of large increases should be sufficient to make this extremely large.

Python 3, D^6(9) (608 600 599 597 591 583 573 bytes)
_="a=06PJ$x-~x<<c6ZJr=0'E?1+TKQ$r6LJ$xK+T)6@t!YtUr#$A([@TC)'f==2?If,I[S(v+2R,/yUTCC'f<2?t-(f>v)*c'f-v?y6AJ$5<<PB)'Fx)-1?MR,Z(rC6DB=0,t=7,X14!Gx:Nx-1Q.G~EV a=IIt,Iu,PBCUaQ $a#d,YFNxCUFrUFrQGc-rV'not(Fu)or(Fr)-fCH'E:XM,d,rOA(t,dQ'fKH'WdRO/t);X/uQGcV .'EH q=~u&2|E# 'q:X1<<IFuUuQ  tR=Iu'q?q,IFcUtC,r#.GuK&WtR);X/tO9#$DB,t,u)\nprint(NNNNNN9CCC)!)Vglobal r,a##\n $return ' G.x=xK#/M-8,13,6\ndef ? else @S(vR,y,B(xRC))Ex%2FL(Gif HV  . IP(JB=0!K>>1MS(4,4ND(O);t=Q)#R,cTZ(xU),V:#WE:c=IXu=Yf,x=F[@FxC,"
for Y in"[YXWVUTRQONMKJIHGFECB@?6/.'$#!":_=_.split(Y);_=_.pop().join(_)
exec(_)

This is an encoded code. Extracted:
a=0
def P(x,c=0):
 global r,a
 return x-~x<<c
def Z(x,c=0):
 global r,a
 r=0 if x%2 else 1+Z(x>>1)
 return r
def L(x,c=0):
 global r,a
 return x>>1+Z(x)
def S(v,c,y,t):
 global r,a
 f,x=L(t),r
 return A(S(v,c,y,L(x)),S(v,c,y,Z(x))) if f==2 else P(f,P(S(v,c,y,L(x)),S(v+2,c,S(4,4-8,13,y),Z(x)))) if f<2 else t-(f>v)*c if f-v else y
def A(x,c=0):
 global r,a
 return 5<<P(x,c) if L(x)-1 else S(4,4,c,Z(r))
def D(x,c=0,t=7,u=14):
 global r,a
 if x:D(x-1)
 x=x>>1
 if ~x%2:
  a=P(P(t,P(u,P(x,c))),a)
  return a
 d,f,x=L(L(D(x))),L(r),L(r)
 if c-r:
  if not(L(u)or(L(r)-f)):
   x=x>>1
   if x%2:u=S(4,4,d,r);t=A(t,d)
  if f>>1:
   x=x>>1
   if x%2:c=P(d,c);t=S(4,4-8,13,t);u=S(4,4-8,13,u)
 if c:
  x=x>>1
  if x%2:
   x=x>>1
   q=~u&2|x%2
   if q:u=1<<P(L(u),u)
   t,c=P(u if q else q,P(L(c),t)),r
 x=x>>1
 if u>>1&x%2:c=P(t,c);u=S(4,4-8,13,t);t=9
 return D(x,c,t,u)
print(D(D(D(D(D(D(9)))))))

In this, it is assumed to be:

Infinite call stack
Infinite memory

This is basically a port of my JavaScript answer. For more details, check that one.
The compression was done with this.
I am not very knowledgeable in Python, so there are certainly places to save bytes. I think sub-600 is possible. sub-600 has been proven.

608->600B, -8B

Grouped some assignments
Reversed conditions of S to reduce parenthesis

600->599B, -1B

Changing u/2 in the third last line of the definition of D to u>>1, saving a byte from compressing it to a character with other >>1s.

599->597B, -2B

2 bytes from removing assignment to r.

597->591B, -6B

Made D recursive.
Removed the unnecessary assignments to d, f, and c. Making D recursive allows this to be completely removed and save more bytes whereas keeping it in a loop would have still needed an assignment to c.

591->583B, -8B

Changed the 1-argument and 2-arguments functions' arguments to (x,c=0).
Added global r,a to every function.
Swapped the second and the third of S.
Changed the instances of S(4,-4,13, to S(4,4-8,13,.
Fixed the compression algorithm (specifically displaying) so it actually works now.

583->573B, -10B

Replaces q and u with u if q else q and that somehow saved 10 bytes.


text:
Color of a Pixel
Write a program that prints the RGB color of a given pixel on the screen.
The program should read a line from stdin in the format x,y, where x and y are unsigned integers. The pixel (0,0) is the top left pixel in the screen.
The program should then output a line to stdout in the format RRR,GGG,BBB, which represents the color of the pixel at (x,y).
RRR, GGG, and BBB should be floating-point numbers between 0 and 1, OR integers in the range [0, 255]. Leading zeros do not matter, for example: both 074 and 74 are acceptable.
Undefined Behavior
It is okay for the program to exhibit undefined behavior (crash, give incorrect output, etc) in the following conditions:

The user inputs a string, signed integer, float, or any other invalid data type
The user input is not in the format x,y
The specified pixel is off-screen

Notes:

The program cannot modify the pixel at the given coordinates.
If you have multiple monitors, it does not matter which monitor the pixel is on, as long as the same monitor is used each time the program runs.

The answer with the fewest bytes wins.

Why should RRR, GGG, and BBB be floating points between 0 and 1? Usually they're integers in the range [0,255]. I would suggest to allow both.

adding to that, RRR,GGG,BBB suggests 3 characters per number? would that mean just one significant digit? (either 0.x or 1.0)?

Can we limit our solutions to the window they are being run in, for the benefit of languages that can't access anything on screen outside of that window?

If you allow only the 0 — 1 format you should not use RRR, GGG, and BBB in the spec, but R, G, B

What if we have multiple monitors?

It could be worth to specify that the program can't modify the pixel at the given coordinate. Otherwise it might be more efficient to black out the entire screen and return 0, 0, 0, defeating the purpose of the challenge.

@maxb It seems like that should be allowed. Then a part of the challenge is whether it's shorter to black the screen or actually read that pixel.

@FelixPalmen Yes to both of those questions. See the edits.

@KevinCruijssen see the edit

Java 10 (lambda function), 105 75 bytes
x->y->(new java.awt.Robot().getPixelColor(x,y)+"").replaceAll("[^\\d,]","")

A function taking two integer parameters and returning a String RRR,GGG,BBB, where the colors are integers in the range [0, 255].
-30 bytes thanks to @LukeStevens by using java.awt.Color's default toString() output and modifying it so only the digits and commas remain.
Explanation:
x->y->                      // Method with two integer parameters and String return-type
  (new java.awt.Robot()     //  Create a AWT-Robot instance
    .getPixelColor(x,y)     //  Get the pixel AWT-Color at position x,y
    +"")                    //  Call the default toString() of the AWT-Color
                            //   i.e. "java.awt.Color[r=213,g=230,b=245]"
  .replaceAll("[^\\d,]","") //  Remove everything except for digits and commas

NOTE: The default toString() implementation of the java.awt.Color has always been the same across JVM versions as far as I know, but can potentially change in the future. I tested it in both Java 8 and Java 10 and it returned "java.awt.Color[r=#,g=#,b=#]".

But, since the challenge states:

Full program
Taking input in the format x,y from STDIN
Output in the format R,G,B to STDOUT
Have the R, G, B as floating points in the range [0.0, 1.0]

The code becomes A LOT more verbose:
Java 10 (full program), 266 bytes
interface M{static void main(String[]a)throws Exception{var s=new java.util.Scanner(System.in).next().split(",");var c=new java.awt.Robot().getPixelColor(new Short(s[0]),new Short(s[1]));System.out.print(c.getRed()/255d+","+c.getGreen()/255d+","+c.getBlue()/255d);}}

Explanation:
interface M{          // Class
  static void main(String[]a)
                      //  Mandatory main method
    throws Exception{ //    Mandatory throws clause for `new Robot()`
  var s=new java.util.Scanner(System.in)
                      //   Create a Scanner for STDIN
         .next()      //   Get the String user input
         .split(","); //   Split it on "," and save it as String-array in `s`
  var c=new java.awt.Robot()
                      //   Create a AWT-Robot instance
         .getPixelColor(
                      //   And get the pixel AWT-Color at position:
           new Short( //    Convert String to Short (and implicitly to int):
            s[0]),    //     x-coordinate input by user from String-array `s`
           new Short( //    Convert String to Short (and implicitly to int):
            s[1]));   //     y-coordinate input by user from String-array `s`
  System.out.print(   //   Print to STDOUT:
   c.getRed()         //    The red part of RGB as integer in the range [0,255]
    /255d             //     Converted to a floating point in the range [0.0, 1.0]
   +","               //    Appended with a comma delimiter
   +c.getGreen()      //    Appended with the green part of RGB as integer in the range [0,255]
     /255d            //     Converted to a floating point in the range [0.0, 1.0]
   +","               //    Appended with a comma delimiter
   +c.getBlue()       //    Appended with the blue part of RGB as integer in the range [0,255]
     /255d);}}        //     Converted to a floating point in the range [0.0, 1.0]

For the first, loose-rules answer, you can make use of Colors String conversion and simply have x->y->(new java.awt.Robot().getPixelColor(x,y)+"").replaceAll("[^\\d,]","") for 75 bytes

@LukeStevens Smart use of the default toString() of java.awt.Color. Thanks!

Good job guys, you beat me to it: I was busy implementing the toString() way as well... ;-) Except I had to download an IDE to do all that: I only use TIO now :(

Note that the Javadoc is very clear that Color::toString is implementation-discretionary. So it might be good to specify which JVM was used for the tests (it works as is with OpenJDK and Oracle JDK).

@OlivierGrégoire Lol.. I still program in Java at work, so I have a test program always open in case I need it (mostly for debugging complex challenges that I created in TIO, since I barely use it at all these days). But for things like this it's useful. :)

Finally, you should replace " " with "," to comply with the strict RRR,GGG,BBB format (not RRR GGG BBB).

6502 machine code (C64), 280 260 bytes
00 C0 A2 00 20 CF FF C9 0D 9D 02 C1 F0 03 E8 D0 F3 20 D2 FF A5 7A 85 FB A5 7B
85 FC A9 01 85 7A A9 C1 85 7B 20 73 00 20 6B A9 A5 14 85 FD A5 15 85 FE 20 73
00 20 6B A9 A5 FB 85 7A A5 FC 85 7B A5 14 4A 4A 4A AA 20 F0 E9 A5 FD 46 FE 6A
4A 4A A8 A5 14 29 07 AA A9 00 38 6A CA 10 FC 85 FE B1 D1 0A 26 FC 0A 26 FC 0A
26 FC 85 FB A5 D2 29 03 09 D8 85 D2 B1 D1 85 02 A9 02 18 2D 18 D0 0A 0A 65 FC
29 0F 09 D0 85 FC A9 33 85 01 A5 FD 29 07 A8 B1 FB A2 37 86 01 25 FE D0 05 AD
21 D0 85 02 A6 D6 20 F0 E9 A5 02 29 0F AA BC D2 C0 20 BC C0 BC E2 C0 20 B7 C0
BC F2 C0 A9 2C 20 D2 FF 98 0A A9 30 90 02 A9 31 20 D2 FF A9 2E 20 D2 FF 98 29
7F 4C D2 FF 30 B0 35 35 36 33 32 39 36 33 38 33 35 37 34 37 30 B0 32 38 32 37
32 39 33 32 34 33 35 B0 34 37 30 B0 32 38 36 33 36 34 32 30 34 33 35 36 39 37

I expected this to be possible in a lot fewer bytes, but unfortunately... well, since I finished it, posting it now anyways. At least, the restrictive format helped with one thing: Something similar to stdin (input from a current device) only exists on the C64 in text mode, because the OS only supports this mode -- so no need to consider other modes of the graphics chip.
Note on the output of the color values: the C64 graphics chip doesn't use RGB colors but directly generates a video signal with YUV colors, with a fixed 16 colors palette. I used rounded values of the colodore conversion to RGB with "default" monitor settings here.
-20 bytes: better output routine, encoding the 3 character output per color channel in a single byte.
Regarding the comment: It's theoretically possible to use even multicolor character mode of the VIC with the stock C64 OS, but it requires a custom font that's actually legible with only 4 horizontal pixels of doubled width. Not entirely impossible, but very unlikely. Likewise, extended color mode (or extended background mode, which is the same) could be used with the C64 OS, but requires to reconfigure the graphics chip directly. I opt to ignore all these possibilities in the sense of code golfing here: It's not the standard environment you find on a Commodore 64 with running stock OS. What's possible with stock OS is switching between two builtin fonts (shift + commodore key), the program does account for that.
Online demo
Usage: SYS49152 to start.
Commented disassembly:
         00 C0       .WORD $C000        ; load address
.C:c000  A2 00       LDX #$00           ; loop index for input
.C:c002   .input:
.C:c002  20 CF FF    JSR $FFCF          ; character from input device
.C:c005  C9 0D       CMP #$0D           ; compare with enter
.C:c007  9D 16 C1    STA .buf,X         ; store to buffer
.C:c00a  F0 03       BEQ .parse         ; was enter -> start parsing
.C:c00c  E8          INX                ; next character
.C:c00d  D0 F3       BNE .input         ; and repeat input loop
.C:c00f   .parse:
.C:c00f  20 D2 FF    JSR $FFD2          ; output the enter character
.C:c012  A5 7A       LDA $7A            ; save pointer of BASIC parser
.C:c014  85 FB       STA $FB
.C:c016  A5 7B       LDA $7B
.C:c018  85 FC       STA $FC
.C:c01a  A9 15       LDA #$15           ; set pointer of BASIC parser to
.C:c01c  85 7A       STA $7A            ; buffer-1
.C:c01e  A9 C1       LDA #$C1
.C:c020  85 7B       STA $7B
.C:c022  20 73 00    JSR $0073          ; get next character
.C:c025  20 6B A9    JSR $A96B          ; BASIC routine to parse number
.C:c028  A5 14       LDA $14            ; lowbyte of parsed number to $fd
.C:c02a  85 FD       STA $FD
.C:c02c  A5 15       LDA $15            ; highbyte to $fe
.C:c02e  85 FE       STA $FE
.C:c030  20 73 00    JSR $0073          ; get next character
.C:c033  20 6B A9    JSR $A96B          ; parse as number ...
.C:c036  A5 FB       LDA $FB            ; restore pointer of BASIC parser
.C:c038  85 7A       STA $7A
.C:c03a  A5 FC       LDA $FC
.C:c03c  85 7B       STA $7B
.C:c03e  A5 14       LDA $14            ; load y coordinate
.C:c040  4A          LSR A              ; divide by 8 for character row
.C:c041  4A          LSR A
.C:c042  4A          LSR A
.C:c043  AA          TAX                ; -> to X
.C:c044  20 F0 E9    JSR $E9F0          ; set pointer to character row
.C:c047  A5 FD       LDA $FD            ; divide x coordinate by 8
.C:c049  46 FE       LSR $FE
.C:c04b  6A          ROR A
.C:c04c  4A          LSR A
.C:c04d  4A          LSR A
.C:c04e  A8          TAY                ; -> to Y
.C:c04f  A5 14       LDA $14            ; load y coordinate
.C:c051  29 07       AND #$07           ; mask pixel position in character
.C:c053  AA          TAX                ; -> to X
.C:c054  A9 00       LDA #$00           ; initialize pixel mask to 0
.C:c056  38          SEC                ; set carry for bit to shift in
.C:c057   .bitnum:
.C:c057  6A          ROR A              ; shift bit in mask
.C:c058  CA          DEX                ; and repeat until
.C:c059  10 FC       BPL .bitnum        ; in correct position
.C:c05b  85 FE       STA $FE            ; store pixel mask to $fe
.C:c05d  B1 D1       LDA ($D1),Y        ; load character code
.C:c05f  0A          ASL A              ; multiply by 8
.C:c060  26 FC       ROL $FC
.C:c062  0A          ASL A
.C:c063  26 FC       ROL $FC
.C:c065  0A          ASL A
.C:c066  26 FC       ROL $FC
.C:c068  85 FB       STA $FB            ; and store to $fb/$fc
.C:c06a  A5 D2       LDA $D2            ; move pointer to position in color RAM
.C:c06c  29 03       AND #$03
.C:c06e  09 D8       ORA #$D8
.C:c070  85 D2       STA $D2
.C:c072  B1 D1       LDA ($D1),Y        ; load color of character
.C:c074  85 02       STA $02            ; and store to $2
.C:c076  A9 02       LDA #$02           ; check which charset is active
.C:c078  18          CLC
.C:c079  2D 18 D0    AND $D018
.C:c07c  0A          ASL A              ; and calculate offset
.C:c07d  0A          ASL A
.C:c07e  65 FC       ADC $FC            ; add to (character code * 8)
.C:c080  29 0F       AND #$0F
.C:c082  09 D0       ORA #$D0           ; and add offset to character ROM
.C:c084  85 FC       STA $FC
.C:c086  A9 33       LDA #$33           ; bank in character ROM
.C:c088  85 01       STA $01
.C:c08a  A5 FD       LDA $FD            ; load y coordinate
.C:c08c  29 07       AND #$07           ; mask pixel-row number
.C:c08e  A8          TAY
.C:c08f  B1 FB       LDA ($FB),Y        ; load pixel row from character ROM
.C:c091  A2 37       LDX #$37           ; bank out character ROM
.C:c093  86 01       STX $01
.C:c095  25 FE       AND $FE            ; apply pixel mask
.C:c097  D0 05       BNE .pixelcol      ; not 0 -> pixel is set
.C:c099  AD 21 D0    LDA $D021          ; otherwise load background color
.C:c09c  85 02       STA $02            ; and store to $2
.C:c09e   .pixelcol:
.C:c09e  A6 D6       LDX $D6            ; restore screen row pointer for
.C:c0a0  20 F0 E9    JSR $E9F0          ; current cursor position
.C:c0a3  A5 02       LDA $02            ; load color
.C:c0a5  29 0F       AND #$0F           ; mask low nibble (only 16 colors)
.C:c0a7  AA          TAX                ; -> to X
.C:c0a8  BC D2 C0    LDY .red,X         ; load encoded output for red
.C:c0ab  20 BC C0    JSR .out2          ; call output without comma
.C:c0ae  BC E2 C0    LDY .green,X       ; load encoded output for green
.C:c0b1  20 B7 C0    JSR .out1          ; call output with comma
.C:c0b4  BC F2 C0    LDY .blue,X        ; load encoded output for blue
.C:c0b7   .out1:
.C:c0b7  A9 2C       LDA #$2C           ; load ","
.C:c0b9  20 D2 FF    JSR $FFD2          ; and output
.C:c0bc   .out2:
.C:c0bc  98          TYA                ; encoded output to A
.C:c0bd  0A          ASL A              ; shift top bit to carry
.C:c0be  A9 30       LDA #$30           ; load "0"
.C:c0c0  90 02       BCC .firstdig      ; carry clear -> to output
.C:c0c2  A9 31       LDA #$31           ; load "1"
.C:c0c4   .firstdig:
.C:c0c4  20 D2 FF    JSR $FFD2          ; and output
.C:c0c7  A9 2E       LDA #$2E           ; load "."
.C:c0c9  20 D2 FF    JSR $FFD2          ; and output
.C:c0cc  98          TYA                ; encoded output to A
.C:c0cd  29 7F       AND #$7F           ; mask out top bit
.C:c0cf  4C D2 FF    JMP $FFD2          ; to output and exit
.C:c0d2   .red:                                 ; encoded values for red
.C:c0d2  30 B0 35 35 .BYTE $30,$B0,$35,$35      ; ASCII digit ($30-$39) after
.C:c0d6  36 33 32 39 .BYTE $36,$33,$32,$39      ; decimal point, with bit 7
.C:c0da  36 33 38 33 .BYTE $36,$33,$38,$33      ; indicating 0 or 1 before
.C:c0de  35 37 34 37 .BYTE $35,$37,$34,$37      ; decimal point
.C:c0e2   .green:                               ; encoded values for green
.C:c0e2  30 B0 32 38 .BYTE $30,$B0,$32,$38      ; ...
.C:c0e6  32 37 32 39 .BYTE $32,$37,$32,$39
.C:c0ea  33 32 34 33 .BYTE $33,$32,$34,$33
.C:c0ee  35 B0 34 37 .BYTE $35,$B0,$34,$37
.C:c0f2   .blue:                                ; encoded values for blue
.C:c0f2  30 B0 32 38 .BYTE $30,$B0,$32,$38      ; ...
.C:c0f6  36 33 36 34 .BYTE $36,$33,$36,$34
.C:c0fa  32 30 34 33 .BYTE $32,$30,$34,$33
.C:c0fe  35 36 39 37 .BYTE $35,$36,$39,$37
.C:c102   .buf:                                 ; buffer for input ("stdin")

This doesn't seem to support multicolor mode.

Of course not, it works with the original OS. Technically, this OS works in any VIC mode, but there will be only garbage on the screen, so it isn't usable. But your comment made me remember "extended color mode", which works quite well with stock OS ... dammit

@nwellnhof added some reasoning about it, I hope this is agreeable.

Makes one wonder if writing this in C would be shorter?

@Rogem could try that with cc65 .. quite possible :) but at least, the compiled code will be larger :)

TI-BASIC (TI-83/84+), 22 bytes
Since the screen is black and white, we just need to test if the specified pixel is on or off and map that to black or white RGB.  Also, the pixels are only accessible through row and column in that order, so that's why the coordinates are reversed.
Prompt X,Y
255
Ans-{Ans,Ans,Ans}pxl-Test(Y,X

Note that this doesn't work on color TI calculators (Like the TI-84 Plus CE).

Are you sure about the byte count? I count 22.

TI-Nspire assembly - 112 bytes
50 52 47 00 30 40 2D E9 FF FF FF FA 00 F0 17 F8
04 1C 00 F0 14 F8 85 00 2D 18 AD 01 2D 19 6C 00
C0 21 09 06 09 69 08 5B 3F 25 42 09 2A 40 1F 25
03 1C 2B 40 C1 0A 29 40 0A A0 0A DF 30 BD 00 20
0A 23 07 49 10 25 8A 69 2A 42 FC D1 0A 68 FF 25
2A 40 30 3A 0B DB 85 00 2D 18 6D 00 A8 18 F1 E7
00 00 02 90 25 64 2C 25 64 2C 25 64 0A 00 70 47

This program outputs integers in the range 0-31 for R and B and 0-63 for G, because the device natively uses a RGB565 framebuffer. It uses serial for input and output.
Source:
.string "PRG"
push {r4, r5, lr}
blx main
.thumb
main:
@ read x and y from serial into r4 and r0
bl read_int
mov r4, r0
bl read_int

@ turn x and y into framebuffer offset
@ r4 = ((r0 * 320) + r4) * 2
lsl r5, r0, #2
add r5, r0
lsl r5, #6
add r5, r4
lsl r4, r5, #1

@ load pixel from framebuffer
@ r0 = ((uint16_t **)0xc0000000)[0x10][r4 / 2]
mov r1, #0xC0
lsl r1, #24
ldr r1, [r1, #0x10]
ldrh r0, [r1, r4]

@ unpack RGB565 value into r1, r2, r3
mov r5, #0x3f
lsr r2, r0, #5
and r2, r5
mov r5, #0x1f
mov r3, r0
and r3, r5
lsr r1, r0, #11
and r1, r5

@ call printf
adr r0, fmt
swi #10

@ return
pop {r4, r5, pc}

@ subroutine to read an integer from serial
read_int:
mov r0, #0
mov r3, #10
ldr r1, serial_base
@ loop until characters come in on serial
2:
mov r5, #(1<<4)
1:
ldr r2, [r1, #0x18]
tst r2, r5
bne 1b
@ read character from serial and mask out status bits
ldr r2, [r1]
mov r5, #0xff
and r2, r5
@ subtract 48 ('0') from byte; if result is negative, return
sub r2, #48
blt 1f
@ multiply existing numbers by 10 and add new number to them
lsl r5, r0, #2
add r5, r0
lsl r5, #1
add r0, r5, r2
b 2b

serial_base:.word 0x90020000
fmt:.string "%d,%d,%d\n"
@ this instruction is over here because serial_base and fmt need to be word-aligned
1:bx lr

bash, 103 / 86 bytes
With a strict interpretation of the spec (input from STDIN and output on STDOUT are both comma-separated):
read x
import -window root -crop 1x1+${x/,/+} ppm:-|od -dj13|awk 'NR<2{n=2^16;print$2/n","$3/n","$4/n}'

With a looser input format (plus-separated input as a command line argument, space-separated output:
import -window root -crop 1x1+$1 ppm:-|od -dj13|awk 'NR<2{n=2^16;print$2/n,$3/n,$4/n}'

Depends on imagemagick, awk, and coreutils.

Bash on Linux with xserver, 30 bytes
xset dpms force off;echo 0,0,0

Using the idea presented in my comment on the question, this solution should turn off the display output completely, and then echo that the screen is indeed black.
I was also thinking of using xbacklight =0, but that doesn't change the pixel colors.

+1 for finding the loophole, but I updated the constraints.

Python 2 + PIL library, 96 91 bytes
import PIL.ImageGrab as i
print','.join('%.1f'%(x/255.)for x in i.grab().getpixel(input()))

Implements the specification literally as requested. Windows only though - doesn't work on Linux, and produces extra output (alpha value) on Mac.

from PIL import ImageGrab as i → from PIL import*, i.grab → ImageGrab.grab.

@Erik this does not for PIL. PIL only imports the names explicitly listed.

@ovs, Ah, that's probably the problem why I couldn't also make the __import__('...') way work.

Note that this outputs an alpha value on macOS, so it only adheres to the spec on Windows.

@ovs, OK, good to know, thanks.

Mathematica, 69 Bytes
Just the function is 34 bytes.
CurrentScreenImage[]~PixelValue~#&
Takes input in the form {x,y}.
The image is the merging of images on all monitors.  If you want a particular screen, use the integer index - e.g.  CurrentScreenImage[1]
Full program exactly as specified is 69 Bytes
CurrentScreenImage[]~PixelValue~ToExpression["{"<>InputString[]<>"}"]

AutoHotKey, 113 bytes
CoordMode,Pixel
InputBox,x
InputBox,y
PixelGetColor,c,x,y
MsgBox % c&255 . "," . c>>8&255 . "," . c>>16&255

Use dialog boxes instead of stdin/stdout.

TIL that AutoHotKey is Turing complete

TI-BASIC (TI-83/84+), 15 bytes
Input Y
255not(rand(3)pxl-Test(Y,Ans

Takes one integer from Ans and one from the prompt. rand(3) creates a list of 3 nonzero random numbers, so the product is zero iff the pixel is dark.

Bash + coreutils + scrot + netpbm, 90 bytes
scrot -e'pngtopnm $f'|(read a;read w h;read m;head -c$((3*(w*$2+$1)))>f;od -t u1 -N3 -An;)
Loose I/O version
Takes x and y as separate command-line arguments.
Prints r, g, b as ints from 0-255 on separate lines

Bash + coreutils + scrot + netpbm + bc + sed, 172 bytes
IFS=, read x y
scrot -e'pngtopnm $f'|(read a;read w h;read m;head -c$((3*(w*$y+$x)))>f;od -vw1 -tu1 -N3 -An|while read p;do bc<<<"scale=2;$p/$m"|tr '\n' ,;done;)|sed s/,$//
Strict I/O version
Input on stdin as x,y
Output on stdout as r.rr,g.gg,b.bb (no newline).

@Shaggy not anymore -- see the updates

source: Stack Exchange

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

sort: votes


text:
"As we travel the universe..."
You'll be given the name of one of the 20 biggest objects in the Solar System. Your task is to return an approximation of its radius, expressed in kilometers.
This is a code-challenge where your score consists of the length of your code (in bytes) multiplied by a penalty ratio \$\ge 1\$, based on your worst approximation. Therefore, the lowest score wins.
"As we travel the universe" is the last line of the song Planet Caravan by Black Sabbath, also later covered by Pantera.
The Solar System objects
Source: Wikipedia
NB: The rank is given for information only. The input is the name of the object.
  n | Object   | Radius (km)
----+----------+-------------
  1 | Sun      |   696342
  2 | Jupiter  |    69911
  3 | Saturn   |    58232
  4 | Uranus   |    25362
  5 | Neptune  |    24622
  6 | Earth    |     6371
  7 | Venus    |     6052
  8 | Mars     |     3390
  9 | Ganymede |     2634
 10 | Titan    |     2575
 11 | Mercury  |     2440
 12 | Callisto |     2410
 13 | Io       |     1822
 14 | Moon     |     1737
 15 | Europa   |     1561
 16 | Triton   |     1353
 17 | Pluto    |     1186
 18 | Eris     |     1163
 19 | Haumea   |      816
 20 | Titania  |      788

Or as copy-paste friendly lists:
'Sun', 'Jupiter', 'Saturn', 'Uranus', 'Neptune', 'Earth', 'Venus', 'Mars', 'Ganymede', 'Titan', 'Mercury', 'Callisto', 'Io', 'Moon', 'Europa', 'Triton', 'Pluto', 'Eris', 'Haumea', 'Titania'
696342, 69911, 58232, 25362, 24622, 6371, 6052, 3390, 2634, 2575, 2440, 2410, 1822, 1737, 1561, 1353, 1186, 1163, 816, 788

Your score
Let \$R_n\$ be the expected radius of the \$n^{th}\$ object and let \$A_n\$ be the answer of your program for this object.
Then your score is defined as:
$$S=\left\lceil L\times\max_{1\le i \le20}\left({\max\left(\frac{A_i}{R_i},\frac{R_i}{A_i}\right)^2}\right)\right\rceil$$
where \$L\$ is the length of your code in bytes.
Example:
If the size of your code is \$100\$ bytes and your worst approximation is on the Moon with an estimated radius of \$1000\$ km instead of \$1737\$ km, then your score would be:
$$S=\left\lceil 100\times{\left(\frac{1737}{1000}\right)^2}\right\rceil=302$$
The lower, the better.
Recommended header for your answer:
Language, 100 bytes, score = 302

You can use this script to compute your score (first line = code length, next 20 lines = your outputs, from Sun to Titania).
Rules

You may take the name of the object in either full lowercase, full uppercase or exactly as described above (title case). Other mixed cases are not allowed.
The input is guaranteed to be one of the 20 possible names.
You may return either integers or floats. In both cases, the penalty must be computed directly with these values (not rounded values in case of floats).
You must return positive values.
Empty programs are not allowed.

Sandbox (now deleted). Thanks to all who provided feedback, and especially xnor for helping fix the scoring formula.

I see the scoring has been changed to the power of 2 for the diff? In that case my 100-byte exact answer is shorter than my 70-byte approximation (which scored 91 before, but now 117..)

@KevinCruijssen The idea behind that was to prevent extremely short answers (basically returning 1 or 2 constants) to be penalized by a reasonable factor and potentially win against more sophisticated ones.

I approve of the square in the scoring function. My previous best result was a score of 60 using 2 bytes to get 7512 for all test cases. I'll see if I dive into creating a MathGolf solution anytime soon, but it'll be hard to beat 05AB1E.

@maxb You'll have to beat Jelly's score of 37, not 05AB1E's score of 60 ;p

Isn't there still a problem with the scoring method if the program returns a large negative number? For example, if A=-1e99 then Max(A/R,R/A) would be a very small -ve number. In that way you could get an arbitrarily small score. Problem would be solved with Max(|A/R|,|R/A|)

@Penguino This is why "you must return positive values".

PowerShell, 3 bytes, score 3637
2e4

Try it online!
Very naive, boring, implementation; just returns 20000 no matter the input. Experimentation with things like special-casing the sun or using floating-point values instead of 2 all resulted in worse scores because the length of code increased enough to offset any size-comparison gains.

That's all you need to know about KPI :)

Why is this getting so many votes?!

For reference, the constant that gives the best ratio appears to be 23425 but scores a cool 4419

@Shaggy I'm confused about that as well.. :S It's by far the laziest and highest scoring answer (don't take it personal AdmBorkBork, but I think the Jelly and Java answers deserve the upvotes a lot more). People probably only see the 3 bytes part (or think higher score is better than lower) and ignore everything else. xD In Arnauld's original challenge description in the Sandbox, this answer wouldn't even have been possible, since it allowed a maximum error percentage of 95% for each I/O. Ah well. Enjoy the free rep AdmBorkBork. ;)

It does fit the question's criterias though. I think people vote it because it's so obvious, many wouldn't have thought about it. It also denotes a challenge with a flawed rating system, if it can be abused that way.

@Elcan Or more precisely, it denotes that the rating system is not flawed, given that the resulting score is so high.

@Arnauld The only flaw I see is the fact that the lowest wins. Number of bytes should be low, but score should be high (at least in most people mind's).

@Arnauld Yeah, the scoring isn't clear, I thought the highest was better, nvm then

People upvote on PPCG for all sorts of reasons, not just because of raw score (see my huge Minecraft redstone answer for example). I upvoted this answer because it is a clear, simple example of the far end of the spectrum of strategy (the spectrum between "return exact values" vs "save bytes to return an approximation and take the penalty").

I agree with Brad. It might be a bad score, but the fact that the scoring system allows it means that this short, inaccurate, answer is still valid.

See a similar (archived) discussion on this top-voted answer in the "Moby Dick" challenge that returns only a space. The point is that these serve as simple outer boundaries. I do something similar for "output this text" challenges; I always start with a trivial PRINT (text) version so I have something to improve upon.

Jelly, 34 bytes, score = 37
OḌ“⁸|5/!‘%ƒị“RNFLOJMjs⁽\u[USJ‘1.1*

Input is in uppercase, output is the power of 1.1 with the least error.
Try it online!
How it works
OḌ“⁸|5/!‘%ƒị“RNFLOJMjs⁽\u[USJ‘1.1*  Main link. Argument: s (string)

O                                   Ordinal; map the char in s to their code points.
                                        "ERIS" -> [69,82,73,83]
 Ḍ                                  Undecimal; treat the result as an array of digits
                                    in base 10 and convert it to integer.
                                        [69,82,73,83] -> 69000+8200+730+83 = 78013
  “⁸|5/!‘                           Literal; yield [136, 124, 53, 47, 33].
         %ƒ                         Fold the array by modulus, using the computed
                                    integer as initial value.
                                        78013 -> 78013%136%124%53%47%33 = 32
            “RNFLOJMjs⁽\u[USJ‘      Literal; yield [82, 78, 70, 76, 79, 74, 77, ...
                                    106, 115, 141, 92, 117, 91, 85, 83, 74].
           ị                        Retrieve the element from the array to the right,
                                    at the index to the left.
                                    Indexing is 1-based and modular.
                                        32 = 16 (mod 16) -> 'J' = 74
                              1.1*  Raise 1.1 to the computed power.
                                        74 = 1.1**74 = 1156.268519450066

Java (JDK), 90 bytes, score = 97
s->("ýCĄ (ᬺ!˂Fɍ".charAt(s.substring(2).chars().sum()%96%49%25)-7)*100

Try it online!

This entry uses both undisplayable and multi-byte Unicode characters (but Java accepts them nevertheless). Check the TIO for the accurate code.
The input must be title-case.
This code rounds the values to the best multiple-of-100 (sometimes up, sometimes down) so that the last two digits can be skipped when encoded, and the value can then be approximated by multiplying by 100.
This entry uses various hashes to fit a 25 codepoints string (shortest string I could find).

Credits

-48 score (-45 bytes) thanks to Kevin Cruijssen by encoding the radiuses (divided by 100) directly in a String instead of hardcoding them in an explicit int array..

96 bytes & 103 score with the same output.

Thanks @KevinCruijssen! That's a nice golf, using unicode characters in a string instead of an array of decimal values. :-)

Glad I could help, and nice answer! :) PS: As for why I added the (...-7): The unprintable character (char)0 is empty so I had to add something. I first tried 9 and 8 being single digits, but 9 gave of course tabs, requiring multiple \t (2 bytes each), and 8 gave an error about an unescaped character used.

@KevinCruijssen To be honest, I tried for a few hours yesterday to get better values by expanding your multiplication into  *100-700 and playing with the values-as-string and those two numbers, but those are the best, actually, Some values can decrease the byte count, but then the score stays the same. So random pinpointing made (one of) the best case ;)

Talk about undisplayable! This entry really weirds out my Firefox to the point that I can't actually read the rest of the page properly :-(

@Neil Sorry, I don't know what to say... This is working fine with my Firefox (latest version, which currently 63.0)

I was using 64.0b12, but I just tried 64.0b14 and the problem seems to have been fixed there. Sorry for the false alarm.

@Neil Just FYI, it seems like the problem is back on 64.0.2.

@Arnauld Ah, well, I'm already on 65.0b6, which seems OK, so...

Wolfram Language 114 103 97 88 86 82 bytes. score = 114 103 97 89 87 83 points
(#&@@EntityValue[Interpreter["AstronomicalObject"]@#,"Radius"]/._String->507)1.61&

At least 6 points saved thanks to Dennis, several more thanks to lirtosiast, and 6 more thanks to user202729.
Although Mathematica can fetch solar system data (as well as much additional astronomical data), some minor tweaks are needed, as explained below.
Interpreter[#,"AstronomicalObject"]& will return the entity (i.e. the machine computable object) associated with the term represented by #.
EntityValue[AstronomicalObject[],"Radius"] returns the radius, in miles, of the entity.  In the case of "Haumea", the value, 816.27 (i.e. 507*1.61), is returned.
Multiplication of the radius by 1.61 converts from miles to km. Decimal values, rather than integers, account for much less than 1% error, even in the most extreme case.
[[1]] returns the magnitude without the unit, km. This was later changed to #&@@, yielding the same result.

Another wolfram built in. Just like detecting downgoats

I would've answered this but I don't know the wolfram language lol

Actually, this requires internet connection too (tested on 10.2)

@user202729, Your last two, helpful, suggestions are now integrated.  Use of curated entities, such as astronomical bodies, does indeed require internet connection.

@user202729 Built-in datasets are allowed, even if they have to be downloaded.

@den I know, but this one cannot be "reused after downloaded".

Ugh, it's default units for radius are miles? At least it has sane (i.e. metric) default units for mass...

Python 3, score 95, 95 bytes
lambda n:ord("ؙҢਏാᣣ४ঈ挒ឤ?̰ҋ??ۉՉ怮ܞ੊̔"[int(n,35)%87%52%24-1])

Try it online!

Python 3, score 133, 133 bytes
lambda n:int(f'00e0{10**18+10**6}10x1h2411j4?00??811i1207wazxmwuvko?mw??xc1ze1ldyujz6zysi4?ob??k9lym6w'[int(n,35)%87%52%24-1::23],36)

Try it online!

Powershell, 150 141 bytes, score 163 153
($args|% t*y|?{'Su6963J699S582U253N246Ea63V60Ma33G26Ti25Me24C24I18M17Eu15T13P12E12H8Titani8'-cmatch"$(($y+=$_))(\d+)"}|%{100*$Matches.1})[-1]

Try it online!
Test script:
$f = {
($args|% t*y|?{'Su6963J699S582U253N246Ea63V60Ma33G26Ti25Me24C24I18M17Eu15T13P12E12H8Titani8'-cmatch"$(($y+=$_))(\d+)"}|%{100*$Matches.1})[-1]
}

$penalty = @(
    ,("Sun"      , 696342)
    ,("Jupiter"  ,  69911)
    ,("Saturn"   ,  58232)
    ,("Uranus"   ,  25362)
    ,("Neptune"  ,  24622)
    ,("Earth"    ,   6371)
    ,("Venus"    ,   6052)
    ,("Mars"     ,   3390)
    ,("Ganymede" ,   2634)
    ,("Titan"    ,   2575)
    ,("Mercury"  ,   2440)
    ,("Callisto" ,   2410)
    ,("Io"       ,   1822)
    ,("Moon"     ,   1737)
    ,("Europa"   ,   1561)
    ,("Triton"   ,   1353)
    ,("Pluto"    ,   1186)
    ,("Eris"     ,   1163)
    ,("Haumea"   ,    816)
    ,("Titania"  ,    788)
) | % {
    $s,$expected = $_
    $result = &$f $s
    $ratio = [Math]::Max($result/$expected, $expected/$result)
    $ratio*$ratio
}
$scriptLength = $f.ToString().Length - 2  # -4 if CRLF mode
$penaltyMax = ($penalty|Measure-Object -Maximum).Maximum
$score = $scriptLength * $penaltyMax
"$score = $scriptLength * $penaltyMax"

Output:
152.731283431953 = 141 * 1.08320059171598

Explanation:

Names contain letters only, radiuses contain digits and dots. So we can write all the data in a data string and perform a regexp search.
The script searches for all substrings from left to right and takes the last result found.
The input must be title-case to reduce the data string.
The end of line mode is LF only.

Example:
Titania         Triton         Titan
--------------  -------------  -------------
T       -> 1.3  T      -> 1.3  T      -> 1.3
Ti      -> 2.5  Tr     ->      Ti     -> 2.5
Tit     ->      Tri    ->      Tit    ->
Tita    ->      Trit   ->      Tita   ->
Titan   ->      Triton ->      Titan  ->
Titani  -> .8
Titania ->

Result is .8    Result is 1.3  Result is 2.5

Powershell, 178 bytes, score 178
($args|% t*y|?{'Su696342J69911S58232U25362N24622Ea6371V6052Ma3390G2634Ti2575Me2440C2410I1822M1737Eu1561T1353P1186E1163H816Titani788'-cmatch"$(($y+=$_))(\d+)"}|%{+$Matches.1})[-1]

05AB1E, score 100 66 60 56 (100 61 56 52 bytes)
•1∞²îc|I‰∍T‡sÇ3¡ò½в…»Ë••1ë£ñƒq£û¿’…•S£I¦¦ÇO96%49%èт*

Port of @OlivierGrégoire's Java answer, so if you like this first answer, make sure to upvote him as well!
Input in titlecase.
Verify all test cases.

05AB1E, score 100 99 (100 99 bytes)
•*Òâ%ÌÜS…Ùb‹Úi{e!]É¸·vÌBUSηHã£āðxyµŠ••3«8¹ØмS7Ç•S£.•WùηƵ@,Sº,ûεβʒóÃX\¹Θäáá’Ý)”Ωož∞-z.A±D•3ôI2£Iθ«kè

Input in full lowercase. Outputs the exact radius, so no penalty is added.
Verify all test cases.
Explanation:
•*Òâ%ÌÜS…Ùb‹Úi{e!]É¸·vÌBUSηHã£āðxyµŠ•
                 # Compressed integer 696342699115823225362246226371605233902634257524402410182217371561135311861163816788
 •3«8¹ØмS7Ç•     # Compressed integer 65555444444444444433
  S              # Converted to a list of digits: [6,5,5,5,5,4,4,4,4,4,4,4,4,4,4,4,4,4,3,3]
   £             # The first integer is split into parts of that size: ["696342","69911","58232","25362","24622","6371","6052","3390","2634","2575","2440","2410","1822","1737","1561","1353","1186","1163","816","788"]
    .•WùηƵ@,Sº,ûεβʒóÃX\¹Θäáá’Ý)”Ωož∞-z.A±D•
                 # Compressed string "sunjursanursneeeahvesmasgaetinmeycaoioomoneuatrnploershaatia"
     3ô          # Split into parts of size 3: ["sun","jur","san","urs","nee","eah","ves","mas","gae","tin","mey","cao","ioo","mon","eua","trn","plo","ers","haa","tia"]
       I2£       # The first two characters of the input
          Iθ     # The last character of the input
            «    # Merged together
             k   # Get the index of this string in the list of strings
              è  # And use that index to index into the list of integers
                 # (and output the result implicitly)

See this 05AB1E tip of mine (sections How to compress large integers? and How to compress strings not part of the dictionary?) to understand how the compression used works.

I found a better hash that use a 25-chars string instead of a 30-chars one. Check my Java answer if you want to update this answer ;)

@OlivierGrégoire Thanks for the heads-up. -6 score and -7 bytes. :)

Mathematica, 57 bytes, score = 62 58
-4 bytes/score thanks to lirtosiast!
#&@@WolframAlpha[#<>" size km","Result"]]/._Missing->816&

Just does a Wolfram Alpha lookup for the mean radius.

Hmm. Doesn't this count as using the internet? Unless Mathematica actually does contain the entire WolframAlpha engine

@ASCII-only I mean, Mathematica's datasets are allowed, and the WolframAlpha function has been used at least four times...

Hmm. Seems kinda like an arbitrary decision, what's stopping other languages from adding search engine functions? IMO datasets are a bit different - downloading all of them is just so massive that a central server gives it to you when needed

@ASCII-only If you're worried, you can always post a question on Meta.

@leg In that case the data can be used offline after downloading. In this case, it's not.

Jelly, 28 bytes, score = 31
“__ʋ7ṗ“RUu⁽NM\sOSJj[FL‘ḥ1.1*

This uses a configurable hashing built-in that I added to Jelly at @lirtosiast's suggestion.
Input is in titlecase, output is the power of 1.1 with the least error.
Try it online!
How it works
This answer consists of merely two parts.

First, “__ʋ7ṗ“RUu⁽NM\sOSJj[FL‘ḥ uses the new built-in to map each of the 20 possible inputs to 15 different integers.
Then, 1.1* elevates 1.1 to the computed power.

“__ʋ7ṗ“RUu⁽NM\sOSJj[FL‘ is a literal; every non-quote character is replaced by it's 0-based index in Jelly's code page, yielding \$[95, 95, 169, 55, 242], [82, 85, 117, 141, 78, 77, 92, 115, 79, 83, 74, 106, 91, 70, 76]\$.
The hashing built-in ḥ first maps \$[95, 95, 169, 55, 242]\$ to an integer by incrementing each number, then treating the result as the bijective base-250 digits integer and adding \$1\$. This yields \$376510639244\$.
By halving and flooring this integer until the result is \$0\$, we get the sequence \$[376510639244, 188255319622, 94127659811, 47063829905, \dots, 5, 2, 1, 0]\$, which has the forward differences \$[188255319622, 94127659811, 47063829906, \dots, 3, 1, 1]\$.
Next, we generate 64 64-bit integers by applying SHAKE256-4096 to the string representation of the internal representation of ḥ's right argument, then chopping the resulting 4096 bits into 64 64-bit chunks.
ḥ now computes the dot product of the 39 differences and the first 39 generated 64-bit integers, modulo \$2^{64}\$. This yields an integer in \$[0, 2^{64})\$.
The list \$[82, 85, 117, 141, 78, 77, 92, 115, 79, 83, 74, 106, 91, 70, 76]\$ has length 15, so we multiply the generated integer by 15 and take the 64 higher bits of the result. This yields an integer in \$[0, 15)\$, which we use to index into the list.
To find the appropriate hash configuration, I've used a brute-forcer in C that is part of the Jelly repo.

Python 2, 155 bytes, score = 155
lambda p:int('G11KK54222111111XXNM8MCO37WQ53YXHE93V8BIF2IMH1WU9KPU2MLN    HGR'['uSJJaSrUNNrEnVsMeGtTMMoCoInMuErTuPsEaHTT'.find(p[7%len(p)]+p[0])/2::20],35)

Try it online!
Surprisingly well for this lazy solution... will look into improving as well. ;-)

Japt, 86 bytes, score = 94
g5 ¥'i?788:[7*A³7*L6*LG²G²IIÉHÄDÑDÑCÑCÑGÄÄGÄGECC8]g`suj«a¨Ì¼và@ã/eÖô¶e©rp¤r`bU¯2)z)*L

Try it for all inputs, Calculate the score, or Check the highest error
Very similar to Olivier's original answer. Input is all lowercase.
After various improvements to the output values, the current highest error is Venus at just over 4%.
Explanation now that things are a bit more stable:
¤¥`Éa`?                             :If the fifth character of the input is 'i':
       788                          : Output 788.
          :                         :Otherwise:
           [...]                    : From the array representing radii
                g                   : Get the value at the index:
                 `...`              :  In the string representing names
                      b             :  Find the first index where this string appears:
                       U¯2)         :   The first two characters of the input
                           z)       :  And divide it by two
                             *L     : Multiply that value by 100

The string for the names is sujusaurneeavemagatimecaiomoeutrplerha compressed using Japt's built-in compression. The numbers representing the radii are calculated like so:
                          My value | Actual value
                          ---------+-------------
7 * 10 ^ 3 = 7000 * 100 =   700000 | 696342
7 * 100    = 700  * 100 =    70000 |  69911
6 * 100    = 600  * 100 =    60000 |  58232
16 * 16    = 256  * 100 =    25600 |  25362
16 * 16    = 256  * 100 =    25600 |  24622
64         = 64   * 100 =     6400 |   6371
64 - 1     = 63   * 100 =     6300 |   6052
32 + 1     = 33   * 100 =     3300 |   3390
13 * 2     = 26   * 100 =     2600 |   2634
13 * 2     = 26   * 100 =     2600 |   2575
12 * 2     = 24   * 100 =     2400 |   2440
12 * 2     = 24   * 100 =     2400 |   2410
16 + 1 + 1 = 18   * 100 =     1800 |   1822
16 + 1     = 17   * 100 =     1700 |   1737
16         = 16   * 100 =     1600 |   1561
14         = 14   * 100 =     1400 |   1353
12         = 12   * 100 =     1200 |   1186
12         = 12   * 100 =     1200 |   1163
8          = 8    * 100 =      800 |    816
788                     =      788 |    788

Japt, 77 76 75 bytes, score = 75
First pass at this; I wanted to try a 0 penalty solution to give myself a baseline to work off. Will come back to it tomorrow to see what improvements can be made, hopefully still for 0 penalty.
Input is case-insensitive.
n35 %87%52 g"..."ò)mc

Try it or test all inputs
The "..." represents a string containing many unprintables. The codepoints are:
32,32,15,61,11,86,696,342,25,75,699,11,33,90,63,71,24,10,24,40,253,62,60,52,32,32,8,16,11,63,32,32,32,32,58,232,17,37,135,3,246,22,18,22,26,34,7,88

To offer a quick explanation: the string gets split into chunks of 2 characters. We then index into that array using part of ovs' formula plus some index-wrapping and then map the 2 characters to their codepoints.

Saved a byte/point thanks to ETH

54 bytes, score = 58
A port of Olivier's solution.
"ýCĄ (ᬺ!˂Fɍ"cU¤¬xc %96%49)-7 *L

Test all inputs

I think you can save a byte by moving the first entry (#23) to the end where it belongs, and removing the %24 :-)

@ETHproductions, that doesn't seem to work

Here's what I was thinking

@ETHproductions: Ah, yes, just twigged myself that I'd need to add a placeholder element to the start of the array. Thanks.

T-SQL, 203 202 201 196 bytes, score = 217 216 212 208
SELECT IIF(v='Titan',13,STUFF(value,1,2,''))*198
FROM i,STRING_SPLIT('Ca12,Ea32,Er6,Eu8,Ga13,Ha4,Io9,Ju353,Ma17,Me12,Mo9,Ne124,Pl6,Sa294,Su3517,Ti4,Tr7,Ur128,Ve31',',')
WHERE LEFT(v,2)=LEFT(value,2)

Line breaks are for readability only.
Input is taken via pre-existing table i with varchar column v, per our IO standards.
Joins the input table to an in-memory table on the first two characters, and returns the remaining digits x100.
Treats "Titan" as a special case using IIF.
EDIT: Saved 1 byte (and 1 point) by using STUFF to erase the first two characters instead of SUBSTRING. Thanks, t-clausen.dk!
EDIT 2: I wanted to see what would happen if I tried to save another byte by multiplying each lookup value by 99 instead of 100, and found to my surprise that it actually increased the accuracy (of the least accurate estimate)!.
This led me to some trial and error testing, and some fancy Excel what-if data tables, where I found an optimal solution using a multiplier of 89 (which of course changed all my stored values).
So while this saves me only one byte, it actually improves my score by 4.6 from my prior solution.
EDIT 3: Searched higher instead of lower, and found an even better multiplication factor, 198. Values stay reasonably accurate while shortening my stored string by quite a few characters, which improves my score.

You can save 1 byte using STUFF(value,1,2,'') instead of substring

Ruby, 105 bytes, score 109
->n{7E5/('!)"0 r&zZ&1#}3Mfh-~~d@'[0,j=" =1&%)AM<I>2,-B#($D  7@".index((n[1,9].sum%50+34).chr)].sum-j*32)}

Try it online!
If we divide 700000 by the radii, we get a sequence which increases reasonably linearly (though rather erratically). The increments in the table below can be approximated by the ASCII values of characters. The problem with this approach is it requires the input to be decoded to a value which orders the different names by size.
A minor issue is that the difference between Eris and Haumea is quite large. Three characters ~~d are required to encode this increment in ASCII only format. The planet-to-index string has two "ghost planet"spaces in it to pad the index.
700000/r    increment from previous
0.994774
9.960407    8.965633
11.95806    1.997657
27.45612    15.49805
28.28129    0.825178
109.2987    81.0174
115.0598    5.761118
205.4106    90.3508
264.3667    58.95612
270.4241    6.057335
285.3861    14.96199
288.9386    3.552524
382.1855    93.24692
400.8877    18.70223
446.0871    45.19939
514.6652    68.57806
587.1349    72.46972
598.7463    11.61144
853.3603    254.6139
883.6827    30.32245

PowerShell, 203 bytes, score 203
param($a)if($a-eq'Titan'){2575;exit}(696342,69911,58232,25362,24622,6371,6052,3390,2634,2440,2410,1822,1737,1561,1353,1186,1163,816,788)["SuJuSaUrNeEaVeMaGaMeCaIoMoEuTrPlErHaTi".indexOf(-join$a[0..1])/2]

Try it online!
Very similar to Olivier's answer, now that I see it, but developed independently.

Swift 4, 225 bytes, score = 241
Probably golfable a bunch more (maybe in the "Ga-Me-Ca" area?), but Swift is not often used (for a reason, maybe.)
func b(i:String){print(i=="Titan" ?2575:["Su":6963,"Ju":699,"Sa":582,"Ur":253,"Ne":246,"Ea":63,"Ve":60,"Ma":33,"Ga":26,"Me":24,"Ca":24,"Io":18,"Mo":17,"Eu":16,"Tr":14,"Pl":12,"Er":12,"Ha":8,"Ti":8][String(i.prefix(2))]!*100)}

and ungolfed
func size(ofAstralObject object: String) {
  let objectToRadius = // Map size/100 of all objects to the first two chars
   ["Su":6963,
    "Ju":699,
    "Sa":582,
    "Ur":253,
    "Ne":246,
    "Ea":63,
    "Ve":60,
    "Ma":33,
    "Ga":26,
    "Me":24,
    "Ca":24,
    "Io":18,
    "Mo":17,
    "Eu":16,
    "Tr":14,
    "Pl":12,
    "Er":12,
    "Ha":8,
    "Ti":8] // Ti is Titania, while Titan is treated differently

  print(object == "Titan" ?
    2575 : // If "Titan", print the exact size
    objectToRadius[String(i.prefix(2))]!*100 // get the size from the map and multiply by 100
  )
}

Try It Online!
I tried different "key sizes" for the map, but of course 1 has many clashes and using three chars doesn't give me i=="Titan" ?2575:'s 17 chars, since there's "Io" to manage (and it'll take more than 3 chars, I think).

Charcoal, 101 bytes, score = 101
Ｉ⍘§⪪“_″FJ⁼⦄b\l≕)Ｔ‹#⊙xO-nη⁻À↓ζ↥ς§%Ｈ8H“ρj✳Hρl× S↶…|ＵＤ⎇ＬkfZ”³⌕⪪”@/rjmq_↙§Ｅ▶νＦ↨oº⁷÷Ｋ⁻eDH:_Tbk¦�”²⁺§θ⁰§θχγ

Try it online! Link is to verbose version of code. Explanation:
⁺§θ⁰§θχ

Take the 1st and 11th character (cyclically) of the input string and concatenate them.
⌕⪪”@/rjmq_↙§Ｅ▶νＦ↨oº⁷÷Ｋ⁻eDH:_Tbk¦�”²

Look them up in the string SuJiSrUuNtEEVVMrGnTTMcClIIMoEpToPPEiHeTa split into pairs of characters.
§⪪“_″FJ⁼⦄b\l≕)Ｔ‹#⊙xO-nη⁻À↓ζ↥ς§%Ｈ8H“ρj✳Hρl× S↶…|ＵＤ⎇ＬkfZ”³

Split the string m.w'fv&J|\"l|\"e1 c& _c Ca ;e ;* 9a 9C 31 2; 0I .7 ,N ,7 (X (< into groups of three characters and take the corresponding group.
Ｉ⍘ ... γ

Decode the result as a base-95 number using the printable ASCII character set as the digits. Example: Io's 11th character is I, so we look up II and find it's the 13th largest object and its size is 31 which maps to 19 * 95 + 17 = 1822.

JavaScript (ES6), 152 bytes, score = 163
Well, it's a pretty standard solution, but I enjoyed the challenge anyway!
s=>s=='Titan'?2575:[6963,699,582,254,246,64,60,34,26,24,24,18,17,16,14,12,12,8,8]["SuJuSaUrNeEaVeMaGaMeCaIoMoEuTrPlErHaTi".match(s[0]+s[1]).index/2]*100

My Score:
Max. penalty ratio = 1.07068 for Triton
Score = ceil(152 x 1.07068) = 163

Try it Online!

FALSE, 152 bytes, Score = 563
[911*.]^$0\[~][1+^]#$$2=\$4=\8=||[2 0!]?$3=[764 0!]?$5=[\$$69=\86=|$[6\]?~[2]?0!]?$6=[\$$83=\85=|$[46\]?~[$72=$[1\]?~[2]?]?0!]?$7=[\$84=$[1\]?~[52]?0!]?

Lazy answer using word lengths and first letters but my excuse is that I'm using a weird language
Try it online! (copy paste the code, hit show and then run)
[911*.]          {defines a function that multiplies a number by 911 and then prints it}
^$0\[~][1+^]#    {counts the length of the name as it's input, also records the first char}
$$2=\$4=\8=||[1 0!]?  {if the name is 2, 4, or 8 chars long print 911*2 (0! calls the function)}
$3=[764 0!]?          {if name is 3 long print 911*764}
$5=[\$$69=\86=|$[6\]?~[2]?0!]? {5 long? print 911*6 if it starts with E or V, otherwise *2}
$6=[\$$83=\85=|$[46\]?~[       {6 long? print 911*46 if it starts with S or U, otherwise:}
    $72=$[1\]?~[2]?            {if name starts with H print 911*1 else *2
]?0!]?
$7=[\$84=$[1\]?~[26]?0!]?      {7 long? print 1822*1 if it starts with NT otherwise *26 (for jupiter}

My results:
Sun       : 696004.00 penalty ratio = (696342.00 / 696004.00 )² = 1.00097
Jupiter   : 47372.00  penalty ratio = (69911.00  / 47372.00  )² = 2.17795
Saturn    : 41906.00  penalty ratio = (58232.00  / 41906.00  )² = 1.93095
Uranus    : 41906.00  penalty ratio = (41906.00  / 25362.00  )² = 2.73014
Neptune   : 47372.00  penalty ratio = (47372.00  / 24622.00  )² = 3.70166
Earth     : 5466.00   penalty ratio = (6371.00   / 5466.00   )² = 1.35855
Venus     : 5466.00   penalty ratio = (6052.00   / 5466.00   )² = 1.22591
Mars      : 1822.00   penalty ratio = (3390.00   / 1822.00   )² = 3.46181
Ganymede  : 1822.00   penalty ratio = (2634.00   / 1822.00   )² = 2.08994
Titan     : 1822.00   penalty ratio = (2575.00   / 1822.00   )² = 1.99737
Mercury   : 1822.00   penalty ratio = (2440.00   / 1822.00   )² = 1.79342
Callisto  : 1822.00   penalty ratio = (2410.00   / 1822.00   )² = 1.74959
Io        : 1822.00   penalty ratio = (1822.00   / 1822.00   )² = 1.00000
Moon      : 1822.00   penalty ratio = (1822.00   / 1737.00   )² = 1.10026
Europa    : 1822.00   penalty ratio = (1822.00   / 1561.00   )² = 1.36236
Triton    : 1822.00   penalty ratio = (1822.00   / 1353.00   )² = 1.81343
Pluto     : 1822.00   penalty ratio = (1822.00   / 1186.00   )² = 2.36008
Eris      : 1822.00   penalty ratio = (1822.00   / 1163.00   )² = 2.45435
Haumea    : 911.00    penalty ratio = (911.00    / 816.00    )² = 1.24640
Titania   : 911.00    penalty ratio = (911.00    / 788.00    )² = 1.33655

Max. penalty ratio = 3.70166 for Neptune
Score = ceil(152 x 3.70166) = 563

It seems like the optimal multiplier for your current code is $1634$.

I updated it to use half of 1822 (911) instead to I could make a special case for Haumea, so this advice doesn't work anymore. I tried using 817 (half of 1634) but it wasn't good. If you want to work your magic and find the new most optimal number feel free.

C (gcc), 118 bytes, score = 135
i;f(char*s){i=exp((strchr("(~?_q#m#.(`(=*2,r-v.h2z2p3d3j6>Qb>a?{Qx]",(*s^s[1]*4)+(strlen(s)!=5)&127|32)[1]+55)/13.5);}

Try it online!
Scoring
Rundown
The object name is turned into a single-character hash through the cumbersome process
(((*s ^ s[1] << 2) + (strlen(s) != 5)) & 127) | 32

whose bloat points to "Titan"/"Titania" as the main offenders. Including the last character in the hash was considered, but that still requires a strlen() in C. The first occurence of the hash character is searched for in the hash/data string. When found, the next character is taken and used to approximate the radius of the object in question.
The data character holds the shifted, scaled natural logarithm of the radius. Generated like so:
for (int i = 0; i < 20; i++)
    data[i] = log(radii[i]) * 13.5 - 55;

The scale was chosen through highly scientific trial-and-error, and the shift for bringing the value within printable ASCII range while avoiding backslashes. Some rearrangement of the objects in the string was necessary due to some hash/data collisions.
i;                                      Return value
f(char*s){                              s is object name
    i=                                  Implicit return
    exp(                                Raise e to some power
        (
            strchr(                     Find hash
                "...",                  Hash/data string
                (*s^s[1]*4)+            Calculate...
                (strlen(s)!=5)&127|32   ...hash
            )
            [1]                         Char following hash holds the power
            +55                         Shift it
        )/13.5                          Scale it
    );                                  Use it
}                                       Exit

Python 2, 89 bytes, Score = 234
lambda(p):39**4/'zzuSJJaSrUNNrEnVsMeGtTMMoCoInMuErTuPsEaHTT'.find(p[7%len(p)]+p[0])**2.18

Try it online!
Most answers posted appear to have used a "encode/decode" strategy.  I wondered how well I could do by estimating the diameter of celestial bodies using a simple equation.  It's been a fun exercise, but the moderate byte savings are more than made up for by the accuracy penalty.
The core of this solution is the estimating equation:
Radius = 39**4/x**2.18

where x is twice the rank order of the radius of the body.
I generate the value of x based on the input string using a modification of @Erik the Outgolfer's Python 2 solution.  I saved a few bytes on his code by recasting my equations to work with [2..40] instead of [1..20].
The code for generating rank orders takes up more than 2/3 of the bytes of the whole solution.  If anyone has a more compact way of generating ranks, this solution could be shortened further.  Because of the accuracy penalty (around 2.6), the score would improve quite a bit.
Generating the Equation
I used statistical methods to search for simple equations to estimate the size of each body based on its rank.  In part following up on the insights in @Level River St's Ruby solution and generalizing, I settled on equations of the form:
Radius = A/(Rank)**B

Working in R, I used linear models on the log of the radii to develop initial estimates, and then used non-linear optimization, seeding the optimization with the results of the linear models, to search for solutions that minimized the penalty function specified in the problem.
The estimated value of A in the above equation is seven digits, so I searched for a simple expression to save a couple of bytes.  I  looked for expressions of the form
x**y

for two digit x and 1 digit y (for a total of five bytes, saving two bytes, or about five points, given the penalty) that was not too different from the optimum value of A and did not inflate the penalty much, and ended up with the (otherwise inexplicable):
39**4

The scoring algorithm really seems to hurt this method-- I'd guess that it would do better under L2 or L1 norm of error. Though you're wasting bytes storing the names anyway.

@lirtosiast  Agree to both points.  Interestingly, a least squares fit (L2 norm) is pretty good under this scoring algorithm too.  It has only about 5% worse penalty than the best equation I found. On storing the names : I could not figure out a more compact way to generate an ascending sequence of numbers from text input.  The modulo arithmetic approaches taken in other answers randomize the order.

TI-BASIC (TI-84), 285 bytes, Score = 285
Ans→Str1:{696342,69911,58232,25362,24622,6371,6052,3390,2634,2575,2440,2410,1822,1737,1561,1353,1186,1163,816,788:Ans(-int(-.125inString("SUN     JUPITER SATURN  URANUS  NEPTUNE EARTH   VENUS   MARS    GANYMEDETITAN   MERCURY CALLISTOIO      MOON    EUROPA  TRITON  PLUTO   ERIS    HAUMEA  TITANIA",Str1

A simple "index in string to list" program.  Can be golfed further.
Input is in Ans and is one of the objects' name in full uppercase.
Output is in Ans and is automatically printed out.
Example:
"MOON
MOON
prgmCDGFC
            1737
"IO
IO
prgmCDGFC
            1822

Explanation:
(Radii list and name string have been shortened for brevity. ... is used to indicate the rest of the list/string.)
Ans→Str1:{696342,69911,5...:Ans(-int(-.125inString("SUN     JU...",Str1  ;complete source

Ans→Str1                                                                 ;store the input string
                                                                         ; in "Str1"
         {696342,69911,5...                                              ;generate the list of
                                                                         ; radii and leave it in
                                                                         ; "Ans"
                                          inString("SUM     JU...",Str1  ;get the index of the
                                                                         ; input string in the
                                                                         ; name string
                                      .125                               ;multiply the index by 1/8
                                -int(-                                   ;then round it towards
                                                                         ; positive infinity
                            Ans(                                         ;use the result as the
                                                                         ; index of the radii list

Visual Model:
Ans→Str1                                            ;Ans = "MOON"
                                                    ;Str1 = "MOON"

{696342,69911,5...                                  ;Ans = {696232 69911 ... }
                                                    ;Str1 = "MOON"

inString("SUN      JU...",Str1                      ;Ans = {696232 69911 ... }
                                                    ;Str1 = "MOON"
                                                    ;current evaluation: 105

.125                                                ;Ans = {696232 69911 ... }
                                                    ;current evaluation: 13.125

-int(-                                              ;Ans = {696232 69911 ... }
                                                    ;current evaluation: 14

Ans(                                                ;Ans = 1737

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


text:
Find what a phrase with removed letters originally said in fewest characters
Write a program that, given a string of capital letters, output all possible phrases that could have been written originally, using any variant of the Oxford English Dictionary.
Input
There are two inputs:

A string \$s\$ of A-Z capital letters that is a phrase with certain letters removed. Example: THSSANEAMPLE
Another string \$r\$ of the letters that have been removed from said phrase. Example: IX. These letters are in no particular order.

Output
Output all phrases shorter than twice the length of \$s\$ which, after removing letters in \$r\$, result in \$s\$. Separate words in each phrase by spaces.
Rules

You are allowed to access any webpage you want, as long as it was created before this question was originally asked. If this webpage was changed in order to facilitate this challenge, then this is likewise not acceptable.
Slang or names of places or people are not required.
Disregard whether a phrase would be syntactically or grammatically correct.
Assume that any full word containing only omitted letters is not to be included.

Examples
"MITURE","X" should only have one possibility.
"MN", "DAI" should give you "MAN", but need not give "ADMIN", "MIND", or "DAMN" because they're at least twice as long as "MN".

I would recommend providing a specific dictionary for the programs to use. Otherwise different programs could end up working with different specifications.

"You are allowed to access any website you want, as long as it was created before this question was originally asked" - This still leaves the possibility of a website being created before this challenge, but updated afterwards. Also websites can change, breaking answers that were previously working. It's up to you what to allow, but allowing accessing websites can make it more difficult to write the spec in a robust way. If you're interested in alternative approaches, one way would be to specify a dictionary file and say "you may access this file" rather than a website.

Did my best to interpret, but I'm not sure (a) if the letters in r are a set or in some order, (b) whether we can output each phrase as a list of words. The dictionary issue mentioned above also needs fixing, especially since many languages have builtin English dictionaries that may or may not be "generally reputable".

It is also reasonable to specify that the answer can use any dictionary, as long as an arbitrary different dictionary can be substituted in the same number of bytes to load it, such as by taking the dictionary as a third parameter or loading it from a file.

Can you assume that you can not add full words to the phrase (if letter I is missing I can't just add the word I everywhere)?

While we have closed your question it is just because we think that it needs a bit more clarification before it is ready. I do think that it can be a very interesting challenge.

@fəˈnɛtɪk I have edited the question to fit criticism.

I found 160 possible solutions to your example. You might want to add an example with fewer solutions so that you can give people some input output pairs to test with. Solution: (this) (is/six) (an/((a/ax) nix)) (example/(exam pile/(pi (lie/lex)))/(ex ample/(amp (lie/lex))/(am/aim/((a/ax) mix) (pile/(pi (lie/lex)))

What constitutes slang?

@PostLeftGarfHunter Words created in the last 10 years or so or are in not common usage that tend to be used more frequently in speech than writing, or profanities.

@fəˈnɛtɪk My example was just to demonstrate what I meant, but I'll add another one.

@fəˈnɛtɪk Is the challenge acceptable now

Two questions: 1) Why websites? Not only does that make it a competition to find the shortest url providing a complete list of OED words, but it also takes dozens of popular languages out of the competition as networking and HTTP requests aren't terribly common (or golfy) built-ins. Typically,  the dictionary is provided as input.

2) Why restrict to upper-case only? Some languages may handle mixed-case or lower-case better.


text:
Algorithm to print the Minimum number of adjacent character swaps necessary to remove all instances of "VK" in a given string?
For example, how many adjacent swaps are at least needed to convert some string such as BVVKCV to one without any instances of VK?
Input-length of the string will be within the range 1 <= length <= 200.
VK will be hardcoded across all test cases.
Input string examples:
Input:  VKVKVVVKVOVKVQKKKVVK
Output: 8

Input:  VVKEVKK
Output: 3

Input:  JUSTIN
Output: 0

I've formatted your post a bit. As mentioned by @JoKing above, is the "vk" hard-coded, or given as second input? Also, you will need a winning criteria tag. [code-golf] is the most common one to use.

The "VK" is hard coded.

Lowercase vk or uppercase? Also, I'd recommend rewriting the title to something less "I need help with my homework" sounding

I would appreciate some more test cases =D

bvvkcv does not contain any instances of VK. Perhaps a test case like VKVKVKVK?

Suggested test case: KV => 0

This question seems really unclear... so I'm making character swaps to position Vs in front of Ks, so they can be removed as an ordered pair? Will I always have an equal number, or might I end up with extra Vs or Ks? Must I make all the swaps before removing anything? Or can I remove each VK as it appears, which reduces the number of letters in the way for remaining swaps?

@KamilDrakari Shouldn't that be 1?

@BradC My reading of the challenge is that the original string is only reordered using swaps until "VK" is not a substring of it. Characters are never removed. "VK" is not a substring of "KV" so no swaps are necessary.

@KamilDrakari Ohhh, that kind of makes sense? Still very unclearly worded.

Substring or subsequence? Should 'VXK' return 0 or 2?

@user202729 it should return 0

Japt, 44 bytes
m£Z¯Y cZtY2 Ô cZsY+2Ãrc
®¬ø"VK"
W+VÌ
Ve ?ß:W

Try it online!
It times out on the first test case because it's super inefficient (something like O(n^n)?) but it should be a viable algorithm. Input is weird; it is a singleton list containing the input, but the input itself is formatted as a list of upper-case characters. I think that would typically be valid, but if not let me know.
Explanation:
#Step 1: try all the swaps
m                          #For each string Z reachable with n swaps (n starts at 0)
 £                  Ã      # For each letter Y in Z:
  Z¯Y                      #  Get the letters before it in Z
      c                    #  Concat
       ZtY2 Ô              #  Y swapped with the following character
              c            #  Concat
               ZsY+2       #  The rest of Z
                     rc    #Flatten by one level
                           #Result: A list of all strings reachable with n+1 swaps

#Step 2: Check for "VK"
®¬         #For each string from Step 1:
  ø"VK"    # Check whether it contains "VK"
           #Result: A list where 1 indicates there was "VK" and 0 otherwise

#Step 3: Increment the counter appropriately
W+      #Increase the counter by
  VÌ    #The value for the original string when run through step 2
        #Result: 0 if 0 swaps were required, the current number of swaps otherwise

#Step 4: Iterate or end
Ve ?       #If all the reachable strings contain "VK"
    ß      # Repeat the program with the current values
     :W    #Otherwise return the counter
           #Result: Outputs the counter when a non-"VK" string is found.

A couple of quick savings to get you down to 44 bytes.

Python 3, 125 bytes
s={input()}
a=0
while all("VK"in q for q in s):a+=1;s={a[:i]+a[i+1]+a[i]+a[i+2:]for a in s for i in range(len(a)-1)}
print(a)

Try it online!
Basic BFS.