text:
JFor? More like XNor
As it turns out, Python allows for 1j for to be compressed to 1jfor. However, jfor sounds like xnor. Since all similar-phonic phrases have something in common, there must be some property shared between jfor and xnor.
If we look at the ASCII representation of the first two characters of jfor in binary, we see:
j:   1101010
f:   1100110
j&f: 1100010

Notice that the bitwise AND of j and f has a streak of 1s at the beginning, then some 0s, then a single 1.
Definition: A pair of numbers meets the JFor property iff their bitwise AND in binary meets the following regex (excluding leading 0s): /1+0+1+0*/ (1 or more 1s, followed by 1 or more 0s, followed by 1 or more 1s, followed by 0 or more 0s)
Do the ASCII codes for x and n meet the JFor property?
x:   1111000
n:   1101110
x&n: 1101000

Yes! So my hunch was correct; jfor and xnor sound similar, and they share a property (This means, of course, that odor must have that property too).
Task
Given a pair of numbers, determine if they meet the JFor property.
The two numbers may not be distinct, but they will both be integers from 0 to 255 respectively.
Output may follow your language's conventions for Truthy and Falsey, or you may choose any two consistent, distinct values to represent truthy and falsey respectively.
Your program/function may take input in any reasonable format to represent an ordered pair of integers/bytes.
Test cases
# Truthy:
106 102
110 120
42 26
17 29
228 159
255 253

# Falsey:
85 170
228 67
17 38
255 255
38 120
21 21

(Bounty: 50 rep to the shortest answer on July 24 if it somehow uses a XOR or XNOR operation; please mention if your submission qualifies)

102&70=70 -> 1000110 - isn't that truthy?

Also, I suggest a falsey case with more runs than required like 21 21.

@JonathanAllan Fixed; changed the 102 70 test case to 21 21

May we output one consistent value for truthy and any other value for falsey, or vice-versa?

@Shaggy "or you may choose any two consistent, distinct values to represent truthy and falsey respectively."

I never heard 'bout 1j, interesting...

Python, 34 bytes
lambda a,b:bin(a&b).count('01')==1

Try it online!
Although this doesn't use xor, I'm xnor.

Python 2,  42  41 bytes
Uses XOR, ^
-1 thanks to Neil (double rather than halve).
lambda a,b:bin(a&b^(a&b)*2).count('1')==4

Try it online!

lambda a,b:bin(a&b^a*2&b*2).count('1')==4?

39 bytes in Python 3.10: lambda a,b:(a&b^(a&b)*2).bit_count()==4.

perl -Mfeature=bitwise -alp, 41 40 bytes
$_=2==(()=sprintf("%b",$_&$F[1])=~/1+/g)

Try it online!
How does it work?
The program reads lines from STDIN, expecting two numbers on each line. 1 is printed for pairs of numbers with the jfor property, an empty line for pairs without the jfor property.
The -p switch makes that the program loops over each line of the input, making the line available in $_. And the end, it will print whatever is in $_. The -l switch removes the trailing newline. The -a switch makes that the input is split on white space, with the components placed in @F. In particular, the second number will be in $F[1].
$_ & $F [1]

Due to the -Mfeature=bitwise switch, this makes & treat its operands as numbers, and performs a bitwise and on them. This makes that while $_ contains both numbers, only the first number is considered, as that is what Perl does with a string which is used as a number: if the beginning looks like a number, this is taken. (atoi, atof, yada, yada, yada). So, we're doing a bitwise and of the two numbers.
sprintf ("%b", ...)

This returns the result in a binary representation.
() = ... =~ /1+/g

Find all the sequences of consecutive 1s. This is assigned to a list (of 0 variables). We're throwing away the results, but assignment itself does have a return value; for a list assignment, the result is the number of elements on the RHS.
$_ = 2 == (...)

Compares the result (of the list assignment above) to 2. If equal, set $_ to 1, else to the empty string.
Edit: Saved a byte by looking at sequences of 1, instead of a full pattern.

Japt -!, 11 9 bytes
r& ¤ÔèA É

Try it
r& ¤ÔèA É     :Implicit input of integer array
r             :Reduce by
 &            :  Bitwise AND
   ¤          :Convert to binary string
    Ô         :Reverse
     è        :Count the occurrences of
      A       :  10, which gets coerced to a string
        É     :Subtract 1
              :Implicit output of Boolean negation

C (gcc), 53 bytes
f(a,b){for(a&=b,b=0;a;a=~a)for(b++;~a&1;a/=2);a=b^4;}

Try it online!
Returns 0 if the two numbers do have the JFor property, and truthy otherwise.

Pip, 11 bytes
1=01NTBaBAb

Try it online! (Verify all test cases)
The main trick is borrowed from xnor's Python answer: the property is satisfied if the binary representation of the bitwise AND contains the sequence 01 exactly once.
1=01NTBaBAb
             a and b are command-line args (implicit)
  01         01 (an integer literal, but treated as a string unless used in a numeric operation)
    N        Count occurrences in:
       aBAb   Bitwise AND of a and b
     TB       Converted to binary
1=           Test whether the number of occurrences equals 1 (0 if not, 1 if so)
             Autoprint (implicit)

Pip ? Ha-ha pip is python package management system ;)

Yeah... people have brought that up before. :P I guess I wasn't enough of a Pythonista to know about pip back when I thought it would be funny to name my golf language "Pip Isn't Python".

Jelly,  9  8 bytes
&BḄƝċ1=1

A dyadic Link accepting which yields 1 if jfor or 0 if not.
Try it online! Or see the test-suite.

8 bytes using XOR
-2 thanks to Neil (double rather than halve).
&Ḥ^$BS⁼4

Try it online!.

&Ḥ^$BS=4?

@Neil Oh, yeah.

Python 3, 137 bytes
def f(x,y):
	b=format;z='08b';x=b(x,z);y=b(y,z);a=""
	for i in range(8):a+=str(int(x[i])and int(y[i]))
	return int(a[7])+a.count("10")==2

Try it online!

a=x&y;return(a&1)+bin(a&255).count("10")==2.
a simplifies down to a bitwise and

R, 37 34 33 bytes
-3 bytes thanks to Dominic van Essen
function(x,y)sum(rle(x&y)$v>0)==2

Try it online!
Takes input as raw bytes, as given by intToBits. In R, this gives a length 32 vector with the least significant bit first, therefore padded with many zeros. Then compute the run lengths, i.e. sequences of consecutive identical elements. The JFor property is verified if there are exactly two runs of 1s.

A (dumb) solution with XOR is:
R, 39 bytes
function(x,y)xor(sum(rle(x&y)$v>0)-2,1)

Try it online!

Or using the $values component of rle for 34 bytes

@DominicvanEssen Nice, thanks! I was convinced that you couldn't compare raws with integers, but I was wrong!

APL (Dyalog Extended), 9 bytes
2=≢⊆⍨∧/⊤⎕

Try it online!
How it works
2=≢⊆⍨∧/⊤⎕  ⍝ Full program; input = a vector of two numbers
       ⊤⎕  ⍝ Binary representation of two numbers
     ∧/    ⍝ Bitwise AND
   ⊆⍨      ⍝ Extract chunks of ones
2=≢        ⍝ Test if there are exactly two chunks

Charcoal, 23 19 bytes
≔＆ＮＮθ⁼⁴Σ⍘⁻｜⊗θθ＆⊗θθ²

Try it online! Link is to verbose version of code. Outputs a Charcoal boolean i.e. - for JFor, nothing if not. Edit: Switched to my version of @JonathanAllan's answer to save 4 bytes. Explanation:
≔＆ＮＮθ

Input the two numbers and take their bitwise AND.
⁼⁴Σ⍘⁻｜⊗θθ＆⊗θθ²

Take the bitwise XOR of twice the number with itself (Charcoal has no XOR operator, so I have to do this longhand) and check that the result (in base 2) has exactly four 1 bits.

Perl 5 +-pl, 35 bytes
$_=unpack(B8,$_&<>)=~/^0*1+0+1+0*$/

Try it online!
Explanation
This accepts characters as input to allow using unpack to get the first 8 chars of the binary representation of the stringwise AND of $_ (which implicitly contains the input line) and <> (which is the following line of input) and checks for the pattern as specified. Prints 1 for JFor pair or the empty string otherwise.

Perl 5 + -pl, 34 bytes
$_=(@a=unpack(B8,$_&<>)=~/1+/g)==2

This uses @Abigail's counting approach, thanks @Dominic van Essen!
Try it online!

I think that gives the wrong answer for "5" and "?". The ASCII code of "5" is 53 or 0b110101. The ASCII code for "?" is 63, or 0b111111. Bitwise AND gives us 110101, which is not valid. But your code says its valid (It also fails on the 21 21 test example, but I'm too lazy to figure out how to put chr(21) into TIO).

@Abigail Thank you. As I was going to sleep last night I realised that a 010101 pattern would give a false positive too. I've amended the regex for +6 (!) I'll try and look at this later though... But I suspect using your approach with the unpack mechanism would be the best approach...

Is there a situation where the g at the end does something?

@DominicvanEssen In this case there wasn't, so thanks! But in general this returns a list of all the matches and when a list is converted to scalar it returns the number of elements (like in Abigail's answer). You can also use it to easily return the first match in something like ($_)=/match/g.

Got it. So I guess that $_=(@a=unpack(B8,$_&<>)=~/1+/g)==2 would be an approach that'd exploit //g to count elements for less bytes?

@DominicvanEssen Yes indeed! Thanks! It's the bulk of Abigail's approach though and I think would make our answers pretty much the same.

Io, 60 bytes
-1 byte thanks to @DLosc.
method(x,y,(x&y)asBinary strip("0")occurancesOfSeq("01")==1)

Try it online!

@DLosc I'm impressed! Have you programmed in Io before?

Haha, thanks! I haven't, but there are similar functions named strip/lstrip/rstrip in other languages, like Python, so I've seen this kind of one-byte savings before. Then it was just a matter of looking up Io's docs and seeing that it did indeed have strip.

C# (Visual C# Interactive Compiler), 58 bytes
a=>b=>Regex.Matches(Convert.ToString(a&b,2),"01").Count==1

Try it online!

APL+WIN, 24 bytes and uses xnor
Prompts for input as a vector of 2 integers:
4=+/b≠9↑1↓b←∊×/(⊂9⍴2)⊤¨⎕

Try it online! Coutesy of Dyalog Classic

JavaScript (V8), 44 bytes
(a,b)=>(a&b).toString(2).match(/^1+0+1+0*$/)

Try it online!
Takes input as two numbers, returns a binary string if they meet the JFor property, otherwise null
(a,b)=>(~(a^b)&(a|b)).toString(2).match(/^1+0+1+0*$/)

Try it online!
The same function, but instead uses an XOR to get the binary string.

05AB1E, 8 7 bytes (without XOR/XNOR bonus)
&b0«ÔCн

Outputs 1 for truthy and 0/2/4 for falsey (only 1 is truthy in 05AB1E, so this is allowed according to rule "Output may follow your language's conventions for Truthy and Falsey").
Try it online or verify all test cases.
8 bytes with XOR bonus:
&x^2вO4Q

Port of @JonathanAllan's Python 2 answer.
Try it online or verify all test cases.
Explanation:
&        # Bitwise-AND the two (implicit) input-integer together
 b       # Convert it to a binary-string
  0«     # Append a trailing 0 at the end
    Ô    # Connected uniquify it
     C   # Convert it from binary back to an integer
         # (which will result in 0/2/10/42; of which only 10 is a truthy test result)
      н  # Pop and leave just the first digit (0/2/1/4, of which only 1 is 05AB1E truthy)
         # (after which the result is output implicitly)

&        # Bitwise-AND the two (implicit) input-integers together
 x       # Double it (without popping)
  ^      # Bitwise-XOR (a&b) with 2*(a&b)
   2в    # Convert this to a binary-list
     O   # Sum that list to get the amount of set bits
      4Q # And check if it's equal to 4
         # (after which the result is output implicitly)

The last four bytes has a few alternatives, like 5%3@ or ₆ÍÃĀ.

Scala, 46 45 bytes
_.&(_).toBinaryString matches "1+0+1+0*"

Try it online


text:
Find me a Tinder date!
Ah, Tinder . . . the app that takes the code golf approach to online dating. With just a few well-chosen right swipes and a bit of luck (or a cute puppy pic), you too could have more matches than /(?!)/.
This code-golf challenge involves Tinder dates of a very different kind. Given a Tinder version number as input, hook me up with the date on which that version was released. You may use any convenient formats for input and output (e.g. string, list of integers, date object). Refer to this table*:
+-------------+--------------+
| Version no. | Release date |
+-------------+--------------+
|   11.19.0   |  2020-07-10  |
|   11.18.0   |  2020-06-18  |
|   11.17.0   |  2020-06-04  |
|   11.16.0   |  2020-05-26  |
|   11.15.0   |  2020-05-11  |
|   11.14.0   |  2020-04-27  |
|   11.13.0   |  2020-04-13  |
|   11.12.0   |  2020-03-27  |
|   11.11.1   |  2020-03-21  |
|   11.11.0   |  2020-03-20  |
|   11.10.4   |  2020-03-06  |
|   11.10.3   |  2020-03-02  |
|   11.10.2   |  2020-02-29  |
|   11.10.1   |  2020-02-28  |
|   11.9.0    |  2020-02-13  |
|   11.8.0    |  2020-01-30  |
|   11.7.2    |  2020-01-24  |
|   11.7.1    |  2020-01-20  |
|   11.7.0    |  2020-01-19  |
|   11.6.1    |  2020-01-04  |
|   11.6.0    |  2019-12-16  |
|   11.5.0    |  2019-12-06  |
|   11.4.0    |  2019-11-22  |
|   11.3.0    |  2019-11-10  |
|   11.2.1    |  2019-11-01  |
|   11.1.1    |  2019-10-16  |
|   11.1.0    |  2019-10-11  |
|   11.0.2    |  2019-10-09  |
|   11.0.1    |  2019-09-27  |
|   11.0.0    |  2019-09-20  |
|   10.20.0   |  2019-09-10  |
|   10.19.1   |  2019-09-03  |
|   10.19.0   |  2019-08-28  |
|   10.18.0   |  2019-08-15  |
|   10.17.0   |  2019-07-24  |
|   10.16.0   |  2019-06-24  |
|   10.15.1   |  2019-06-08  |
|   10.15.0   |  2019-06-05  |
|   10.14.0   |  2019-06-04  |
|   10.13.0   |  2019-05-16  |
|   10.12.1   |  2019-05-02  |
|   10.12.0   |  2019-04-28  |
|   10.11.0   |  2019-04-13  |
|   10.10.1   |  2019-04-10  |
|   10.10.0   |  2019-04-02  |
|   10.9.1    |  2019-03-23  |
|   10.9.0    |  2019-03-18  |
|   10.8.1    |  2019-03-15  |
|   10.8.0    |  2019-03-06  |
|   10.7.0    |  2019-02-16  |
|   10.6.0    |  2019-02-12  |
|   10.5.0    |  2019-01-22  |
|   10.4.1    |  2019-01-08  |
|   10.4.0    |  2018-12-17  |
|   10.3.0    |  2018-11-29  |
|   10.2.1    |  2018-11-20  |
|   10.2.0    |  2018-11-15  |
|   10.1.1    |  2018-11-02  |
|   10.1.0    |  2018-10-31  |
|   10.0.2    |  2018-10-25  |
|   10.0.1    |  2018-10-19  |
|   10.0.0    |  2018-10-17  |
|    9.9.2    |  2018-10-12  |
|    9.9.1    |  2018-10-11  |
|    9.9.0    |  2018-10-09  |
|    9.8.1    |  2018-10-03  |
|    9.8.0    |  2018-09-21  |
|    9.7.2    |  2018-09-14  |
|    9.7.1    |  2018-09-06  |
|    9.7.0    |  2018-08-29  |
|    9.6.1    |  2018-08-23  |
|    9.6.0    |  2018-08-21  |
|    9.5.0    |  2018-08-06  |
|    9.4.1    |  2018-08-03  |
|    9.4.0    |  2018-07-24  |
|    9.3.0    |  2018-06-22  |
|    9.2.0    |  2018-06-11  |
|    9.1.0    |  2018-05-29  |
|    9.0.1    |  2018-05-17  |
|    9.0.0    |  2018-05-14  |
|    8.13.0   |  2018-05-03  |
|    8.12.1   |  2018-04-28  |
|    8.12.0   |  2018-04-26  |
|    8.11.0   |  2018-04-12  |
|    8.10.0   |  2018-04-05  |
|    8.9.0    |  2018-03-15  |
|    8.8.0    |  2018-02-28  |
|    8.7.0    |  2018-02-16  |
|    8.6.0    |  2018-02-05  |
|    8.5.0    |  2018-01-22  |
|    8.4.1    |  2018-01-02  |
|    8.4.0    |  2017-12-15  |
|    8.3.1    |  2017-12-08  |
|    8.3.0    |  2017-11-29  |
|    8.2.0    |  2017-11-03  |
|    8.1.0    |  2017-10-17  |
|    8.0.1    |  2017-10-09  |
|    8.0.0    |  2017-09-25  |
|    7.8.1    |  2017-09-08  |
|    7.8.0    |  2017-09-05  |
|    7.7.2    |  2017-08-23  |
|    7.7.1    |  2017-08-15  |
|    7.7.0    |  2017-08-14  |
|    7.6.1    |  2017-07-24  |
|    7.6.0    |  2017-07-14  |
|    7.5.3    |  2017-06-22  |
|    7.5.2    |  2017-06-09  |
|    7.5.1    |  2017-06-02  |
|    7.5.0    |  2017-05-30  |
|    7.4.1    |  2017-05-17  |
|    7.4.0    |  2017-05-09  |
|    7.3.1    |  2017-04-19  |
|    7.3.0    |  2017-04-13  |
|    7.2.2    |  2017-04-03  |
|    7.2.1    |  2017-04-01  |
|    7.2.0    |  2017-03-30  |
|    7.1.1    |  2017-03-16  |
|    7.1.0    |  2017-03-06  |
|    7.0.1    |  2017-02-19  |
|    7.0.0    |  2017-02-16  |
|    6.9.4    |  2017-02-06  |
|    6.9.3    |  2017-01-27  |
|    6.9.2    |  2017-01-25  |
|    6.9.1    |  2017-01-17  |
|    6.9.0    |  2017-01-12  |
|    6.8.1    |  2017-01-03  |
|    6.8.0    |  2016-12-19  |
|    6.7.0    |  2016-11-30  |
|    6.6.1    |  2016-11-18  |
|    6.6.0    |  2016-11-16  |
|    6.5.0    |  2016-11-07  |
|    6.4.1    |  2016-11-01  |
|    6.4.0    |  2016-10-26  |
|    6.3.2    |  2016-10-19  |
|    6.3.1    |  2016-10-12  |
|    6.3.0    |  2016-10-04  |
|    6.2.0    |  2016-09-27  |
|    6.1.0    |  2016-09-20  |
|    5.5.3    |  2016-09-12  |
|    5.5.2    |  2016-09-08  |
|    5.5.1    |  2016-09-03  |
|    5.5.0    |  2016-08-31  |
|    5.4.1    |  2016-08-25  |
|    5.4.0    |  2016-08-18  |
|    5.3.2    |  2016-07-29  |
|    5.3.1    |  2016-07-21  |
|    5.3.0    |  2016-07-19  |
|    5.2.0    |  2016-06-27  |
|    5.1.1    |  2016-06-07  |
|    5.1.0    |  2016-06-06  |
|    5.0.2    |  2016-05-13  |
|    5.0.1    |  2016-04-29  |
|    5.0.0    |  2016-04-21  |
|    4.8.2    |  2016-03-02  |
|    4.8.1    |  2016-01-30  |
|    4.8.0    |  2016-01-27  |
|    4.7.2    |  2015-12-17  |
|    4.7.1    |  2015-11-13  |
|    4.7.0    |  2015-11-11  |
|    4.6.1    |  2015-09-23  |
|    4.6.0    |  2015-09-04  |
|    4.5.0    |  2015-07-07  |
|    4.4.6    |  2015-05-18  |
|    4.4.5    |  2015-05-12  |
|    4.4.4    |  2015-05-05  |
|    4.4.3    |  2015-04-28  |
|    4.4.1    |  2015-04-16  |
|    4.4.0    |  2015-04-15  |
|    4.3.0    |  2015-03-02  |
|    4.1.4    |  2015-02-13  |
|    4.1.3    |  2015-02-06  |
|    4.1.1    |  2015-02-02  |
|    4.0.9    |  2014-10-09  |
|    4.0.8    |  2014-09-27  |
|    4.0.7    |  2014-09-19  |
|    4.0.6    |  2014-09-18  |
|    4.0.4    |  2014-07-17  |
|    4.0.3    |  2014-06-26  |
|    4.0.2    |  2014-06-17  |
|    4.0.1    |  2014-06-06  |
|    4.0.0    |  2014-06-05  |
|    3.0.4    |  2014-03-12  |
|    3.0.3    |  2014-02-26  |
|    3.0.2    |  2013-12-19  |
|    3.0.1    |  2013-11-28  |
|    3.0.0    |  2013-11-21  |
|    2.2.3    |  2013-11-20  |
|    2.2.2    |  2013-09-25  |
|    2.2.1    |  2013-09-24  |
|    2.2.0    |  2013-09-14  |
|    2.1.1    |  2013-06-07  |
|    2.1.0    |  2013-05-23  |
|    2.0.3    |  2013-04-01  |
|    2.0.2    |  2013-03-29  |
|    2.0.1    |  2013-03-28  |
|    1.1.4    |  2013-02-08  |
|    1.1.3    |  2013-02-06  |
|    1.1.2    |  2013-01-21  |
|    1.1.1    |  2013-01-11  |
|    1.1.0    |  2013-01-08  |
|    1.0.6    |  2012-11-24  |
|    1.0.5    |  2012-11-16  |
|    1.0.4    |  2012-11-06  |
|    1.0.3    |  2012-09-20  |
|    1.0.2    |  2012-08-29  |
|    1.0.1    |  2012-08-15  |
|    1.0.0    |  2012-08-03  |
+-------------+--------------+

 *Source, with four modifications to unify the version number format (1.03 → 1.0.3, 4.3 → 4.3.0, 4.4 → 4.4.0, iOS 8.4.0 → 8.4.0).

JavaScript (Node.js),  527 ... 498  493 bytes
Expects the version in the format described in the challenge. Returns a stringified Date object.
v=>"W302o288qB$87LB38R8gXL7x3egzBX9wW*2ec62od1X<H2eX8wX$30iiXL*Y398dXX<**Z7dab1u7jR6g67L447b$2o4lX2l29R$2l*[L`1o!++$*+Z[IR311v3eI`$RBAL3fB2pRRCZ2l$2vL*2u29B2fX$2vL252o%2755H+202l2p=313f2f+2pR1j;L312v=45BM3fR[$$+30[RX_RZ[R2v`I21282p2f1p21HM`C$M3f1o2p1vYL393l292vZ+A*30S`36I312pC1u3fX1o[2p3cXR1o2pX[272p2p3fI2p29".replace(/[\da-z]?./g,s=>(n=(s[1]?parseInt(s,36):Buffer(s)[0]-32-10*(s>'9'))^46,d-=~(n/6),n%=6,y=++n&4?z=++x-x:y,z=(n&2?!++y:z)+n%2,v==x+`.${y}.`+z?new Date(d*864e5):''),x=0,d=15554)

Try it online!
How?
Each version is stored as a number \$d\$ of days elapsed since the previous version and a 3-bit value \$m\$ describing how the version numbers x.y.z are updated. The final value is:
$$n=\big(6\times(d-1)+(m-1)\big)\operatorname{XOR}46$$
The purpose of the XOR is to maximize the number of small values.
Numbers \$0\$ to \$15\$ are encoded with a single character in the ASCII range 32-47.
Numbers \$16\$ to \$54\$ are encoded with a single character in the ASCII range 58-96.
All other numbers are encoded as a 2-digit number in base 36, using digits and lower case letters (ASCII ranges 48-57 and 97-122 respectively).
We use the regular expression /[\da-z]?./g to match either a 2-digit number in base-36 or a single character in the other ASCII ranges.

Hi :) Is is possible to get some explanation here?

@SomoKRoceS Done :) I'm currently on vacation with a sporadic Internet connection, so that's the best I can do for now.

Python 3.8, 519 517 493 bytes
lambda x,e=enumerate:((y:=sum(ord(i)-35for i in"/1:U-+Ó&-4%W#$'Y3\x8a-$^$*:ê5|$.,:#d$+1Ĝ##'*8#P$#/,*)X`6W%GÍ&GV+3<$7;%+8*)'('+#*,+***),%/8³,(+%.-&6-1&%-)9+0'*0;-9$+1&43+5=.*¶72./69*1%*.&/1.E.&2%),+*1)%$(%))&0(,7º19'9,&(.+&2)17$&3C:0**-*1%(4#,/3-·2$')22#$('1$)5132-1;#"[:[(n,m,k)for n,i in e('1p 7o 5 6fp23 2aqc 2jno0l mzkii f1qqnj2p 4r96mr srha04m2ix5d 3lfbiojllc95'.split(),1)for m,j in e('a'*(n==4)+oct(int(i,36))[2:])for k in range(int(j,16))].index(x)])+1030403)>>9,(y>>5)&15,y&31)

Try it online!
Compressor+ungolfed:
import re
import time
import calendar
import base64
import math
with open('207234.txt','rt') as f:
    s=f.read()
matcher=re.compile(
    re.sub(r'\d+',lambda m:r'(\d+)',
    re.sub(r'(?:\\\ )+',lambda m:r'\s*',
    re.escape((x:=s.split('\n'))[0])
           )
           )
    )
assert len(x_:=matcher.findall(s))==sum(1 for i in x if i)
x_=[[int(j) for j in i] for i in x_][::-1]
v_=[tuple(i[:3]) for i in x_]
#for v in [(2, 0, 1),(11, 2, 1)][::-1]:
#    i=v_.index(v)
#    a,b,c,d,e,f=x_[i]
#    x_=x_[:i]+[[a,b,c-1,d,e,f]]+x_[i:]
for n,v in (v_add:=[(1,(2, 0, 1)),
            (0,(4, 0, 4)),
            (1,(4, 1, 1)),
            (0,(4, 1, 1)),
            (2,(4, 3, 0)),
            (0,(4, 4, 1)),
            (2,(6, 1, 0)),
            (1,(11, 2, 1)),
            (1,(11, 10, 1))])[::-1]:
    i=v_.index(v)
    a,b,c,d,e,f=x_[i]
    plus_i,plus_c,plus_b=[(1,1,0),(0,-1,0),(0,0,-1)][n]
    x_=x_[:i+plus_i]+[[a,b+plus_b,c+plus_c,d,e,f]]+x_[i+plus_i:]
x=[[0]]
old_a,old_b,old_c=1,0,0
for a,b,c,d,e,f in x_:
    if old_c!=c:
        if old_a==a and old_b==b:
            assert c==old_c+1# or (old_a,old_b,old_c) in [
                #(4, 0, 4),(4, 1, 1),(4, 4, 1)]
        x[-1][-1]+=(c-old_c>=0 and c-old_c or 1)
    if old_b!=b:
        if old_c==c:
            assert c==0# or (a,b,c) in [(11, 2, 1)]
            x[-1][-1]=1
        x[-1].append(0)
    if old_a!=a:
        if old_b==b:
            x[-1].append(0)
        x.append([0])
    old_a,old_b,old_c=a,b,c
x[-1][-1]+=1
v__=[(n,m,k) for n,i in enumerate(x,1)
     for m,j in enumerate(i)
     for k in range(j)]
assert set(v_)-set(v__)==set()
assert len(set(v__)-set(v_))==len(v_add)
versions=x
x=[d*512+e*32+f
    for a,b,c,d,e,f in x_
    ]
x2=[i-j for i,j in zip(x[1:],x)]
ls2,d2,s2=min((len(repr(
        s:=''.join(chr(k+l) for k in x2+[0])
        ).encode('utf-8')),l,s) for l in range(32,128))
print(ls2,d2)
s0=''.join(''.join(((str(j) if j else ' ') if j0 and base_n(x//n,n)+chr(48+x%n+(97-48-10)*(x%n>=10)) or ''
s0_=' '.join(base_n(int(i,8),36) for i in s0.split())
assert (s0==
    ' '.join(
        #('a'*(n==4)+
        oct(int(i,36))[2:]
        #)
        for n,i in enumerate(s0_.split(),1))
        )
print(len(s0_))
f=(
#print(len(r'''
lambda x,e=enumerate:((
    y:=sum(ord(i)-35 for i in s2[
        :[(n,m,k)
          for n,i in e(s0_.split(),1)
          for m,j in e('a'*(n==4)+oct(int(i,36))[2:])
          for k in range(int(j,16))].index(x)
        ])+1030403
    )>>9,(y>>5)&15,y&31)
#''')-8-4*(7+5)-3)
)
assert all(f((a,b,c))==(d,e,f_) for a,b,c,d,e,f_ in x_)

Javascript - 862 bytes
r=(v=>{for(p=[1,0,0],s=0,d="0cc0ec16c2fc0ac08c2db03c0ac10c02c30a00c01c03c34b0fc63b0ac01c38c01a07c15c45c0ec55a01c0bc09c15c3fc00c01c08c0cc74b00c04c00c07c11b00b2cb01c0cc00c07c07c06c32b3bb13c31b02c22c29b03c20c32a08c0ec18b01c14b16b02c08c14b07c06b03c05c04c08a00b07b07b08c07c07b06c06b09b02c0cb13b0fc09b05c08c02c0ac0aa03c0fb0ac0eb02c02c0ab06c14b08c0db03c07c0dc16b0ac15b01c08c0db03c11a0ec08b11b1ab09c07b12c14b0eb0bb0cb0fb15b07b0eb02c05b0ba03c0cb0db0bb20b0ac03b0fb02c06b08c08c07b0cc06b02c01c05a02c06c06b02c0db05c09b12b16c0eb15b04b12b09c03b05c0ab08c03b0fb04c0eb13b01b03c10b1eb16b0db06c07b0aa07c0cc02b05c10b00c09b0cb0eb0ab13c0fb01c04c06b0eb0fb00c01c02c04c0eb01c06b11b0eb0eb0fb09b0eb16b00c",i=0;;i+=3){if(p.join(".")==v)return new Date(1343952e6+864e5*s).toISOString().substr(0,10);s+=parseInt(d[i]+d[i+1],16),l=d[i+2],[a,b,c]=p,p='b'>l?[a+1,0,0]:'c'>l?[a,b+1,0]:[a,b,c+1]}})

Explanation
The release dates are encoded as a difference of days. Each diff is represented by 3 characters in d. The first 2 characters indicate the number of days to the next version. The last character uses 'a','b', or 'c' to represent which part of the version changed, if the version number is considered as a.b.c .
As some versions skip over numbers (such as 11.1.1 to 11.2.1), missing releases were added, costing only 3 bytes each.
There's probably some additional compression possible with the data string but I wanted to keep it strictly ASCII.

const version_dates = {
    '11.19.0':'2020-07-10',
    '11.18.0':'2020-06-18',
    '11.17.0':'2020-06-04',
    '11.16.0':'2020-05-26',
    '11.15.0':'2020-05-11',
    '11.14.0':'2020-04-27',
    '11.13.0':'2020-04-13',
    '11.12.0':'2020-03-27',
    '11.11.1':'2020-03-21',
    '11.11.0':'2020-03-20',
    '11.10.4':'2020-03-06',
    '11.10.3':'2020-03-02',
    '11.10.2':'2020-02-29',
    '11.10.1':'2020-02-28',
    '11.10.0':'2020-02-28',
    '11.9.0':'2020-02-13',
    '11.8.0':'2020-01-30',
    '11.7.2':'2020-01-24',
    '11.7.1':'2020-01-20',
    '11.7.0':'2020-01-19',
    '11.6.1':'2020-01-04',
    '11.6.0':'2019-12-16',
    '11.5.0':'2019-12-06',
    '11.4.0':'2019-11-22',
    '11.3.0':'2019-11-10',
    '11.2.1':'2019-11-01',
    '11.2.0':'2019-11-01',
    '11.1.1':'2019-10-16',
    '11.1.0':'2019-10-11',
    '11.0.2':'2019-10-09',
    '11.0.1':'2019-09-27',
    '11.0.0':'2019-09-20',
    '10.20.0':'2019-09-10',
    '10.19.1':'2019-09-03',
    '10.19.0':'2019-08-28',
    '10.18.0':'2019-08-15',
    '10.17.0':'2019-07-24',
    '10.16.0':'2019-06-24',
    '10.15.1':'2019-06-08',
    '10.15.0':'2019-06-05',
    '10.14.0':'2019-06-04',
    '10.13.0':'2019-05-16',
    '10.12.1':'2019-05-02',
    '10.12.0':'2019-04-28',
    '10.11.0':'2019-04-13',
    '10.10.1':'2019-04-10',
    '10.10.0':'2019-04-02',
    '10.9.1':'2019-03-23',
    '10.9.0':'2019-03-18',
    '10.8.1':'2019-03-15',
    '10.8.0':'2019-03-06',
    '10.7.0':'2019-02-16',
    '10.6.0':'2019-02-12',
    '10.5.0':'2019-01-22',
    '10.4.1':'2019-01-08',
    '10.4.0':'2018-12-17',
    '10.3.0':'2018-11-29',
    '10.2.1':'2018-11-20',
    '10.2.0':'2018-11-15',
    '10.1.1':'2018-11-02',
    '10.1.0':'2018-10-31',
    '10.0.2':'2018-10-25',
    '10.0.1':'2018-10-19',
    '10.0.0':'2018-10-17',
    '9.9.2':'2018-10-12',
    '9.9.1':'2018-10-11',
    '9.9.0':'2018-10-09',
    '9.8.1':'2018-10-03',
    '9.8.0':'2018-09-21',
    '9.7.2':'2018-09-14',
    '9.7.1':'2018-09-06',
    '9.7.0':'2018-08-29',
    '9.6.1':'2018-08-23',
    '9.6.0':'2018-08-21',
    '9.5.0':'2018-08-06',
    '9.4.1':'2018-08-03',
    '9.4.0':'2018-07-24',
    '9.3.0':'2018-06-22',
    '9.2.0':'2018-06-11',
    '9.1.0':'2018-05-29',
    '9.0.1':'2018-05-17',
    '9.0.0':'2018-05-14',
    '8.13.0':'2018-05-03',
    '8.12.1':'2018-04-28',
    '8.12.0':'2018-04-26',
    '8.11.0':'2018-04-12',
    '8.10.0':'2018-04-05',
    '8.9.0':'2018-03-15',
    '8.8.0':'2018-02-28',
    '8.7.0':'2018-02-16',
    '8.6.0':'2018-02-05',
    '8.5.0':'2018-01-22',
    '8.4.1':'2018-01-02',
    '8.4.0':'2017-12-15',
    '8.3.1':'2017-12-08',
    '8.3.0':'2017-11-29',
    '8.2.0':'2017-11-03',
    '8.1.0':'2017-10-17',
    '8.0.1':'2017-10-09',
    '8.0.0':'2017-09-25',
    '7.8.1':'2017-09-08',
    '7.8.0':'2017-09-05',
    '7.7.2':'2017-08-23',
    '7.7.1':'2017-08-15',
    '7.7.0':'2017-08-14',
    '7.6.1':'2017-07-24',
    '7.6.0':'2017-07-14',
    '7.5.3':'2017-06-22',
    '7.5.2':'2017-06-09',
    '7.5.1':'2017-06-02',
    '7.5.0':'2017-05-30',
    '7.4.1':'2017-05-17',
    '7.4.0':'2017-05-09',
    '7.3.1':'2017-04-19',
    '7.3.0':'2017-04-13',
    '7.2.2':'2017-04-03',
    '7.2.1':'2017-04-01',
    '7.2.0':'2017-03-30',
    '7.1.1':'2017-03-16',
    '7.1.0':'2017-03-06',
    '7.0.1':'2017-02-19',
    '7.0.0':'2017-02-16',
    '6.9.4':'2017-02-06',
    '6.9.3':'2017-01-27',
    '6.9.2':'2017-01-25',
    '6.9.1':'2017-01-17',
    '6.9.0':'2017-01-12',
    '6.8.1':'2017-01-03',
    '6.8.0':'2016-12-19',
    '6.7.0':'2016-11-30',
    '6.6.1':'2016-11-18',
    '6.6.0':'2016-11-16',
    '6.5.0':'2016-11-07',
    '6.4.1':'2016-11-01',
    '6.4.0':'2016-10-26',
    '6.3.2':'2016-10-19',
    '6.3.1':'2016-10-12',
    '6.3.0':'2016-10-04',
    '6.2.0':'2016-09-27',
    '6.1.0':'2016-09-20',
    '6.0.0':'2016-09-20',
    '5.5.3':'2016-09-12',
    '5.5.2':'2016-09-08',
    '5.5.1':'2016-09-03',
    '5.5.0':'2016-08-31',
    '5.4.1':'2016-08-25',
    '5.4.0':'2016-08-18',
    '5.3.2':'2016-07-29',
    '5.3.1':'2016-07-21',
    '5.3.0':'2016-07-19',
    '5.2.0':'2016-06-27',
    '5.1.1':'2016-06-07',
    '5.1.0':'2016-06-06',
    '5.0.2':'2016-05-13',
    '5.0.1':'2016-04-29',
    '5.0.0':'2016-04-21',
    '4.8.2':'2016-03-02',
    '4.8.1':'2016-01-30',
    '4.8.0':'2016-01-27',
    '4.7.2':'2015-12-17',
    '4.7.1':'2015-11-13',
    '4.7.0':'2015-11-11',
    '4.6.1':'2015-09-23',
    '4.6.0':'2015-09-04',
    '4.5.0':'2015-07-07',
    '4.4.6':'2015-05-18',
    '4.4.5':'2015-05-12',
    '4.4.4':'2015-05-05',
    '4.4.3':'2015-04-28',
    '4.4.2':'2015-04-28',
    '4.4.1':'2015-04-16',
    '4.4.0':'2015-04-15',
    '4.3.0':'2015-03-02',
    '4.2.0':'2015-03-02',
    '4.1.4':'2015-02-13',
    '4.1.3':'2015-02-06',
    '4.1.2':'2015-02-06',
    '4.1.1':'2015-02-02',
    '4.1.0':'2015-02-02',
    '4.0.9':'2014-10-09',
    '4.0.8':'2014-09-27',
    '4.0.7':'2014-09-19',
    '4.0.6':'2014-09-18',
    '4.0.5':'2014-09-18',
    '4.0.4':'2014-07-17',
    '4.0.3':'2014-06-26',
    '4.0.2':'2014-06-17',
    '4.0.1':'2014-06-06',
    '4.0.0':'2014-06-05',
    '3.0.4':'2014-03-12',
    '3.0.3':'2014-02-26',
    '3.0.2':'2013-12-19',
    '3.0.1':'2013-11-28',
    '3.0.0':'2013-11-21',
    '2.2.3':'2013-11-20',
    '2.2.2':'2013-09-25',
    '2.2.1':'2013-09-24',
    '2.2.0':'2013-09-14',
    '2.1.1':'2013-06-07',
    '2.1.0':'2013-05-23',
    '2.0.3':'2013-04-01',
    '2.0.2':'2013-03-29',
    '2.0.1':'2013-03-28',
    '2.0.0':'2013-03-28',
    '1.1.4':'2013-02-08',
    '1.1.3':'2013-02-06',
    '1.1.2':'2013-01-21',
    '1.1.1':'2013-01-11',
    '1.1.0':'2013-01-08',
    '1.0.6':'2012-11-24',
    '1.0.5':'2012-11-16',
    '1.0.4':'2012-11-06',
    '1.0.3':'2012-09-20',
    '1.0.2':'2012-08-29',
    '1.0.1':'2012-08-15',
    '1.0.0':'2012-08-03'
}

r=(v=>{for(p=[1,0,0],s=0,d="0cc0ec16c2fc0ac08c2db03c0ac10c02c30a00c01c03c34b0fc63b0ac01c38c01a07c15c45c0ec55a01c0bc09c15c3fc00c01c08c0cc74b00c04c00c07c11b00b2cb01c0cc00c07c07c06c32b3bb13c31b02c22c29b03c20c32a08c0ec18b01c14b16b02c08c14b07c06b03c05c04c08a00b07b07b08c07c07b06c06b09b02c0cb13b0fc09b05c08c02c0ac0aa03c0fb0ac0eb02c02c0ab06c14b08c0db03c07c0dc16b0ac15b01c08c0db03c11a0ec08b11b1ab09c07b12c14b0eb0bb0cb0fb15b07b0eb02c05b0ba03c0cb0db0bb20b0ac03b0fb02c06b08c08c07b0cc06b02c01c05a02c06c06b02c0db05c09b12b16c0eb15b04b12b09c03b05c0ab08c03b0fb04c0eb13b01b03c10b1eb16b0db06c07b0aa07c0cc02b05c10b00c09b0cb0eb0ab13c0fb01c04c06b0eb0fb00c01c02c04c0eb01c06b11b0eb0eb0fb09b0eb16b00c",i=0;;i+=3){if(p.join(".")==v)return new Date(1343952e6+864e5*s).toISOString().substr(0,10);s+=parseInt(d[i]+d[i+1],16),l=d[i+2],[a,b,c]=p,p='b'>l?[a+1,0,0]:'c'>l?[a,b+1,0]:[a,b,c+1]}})

const test_passed = Object.keys(version_dates).every(version=>
    version_dates[version]===r(version)
);
console.log(test_passed ? 'TEST PASSED' : 'TEST_FAILED')

PowerShell, 513 508 bytes
Inspired by Arnauld's answer. It's nice code.
param($t)$v=,0*5;$d='2012-8'|date
'Ba2a4b2d7a0hT5ca0a6b@d8acU2a5Y9a0ae6Agb1f9a4H5aa1ib1`f3aha2Pa16`dgPQ7T4a`a2ggfU0U9a9T9bc4T1cc2E0ha4R4aR0R2bhR0gVced@XWWhgWfVYbQ2Q9a5Yehba0A0cQ5a0Q4bbQ0fR0hQ3cga3R2a0R1ahQ3cA7a4XQ7R6iWa8R0Q4Q1Q2Q5R1WQ4bUA1cQ2Q3Q1S2a0SQ5bVhhWa2VbaEbfVbQ3eYQ8b2Q4R1TQ8iSeQ0hSQ5dQ4Q9QcQ6S0R2Q3fWA0ga2RePa6YQ2Q4Q0a9Q5adVQ4Pa5abdQ4aVQ7Q4Q4Q5YQ4R2'-split'(?=\D)'|%{$d=$d|% *ys($a=[char]($_[0]-($i=($_[0]-48)-shr4)*16)+$_[1]+$_[2])
$v[$i-1]++;$v[$i]=$v[$i+1]=0;if(+$a-and$v[0..2]-join'.'-eq$t){$d}}

Try it online!
Some versions of the Tinder are missing from the list. They're added as test cases.
The script starts with version 0.0.0 and the date of August 1, 2012.
Then the script iterates through the data string. Each substring contains the number of days since the previous release and the descriptor in the first character ASCII code. The descriptor is one of 16,32,48:

16 - increment the major version by 1
32 - increment the middle version by 1
48 - increment the minor version by 1

The script excludes versions for which the number of days is zero, but makes an increment for the version. Thus, the script works correctly with the missed versions of the Tinder.

Jelly, 333 332 bytes
“3ĖẎ⁺Ḣµ3bṄ9HĊ:%:ḞŻHuƤƊ²ⱮĠJėḷȧ!°ọṫọẠIÆGƙĿĠR%ėȦqȷSḂṘ^ṡ¬’BC2“®(0>FZ\`j‘¦3“"4‘¦s2;"“€żḍḋF=ẎhƘẎƁy7ẉr¶$qɦṁI>Ḥ⁾s÷,Ṇ~ʋƊt¦c@ɓḥḤ~ÐqHṀ °8{yþẒ⁺¬4ɠz DOṇĠƓK?Ọj!⁽>3'nẏmẹœƭUÑʠæƥæk¹Ð§©ḲŒmPɦġRXɓµọạṢṘỤzḍ⁻s¡+ç¿¹ḋ-^ɼRċIsẸƑñ*½Nı’b29¤[“¬¿“¬“£’];
“eÄneøỌC<½weƙBƤʠĠċUṅKȮCıẈ-ɱ¥*øṬḊ⁹®gṫ¥ɗɱɦɦN⁶ÐẈGṖƭƇ¶ȦĿ⁸ịỵ9ḟŒḥɱ=ṭcỴʠßɓḷ@ḳⱮsṪɠḞ.ṣ?9’B2“`ot~‘¦s3,¢¹×TṂ>3Ḷ¤Ʋ}+ʋ\€yW

Try it online!
Input and output are a list of three integers. (The output is actually wrapped in a singleton list, but that's not visible.)
Explanation
The version numbers are stored as increments from the last version, except if the minor version is increased, then the patch version is automatically reset, etc. For example: [7,8,9] + [0,1,2] = [7,9,2]. It turns out that most increments are made of 0's and 1's, so I concatenated them (starting with the initial version [1,0,0], replaced 2's with 0's and represented the huge binary number with a base-250 literal, then added code to set the specific indices to 2.
For dates, the same incrementing logic is used, but this time the day increments are much bigger (up to 28), so I stored them separately as a base 29 number. (Since there are no 0's, I tried using base 28 and incrementing, but it wasn't worth it.) Years and months are stored analogously to version numbers, except:

The initial date is added separately
The number had leading zeros, so I had to invert it
There were some 3's, which I dealt with the same way as with 2's.

Merging this all together creates the table, which I simply pass to the y (translate) command to look up the input.

Nice! How does it work?

@Dingus It's… complicated. I'll try to explain when I have time.

@Dingus I added an explanation.

source: Stack Exchange

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

sort: votes


text:
Is it a uniform polyhedron?
Objective
Given a vertex figure consisting of regular convex polygons, determine whether it represents a convex uniform polyhedron.
What is a uniform polyhedron?
A uniform polyhedron is a polyhedron whose faces are regular polygons, while having the same vertex figure for each vertices. Generally a uniform polyhedron can be nonconvex, but only convex polyhedra will be considered in this challenge. (More precisely, the polyhedron is required to be vertex-transitive, but that's just another detail.)
What is a vertex figure?
In the context of a convex uniform polyhedron, a vertex figure is a list of the number of edges of polygons (in order) around a vertex. For example, a cube has vertex figure of (4.4.4).
Truthy inputs

(3.3.3) – Tetrahedron
(4.4.4) – Cube
(3.3.3.3) – Octahedron
(5.5.5) – Dodecahedron
(3.3.3.3.3) – Icosahedron
(4.4.N) for every N≥3 – N-gonal prism (It is a cube for N=4)
(3.3.3.N) for every N≥4 – N-gonal antiprism (It is an octahedron for N=3)
(3.6.6) – Truncated tetrahedron
(3.4.3.4) – Cuboctahedron
(3.8.8) – Truncated cube
(4.6.6) – Truncated octahedron
(3.4.4.4) – Rhombicuboctahedron
(4.6.8) – Truncated cuboctahedron
(3.3.3.3.4) – Snub cube
(3.5.3.5) – Icosidodecahedron
(3.10.10) – Truncated dodecahedron
(5.6.6) – Truncated icosahedron
(3.4.5.4) – Rhombicosidodecahedron
(4.6.10) – Truncated icosidodecahedron
(3.3.3.3.5) – Snub dodecahedron

Rotations and reversions (generally, all dihedral permutations) of these lists are also truthy. For example, (4.6.8), (4.8.6), (6.4.8), (6.8.4), (8.4.6), (8.6.4) are all truthy.
Falsy examples

(3.3.3.3.3.3) – Triangular tiling; not a polyhedron.
(5.5.5.5) – Order-4 pentagonal (hyperbolic) tiling; not a polyhedron.
(3.3.4.4) – Cannot be uniform. Note that this is different from (3.4.3.4).

Don't care situations
An input is expected to have at least 3 entries, and to consist of integers that are at least 3. Otherwise, the challenge falls in don't care situation.

(5/2.5/2.5/2) – Great stellated dodecahedron; not convex.
(3.3) – Triangular dihedron; not Euclidean.
(2.2.2) – Triangular hosohedron; not Euclidean.
(3/2.3/2.3/2) – Retrograde tetrahedron.
(1)
(-3)
()

As I understand it, the Kepler-Poinsot polyhedra and uniform star polyhedra all have non-integer entries in the vertex figure, so they are not included, and the truthy inputs shown are all truthy inputs possible. Is this correct?

@fireflame241 Yes.

Jelly,  54  51 bytes
2×þ5o6R¤
“EḶ¤ẊƓW4mð,’b6ṣ5ịþ¢Ẏṙ€Ƭ1Ẏ;U$e@
ṢṖ’Ḍe“!ṛ‘ȯÇ

A dyadic Link accepting a list of integers (each greater than two) which yields 1 if that list is a vertex figure which represents a uniform polyhedron, or 0 otherwise.
Try it online! Or see the test-suite.
How?
First, check if the input is any rotation or reflection of either 4,4,N or 3,3,3,N (using ṢṖ’Ḍe“!ṛ‘) - the prisms or antiprisms.
If not, build a table containing all the other un-permuted, possibilities - the Platonic and Archimedean solids. Then get all dihedral-permutations of that table's values (Ẏṙ€Ƭ1Ẏ;U$) and then check for the existence of the input (e@).
Note: The table actually built includes two redundant rows containing only lists which either contain some value(s) less than 3 or are of the form 4,4,N in some rotation.
To build the table an outer-product using 1-based indexing is made between "items" vectors (of the form r,2r,3,4,5,6, where r is the row) and "indexes" vectors.
  | items        | indexes
--+--------------+----------------------------------------------------------------
r | r,2r,3,4,5,6 | 1,1,1 | 3, 2, 2 | 3,1,3,1 | 1,0,0 | 3,4,1,4 | 4,0,2 | 3,3,3,3,1
--+--------------×-------+---------+---------+-------+---------+-------+----------
1 | 1, 2,3,4,5,6 | 1,1,1 | 3, 2, 2 | 3,1,3,1 | 1,6,6 | 3,4,1,4 | 4,6,2 | 3,3,3,3,1
2 | 2, 4,3,4,5,6 | 2,2,2 | 3, 4, 4 | 3,2,3,2 | 2,6,6 | 3,4,2,4 | 4,6,4 | 3,3,3,3,2
3 | 3, 6,3,4,5,6 | 3,3,3 | 3, 6, 6 | 3,3,3,3 | 3,6,6 | 3,4,3,4 | 4,6,6 | 3,3,3,3,3
4 | 4, 8,3,4,5,6 | 4,4,4 | 3, 8, 8 | 3,4,3,4 | 4,6,6 | 3,4,4,4 | 4,6,8 | 3,3,3,3,4
5 | 5,10,3,4,5,6 | 5,5,5 | 3,10,10 | 3,5,3,5 | 5,6,6 | 3,4,5,4 | 4,6,T | 3,3,3,3,5

The "indexes" vectors are encoded as a single base-6 integer which is split at its 5 digits (see the start of Link 2).
2×þ5o6R¤ - Link 1, Get the five "items vectors": no arguments
2        - two
   5     - five
  þ      - (implicit [1..2]) table (implicit [1..5]) using:
 ×       -   multiplication  -> [[1,2],[2,4],[3,6],[4,8],[5,10]]
     6R¤ - range of six -> [1,2,3,4,5,6]
    o    - logical OR (vectorises) -> [[1,2,3,4,5,6],[2,4,3,4,5,6],[3,6,3,4,5,6],[4,8,3,4,5,6],[5,10,3,4,5,6]]

“EḶ¤ẊƓW4mð,’b6ṣ5ịþ¢Ẏṙ€Ƭ1Ẏ;U$e@ - Link 2, Platonic or Achimedian?: list of integers (>2), V
“EḶ¤ẊƓW4mð,’                   - base 250 number = 269760427146828960006295
            b6                 - in base 6 = [1,1,1,5,3,2,2,5,3,1,3,1,5,1,0,0,5,3,4,1,4,5,4,0,2,5,3,3,3,3,1]
              ṣ5               - split at fives = [[1,1,1],[3,2,2],[3,1,3,1],[1,0,0],[3,4,1,4],[4,0,2],[3,3,3,3,1]]
                  ¢            - call Link 1 as a nilad = [[1,2,3,4,5,6],[2,4,3,4,5,6],[3,6,3,4,5,6],[4,8,3,4,5,6],[5,10,3,4,5,6]]
                 þ             - table using:
                ị              -   index into -> the 5 by 7 table shown above
                   Ẏ           - tighten (to a list of the unpermuted lists)
                      Ƭ        - collect up until repetition applying:
                    ṙ€ 1       -   rotate each left one place
                        Ẏ      - tighten (to a list of all the rotations)
                           $   - last two links as a monad:
                          U    -   upend (reverse each list)
                         ;     -   concatenate (to the forward ones)
                            e@ - does (the input, V) exist in that list of lists?

ṢṖ’Ḍe“!ṛ‘ȯÇ - Main Link: list of integers (each >2), V
Ṣ           - sort V
 Ṗ          - remove the rightmost (maximal)
  ’         - decrement (each)
   Ḍ        - convert from base ten
     “!ṛ‘   - list of code page indices = [33,222]
    e       - exists in? (i.e. was V some rotation of [4,4,n] or [3,3,3,n]?)
          Ç - call Link 2 as a monad - f(V)
         ȯ  - logical OR

Python 3, 190 bytes
def f(F):s="".join(hex(k)[2]for k in F);F[1:]in[[4,4],[3]*3]or{s,s[::-1]}&{*"555 333 366 388 3aa 466 566 468 46a 3434 3444 3454 3535 33333 33334 33335".split()}and max(F)<16or f(F[1:]+F[:1])

Try it online!
Takes input as a list of integers representing the vertex figure. The function errors (RecursionError) if the vertex figure is not a uniform polyhedron, otherwise there is no error.
I tried several schemes of organizing the finite classes into a smart way that takes advantage of patterns, but hardcoding all possibilities reigned superior since it is a relatively small set.
Explanation
def f(F):
    # F is a rotation of the input vertex figure; initially is the input vertex figure
    # Convert to string for easier comparison later in the code
    s="".join(hex(k)[2]for k in F)
    # Test true if the permutation is N.4.4.4 or N.3.3.3
    (F[1:]in[[4,4],[3]*3]or
    # Test truthy if permutation (or its reverse) is in
    #   3.3.3, 3.6.6, 3.8.8, 3.10.10, 4.6.6, 5.6.6, 4.6.8, 4.6.10,
    #   3.3.3.N, 3.4.3.4, 3.4.4.4, 3.4.5.4, 3.5.3.5
    #   3.3.3.3.3, 3.3.3.3.4, 3.3.3.3.5
    {s,s[::-1]}&{*"555 333 366 388 3aa 466 566 468 46a 3434 3444 3454 3535 33333 33334 33335".split()}
    # Numbers greater than 15 would convert into the most-significant hexit when converted to a string,
    # causing 0x43 to match the same as 0x4,
    # so we need to check that none of this happened if we want a bugfree string search
    and max(F)<16
    # If we tested truthy, then terminate
    # Otherwise, recurse with the vertex figure cyclically rotated left one
    or f(F[1:]+F[:1]))

Retina, 142 bytes
$
,$",
^`\G\d+,
$&
%L$`,
$'$>`
N^$`.+,(.+),
$1
N`
^(3,(3,3(,(\d+|3,[3-5]))?|4,([3-5],)?4|5,3,5|(6|8|10),\6)|4,4,\d+|4,6,(6|8|10)|5,(5|6),\8),¶

Try it online! Link includes test cases. Explanation:
$
,$",

Duplicate the list and suffix a comma to each copy.
^`\G\d+,
$&

Reverse the first copy of the list.
%L$`,
$'$>`

Generate all rotations of both the list and its reverse.
N^$`.+,(.+),
$1

Sort the last number in descending order.
N`

Sort in ascending numeric order. (For the truthy cases, these two sorts ensure that the resulting first list is also the first list in list order.)
^(...),¶

Ensure the first list matches one of the truthy cases:
3,(3,3(,(\d+|3,[3-5]))?|4,([3-5],)?4|5,3,5|(6|8|10),\6)

Handle those cases with a 3: 3,3,3, 3,3,3,N (N>=3), 3,3,3,3,3, 3,3,3,3,4, 3,3,3,3,5, 3,4,4 (this is 4,4,N with N=3 of course), 3,4,3,4, 3,4,4,4, 3,4,5,4, 3,5,3,5, 3,6,6, 3,8,8, and 3,10,10.
|4,4,\d+|4,6,(6|8|10)|5,(5|6),\8

Handle 4,4,N (N>=4), 4,6,6, 4,6,8, 4,6,10, 5,5,5 and 5,5,6.

05AB1E, 68 61 bytes
Ž‚ÃS2äI{¨.å•3É≠ÞÌδ)Ö“JhG•твŽ6ð9ǝ11Ž
¤š«.¥Ƶ_+ε5L._Dí«}˜€S>I.å~

Input as a list of integers.
Try it online or verify all test cases.
Explanation:
Hard-coded approach.
Step 1: Check if the input is of the type 3.3.3.N or 4.4.N:
Ž‚Ã         # Push compressed integer 33344
   S        # Split it into a list of digits: [3,3,3,4,4]
    2ä      # Try to split it into 2 equal-sized parts: [[3,3,3],[4,4]]
      I     # Push the input-list
       {    # Sort it from lowest to highest
        ¨   # Remove the last/highest item
         .å # Check if this modified input-list is in the [[3,3,3],[4,4]] list of lists

Step 2: Check if the input is in the hard-coded list of truthy polyhedrons including their rotations and reflections (minus the 4.4.4 and 3.3.3.3, which are already covered by the 3.3.3.N and 4.4.N check):
•3É≠ÞÌδ)Ö“JhG•
            # Push compressed integer 1122222256020285110099101081
 тв         # Convert it to base-100 as list:
            #  [11,22,22,22,56,2,2,85,11,0,99,10,10,81]
Ž6ð         # Push compressed integer 1769
   9ǝ       # Insert it at index 9:
            #  [11,22,22,22,56,2,2,85,11,1760,99,10,10,81]
11          # Push 11
  Ž\n¤      # Push compressed integer 19798
      š     # Convert the 11 to a list [1,1] and prepend the 19798: [19798,1,1]
       «    # Merge it to the other list:
            #  [11,22,22,22,56,2,2,85,11,1769,99,10,10,81,19798,1,1]
.¥          # Undelta it:
            #  [0,11,33,55,77,133,135,137,222,233,2002,2101,2111,2121,2202,22000,22001,22002]
  Ƶ_        # Push compressed integer 222
    +       # Add it to each value:
            #  [222,233,255,277,299,355,357,359,444,455,2224,2323,2333,2343,2424,22222,22223,22224]
 ε          # Map each value to:
  5L        #  Push list [1,2,3,4,5]
    ._      #  Rotate the current integer that many times towards the left:
            #   i.e. acbde → [bcdea,cdeab,deabc,eabcd,abcde]
            #   i.e. abc → [bca,cab,abc,bca,cab]
      D     #  Duplicate that list
       í    #  Reverse each inner integer
            #   i.e. → [aedbc,caedb,bcaed,dbcae,edbca]
            #   i.e. → [acb,bac,cba,acb,bac]
        «   #  Merge the two lists together
 }˜         # After the map: flatten the list of lists
   €S       # Split each integer into a list of digits
     >      # Increase each by 1
      I.å   # Check if the input-list is in this list of lists

Step 3: Check if either of the two checks is truthy, and output the result:
~           # Bitwise-OR to check if either of the two is truthy
            # (after which the result is output implicitly)

See this 05AB1E tip of mine (sections How to compress large integers? and How to compress integer lists?) to understand why Ž‚Ã is 33344; •3É≠ÞÌδ)Ö“JhG• is 1122222256020285110099101081; •3É≠ÞÌδ)Ö“JhG•тв is [11,22,22,22,56,2,2,85,11,0,99,10,10,81]; Ž6ð is 1769; Ž\n¤ is 19798; and Ƶ_ is 222.

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


text:
Average of your code
Inspired by this
Task
Your task is to output the average character of your code.
What is an average character?
Say we have a string golf().
We then take the ASCII value of each separate symbol, so our string is 103 111 108 102 40 41, and calculate the average of those values, rounded to an integer. In our case the average is 505 / 6 = 84.1666... = rounded to 84. That value is printed out as an ASCII character, in our case T.
Rules
You must take no input and must not read the source code directly, while outputting the average character of its source code. Integers are rounded by function floor(x+0.5). Empty programs are not allowed. This is code-golf, so lowest byte count wins!

Average Character Calculator (only works for unicode characters input)

@FryAmTheEggman will update rules

While I like the idea, it would have been beneficial to restrict code to contain at least two different characters, neither of which can be identical to the average.

@Adám yeah, for some reason I didn't think of hardcoding the output... Maybe somebody could turn this into an interesting question, as I think its too late to edit this question.

@Dion You could post in the Sandbox a variant where the scoring works best for longer programs, or where the average/sum plays some role (just spitballing ideas)

@Dion Are empty program allowed, and if allowed should they output a null char or nothing.

@Mukundan314 empty programs are allowed as long as they output the average character, which is the NULL byte for an empty program

@Dion Empty program would result the average value of round(0 / 0). It is invalid simply due to divided by zero. So I don't think the empty source code should be allowed. If it must be allowed, by using the definition of division, x / y = z is y * z = x, one may argue output any single character should be allowed.

@tsh ok, thats reasonable. Will edit the rules.

@Dion is returning the value from a function allowed

@Mukundan314 yes, as returning is printing to the functions output.

Downvoted - the challenge mostly boils down to "output one given character". There might be very special situations where the self-reference makes this harder - but if you have a primitive like print("?") where ? can be replaced by any other character, then it's easy to convert it into a solution (in particular, repeatedly replacing '?' by the average will always converge).

Does a cat script count as "reading the source code directly"?

///, 1 byte
A

Try it online!
As it is 1 byte, simply outputting the source code gives the average. /// just outputs the source code unchanged if it doesn’t contain any / characters, so almost any ASCII character works in place of A

+1 Right tool for the job.

Could we do a CW of languages which can implicitly output a single character? Retina, Jelly, etc.

@fireflame241 Looks like Adàm may have Beat you to it

Also works for Charcoal.

Also works for Keg/Canvas/Carrot.

Also works for cat

Cat is a programming language?

Unreadable, 111 bytes

'"'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'"""

Try it online! or Check average
Note that the average character is $ and does not appear in the source code, which contains only 37 's and 74 "s.

Malbolge, 17 bytes
(=<;:9876543210TA

Try it online!
Test the code average
Explanation:
(=<;:9876543210TA

(                    Copies the value pointed by register d to register d.
                     (d = 0 so it copies the '(' ASCII value)
 =<;:9876543210      Succesive calls to the crazy operation to update the value
                     in register a until the value stored meets the code average
               T     Prints the value in a
                A    Ends the program

Luckily this time we don't need to cope with Malbolge's code encryption feature.

HQ9+ Family, 1 bytes
Q

Believe it or not, there are challenges can be solved by HQ9+ in 2020.

Don’t know whether this counts as indirectly or “directly reading own source code.” But I upvoted immediately for the clever meta-ness and original use of such a ‘done’ language!

This challenge can also be solved by cat in 2020.

The fact that you can solve this challenge with HQ9+ and also with cat makes it a particularly lame challenge in 2020.

Python 2, 8 bytes
print"Y"

Try it online!
Average Character Verified

Also compatible with Lua

And with Perl too!

APL (Dyalog Unicode) and lots of other languages and REPLs, 1 byte
4

Try it online!

However, more interesting is:
''''

Which actually evaluates to the single quote. Try it online!

brainfuck, 15 bytes
+[+++++>+<]>++.

Try it online!
Requires an 8 bit interpreter as it uses modulo 256 arithmetic.
Average is 53.4. Outputs 5 which is character 53.

COW, 11 8 bytes
BOOM!!

Try it online! or
verify the average.
Explosively prints 0 (average 48.375), using the fact that all non-instructions (B, !!, and the two newlines) are no-ops.
6 bytes
I'm retaining the 8-byte version above because it's my favourite, but here's a 6-byter thanks to @JoKing:
OOM!

(Note the code ends with two tabs.) Also prints 0 (average 47.66...).
And here's another, with an average of exactly 48:
OOM!

COW, 87 78 bytes
MoOMoOMoOMoOMoOMoOMoOMoOMoOMoOMoOMoOMoOMOOMMMMOOmoOMoOmOoMOomooMMMMOomoomoOMoo

Try it online! or verify the average.
No no-ops this time. Prints [ (average 90.54...) by counting up to 91.
Commented
MoOMoOMoOMoOMoOMoOMoOMoOMoOMoOMoOMoOMoO    push 13 to first memory block
MOO        begin outer loop
  MMM      copy value to register
  MOO      begin inner loop
    moO    switch to second memory block
    MoO    increment
    mOo    switch to first memory block
    MOo    decrement
  moo      end inner loop
  MMM      paste register value into first memory block
  MOo      decrement
moo        end outer loop
moO        switch to second memory block
Moo        print as ASCII character

BOOM!! Out of mana! - Don't we know those lines?

R, 8 bytes
cat("B")

Try it online! or Check average
or
cat('C')

Try it online! or Check average
Also,
cat(8)

(with 2 null bytes) doesn't work on TIO, but works in RStudio on my Kubuntu machine.
Try it online! or Check average.

Pyramid Scheme, 29 bytes
   ^
  / \
 /out\
^-----
-

Try it online!
This has an average of ~48.137, so this outputs 0.
If we're allowed a trailing newline, then we can get 4 bytes
^,
-

Try it online!
Again, this outputs 0, but by printing the return of the pyramid, which has an extra newline

cat, 1 byte
a

If your challenge can be competitively solved with cat, there is probably something wrong with the challenge.

Assuming cat is allowed, isn't this reading its own source code?

@Calculuswhiz No, cat is just the interpreter. Every interpreter has to read the source code of the program. There's no instruction in this program which reads the source code, only one that outputs the letter a.

Retina 0.8.2, 1 byte
0

Try it online! Works by counting the number of 0s in the input. This can of course be extended to any arbitrary number of bytes just by repeating the number of 0s, or substituting other characters which happen to have an average byte value of 0, e.g. .2, as long as the result remains a valid regular expression that doesn't match the empty string.
Without using a Match (count) stage, I think the minimum possible is 3 bytes:
^
4

This program outputs 4, whose ASCII code 52 is the average of 94 (for ^) and 10 (for the newline).

If 0 outputs 0, what stops a .2 outputing 0 too?

@tsh Yeah, I thought of that myself overnight, almost any two ASCII characters with an average of 0 will work.

Lost, 19 13 11 bytes
v<<<<
>%(9@

-6 bytes thanks to @JoKing.
The average is 57.090..., which will be rounded to 57 (character '9').
Try it online or verify that it's deterministic.
Explanation:
Explanation of the language in general:
Lost is a 2D path-walking language. Most 2D path-walking languages start at the top-left position and travel towards the right by default. Lost is unique however, in that both the start position AND starting direction it travels in is completely random. So making the program deterministic, meaning it will have the same output regardless of where it starts or travels, can be quite tricky.
A Lost program of 2 rows and 5 characters per row can have 40 possible program flows. It can start on any one of the 10 characters in the program, and it can start traveling up/north, down/south, left/west, or right/east.
In Lost you therefore want to lead everything to a starting position, so it'll follow the designed path you want it to. In addition, you'll usually have to clean the stack when it starts somewhere in the middle.
Explanation of the program:
All arrows will lead the path towards the leading > on the second line. From there the program flow is as follows:

>: travel in an east/right direction
%: Put the safety 'off'. In a Lost program, an @ will terminate the program, but only when the safety is 'off'. When the program starts, the safety is always 'on' by default, otherwise a program flow starting at the exit character @ would immediately terminate without doing anything. The % will turn this safety 'off', so when we now encounter an @ the program will terminate (if the safety is still 'on', the @ will be a no-op instead).
(: Pop the top value, and push it to the scope. This is basically used to make the stack empty if we started somewhere in the middle.
9: Push a 9
@: Terminate the program if the safety is 'off' (which it is at this point). After which all the values on the stack will be output implicitly. So it'll output the 9 for the average character of unicode 57.

Perl 5 + -M5.10.0, 67 bytes
I know this isn't the shortest, but I think it's what OP was after.
$_=q{$_="\$_=q{$_};eval";$-+=ord for/./g;say chr(.5+$-/y///c)};eval

Try it online!

MATLAB... and MS-DOS and Bash? 7 bytes
!echo P

Outputs P. Length verification

First post here.
I thought this was going to be easy with MATLAB, as you can just enter a single digit number and it will return that as-is. Except that MATLAB prints more than just the number back out...
>> 0
ans =
     0

Same goes for strings.
>> 'a'
ans =
    'a'

Now I might've just waved my hands and said good enough, but where's the fun in that? :)
The only methods I knew of, that can print something to console without the extra ans =  would be to use the fprintf() or disp() functions.
12 Bytes.
>> fprintf('T')
T

9 Bytes. Note, Disp(0) and other single-digit variations will not work due to average length constraint.
>> disp('J')
J

These two are valid submissions, but I kept wondering... Can I do better?
Then I learned I could send commands to the operating system with the Shell Escape Function. i.e. !COMMAND
Except the command is sent to whatever operating system that machine is running on. Since MATLAB is available for both Windows and Unix, whatever command I choose needs to work on both; ensuring that my code runs on all machines.
This more or less locked me to the single command; echo. (Kinda anti-climactic, really)
A few trials and error with the output character, and I converged to the final answer. 7 Bytes.
>> !echo P
P

I really hope this isn't breaking any rules here...

MAWP 0.1, 3 bytes
99:

Outputs 9. Works because : and 9 are neighbours in the table, so 9: gives a value thats in between them, so adding another 9 guarantees that the average corresponds to 9

Backhand, 6 bytes
"o@7"

Try it online!
Explanation
"  7   Start a quote, then the character 7
 o  "  (backwards) End a quote, output the character
  @    Stop the program + no-op.

Hexagony, 3 bytes
0!@

Try it online! or Check the average character
Explanation
0     Set current memory edge to 0
 !    Output current memory edge as a number
  @   Terminate the program

SuperMarioLang, 2 bytes
:%

Try it online!
A simple answer in SuperMarioLang. The only command that gets executed is : which prints the value of the currently pointed memory position (0) as a number (initially 0). The second command % never gets executed as Mario (the command pointer) falls because there is no floor under him, so the program stops. The average between : and % is 0.
Also works in MarioLANG, where % is just interpreted as a comment.

Java (JDK), 4 bytes
A->9

Try it online!
Outputs the number 9 which as a character is the average character of the code.
Defined as a int f(Void v). Note that Void is an accepted argument type for "no input" challenges.
If an int isn't an acceptable output for this challenge, the following is most definitely valid, for an extra byte.
A->56

Try it online!
Outputs 8 which is the average character.
Defined as a char f(Void v). I was surprised that no casting to char was required, but it beats v->';' by one byte.

It's an implicit narrowing conversion; any constant integer expression whose value is between 0 and 65535 can be used where a char is expected.

Python 3, 10 bytes
print("N")

Try it online!

either print("O")
or print('P') works too

A more fun idea is print(chr(82)).

Ruby, 6 bytes
$><<?8

average is 56.16
$ cat mean.rb
$><<?8
$ ruby mean.rb
8
$ python -c "[print(chr(int(0.5 + sum([ord(c) for c in s])/len(s)))) for s in [l.strip() for l in open('mean.rb')]]"
8

p ?E outputs "E", but I don't think it's acceptable.

oops, somehow I dropped the leading char when calculating the average.  Fixed.

Your code works fine now. The average is still wrong, though.

JavaScript (Browser), 10 bytes
alert('M')

Try it online!

8 bytes.

Befunge-93, 5 3 bytes
.@!

Try it online!
.@ prints 0. ! was added so the average is 47.667, which rounds to 48, which is the ASCII code for 0.

SQLite, 9 bytes
SELECT"@"

Try it online!

brainfuck, 16 bytes
Outputs 6, the average of the program.
-[>+<-----]>+++.

Try it online!

PowerShell, 1 byte
0

Try it online!
This will work with every single digit. It just gets echoed.

JavaScript (Node.js), 5 bytes
()=>3

Try it online!

That returns 3, but outputs nothing.

@GirkovArpa, Functions are allowed by default and function may output by return value

The example specifically says printed out.

@GirkovArpa the rules explicitly say "outputting".

If I type 3 in my browser console and hit Enter, it outputs 3. Would that win?

@GirkovArpa that would but that only works on a repl environment

I just realized you can save a byte with _=>3.

@GirkovArpa the average of _=>3 would be C not 3

My mistake I had totally forgotten the goal of this challenge.

AlphaBeta, 10 bytes
edaaaaaCLz

Try it online!

05AB1E, 1 byte
0

Or any other single digit.
Try it online.

Z80Golf, 4 bytes
00000000: 3e 91 ff 76

Try it online!
This is ld a, 0x91 → rst 0x38 (putchar) → halt.
It prints a single 0x91 byte, and (0x3e + 0x91 + 0xff + 0x76) / 4 = 0x91.

Batch, 7 bytes
@echo U

I used the average character calculator to calculate the average of @echo  (with trailing space) and just appended the result, as that won't change the average.

ArnoldC, 59 bytes
IT'S SHOWTIME
TALK TO THE HAND "A"
YOU HAVE BEEN TERMINATED

Try it online!
Test the average
Mandatory answer in ArnoldC. New line characters have been added to the average as a single character of value 10.

Sorry, I misunderstood what you meant by 'New line characters have been added to the average as a single character'. But with "B" and two newlines the average I get is 65.4237288, which rounds down to 65 (A).

@Dingus you're totally right, I don't know Python and I messed up the code of the average calculator trying to adapt it. ^__^U

I had similar problems myself with newlines not being counted properly by that Python code. Here is another way to do it.

Vim, 2 bytes
ii

Try it online!

This is a V submission. a Vim submission would require an esc at the end.

@Razetime Why would an esc be required? Even though Vim is still in Insert mode, the intended text has still been outputted. esc would just be moving it out of insert mode and into normal mode, but as far as I can tell, there is no requirement for a Vim submission to end in normal mode, or that it can't end in insert mode.

I'm not sure, but it's the same reason why 2i2i is a V quine rather than a vim quine

I think a consensus on this would be good.

2i2I does not double the input until  is pressed, that's why it's required there. This answer should be fine

Lenguage, 4 bytes

Is this the first time where a lenguage program is totally written?
brainfuck, 14 bytes
+[+++++>+<]>.
Try it online!
Forcefix average

13 bytes BF with proof of average

@Bubbler https://en.wikipedia.org/wiki/ASCII says ASCII is 0-127

Please provide a hexdump for programs containing unprintables. I can tell that your Lenguage program is made entirely out of null bytes, but please specify next time, as they show up as �.

@Makonede Do � in every browser show �?

Pretty sure yeah. I don't think it's browser-dependent though, as searching it shows that it is shown as the real U+FFFD.

vim, 3 bytes
Four versions; one for each of the "insert on the same line" commands: A, a, i, and I:

A.<ESC>
a><ESC>
iB<ESC>
I2<ESC>

<ESC> is 0x1b.
(We can shave off a byte if we're willing to terminate while still in insert mode.)
Try it online! (For the A.<ESC> variant)

Sandwich, 2 bytes
pp

Sandwich is comprised of opcodes. The first letter of each line is the opcode, and the rest of the line is the arguments.
The opcode for this code is p, which means print. The arguments are also p, which is passed to the opcode.
The result of this code is that it prints out p, AKA ASCII 112.
Since the code is 2 bytes long, simply using the same two characters will give the average of the entire code segment.

Plumber, 191 bytes
[]
]
]
...88 more ']'...
]
]
][[=

Try it online!
Drops a packet down, which is incremented up to 92 and printed. 92 is the ASCII value for \.

perl -Mfeature=say, 6 bytes
say"P"

Try it online!
I wrote a small program to find the program above:
#!/opt/perl/bin/perl

use 5.028;

use strict;
use warnings;
no  warnings 'syntax';

use experimental 'signatures';
use experimental 'lexical_subs';

for my $c (32 .. 127) {
    my $char = chr $c;
    my $s = qq [say"$char"];
    my $score = 0;
    $score += ord $_ for split // => $s;
    $score = int (.5 + $score / length ($s));
    if ($score == $c) {
        say $s;
    }
}

__END__

Try it online!

Bash, 6 bytes
echo Y

Try it online!
echo Z

works as well.
Just like my Perl solution, this was found using a brute force search.

AWK, 15 bytes
BEGIN{print"X"}

Try it online!

7, 1 byte
3

Try it online!
After the code cycles, 3 tries to output itself. However, 3 is an unnamed command, so it can't be directly outputted. Instead, it gets turned into 73, which is outputted. 7 specifies the output format as "the same as the input", so the 3 after it prints 3.

A more interesting solution:

7, 3 bytes (8 characters)
01116743

Try it online!
This outputs 3 as a number.

naz, 8 bytes
8a9m7a1o

Short and sweet. Verify the average character here.
Explanation
8a9m7a # Set the register to a value of 79
1o     # Output once

PowerShell, 3 bytes
+$A

Try it online!
(43+36+65)/3 == 144/3 == 48 == ASCII('0')

JavaScript (Node.js), 16 bytes
console.log('U')

Here's how I brute-forced the solution:

const average = str => String.fromCharCode([...str]
  .reduce((total, char) => (total += char
    .charCodeAt(0)) || total, 0) / str.length);

for (let i = 0; i < 2 ** 16; i++) {
  const char = String.fromCharCode(i);
  const avg = average(`console.log('${char}')`);
  char == avg && console.log({ code: i, char, avg });
  // { i: 85, char: 'U', avg: 'U' }
}

99, 22 bytes
99 99 9
99 99 9
9 99
9m

Try it online!

T-SQL, 8 bytes
PRINT'D'

DB Fiddle

SimpleTemplate, 10 bytes
This is a simple code that outputs the average character itself:
{@echo"X"}

The average was calculated previously using JavaScript:

var code = '{@echo"X"}';

var sum = code.split('').reduce((a,_)=>a+_.charCodeAt(0), 0);

document.body.innerHTML += String.fromCharCode(sum/code.length);

To get the right character, I just used a random one, until I got one where the result was the same (in this case, "X").
The rules don't specify that the character can't be pre-calculated before. They only specify that you can't read the source code or that you can't take any input.

SimpleTemplate, 1 byte
Just simply outputs the character average:
1

This generates a PHP echo (example below):
echo (<<<'DATA6229934543895a3c69912b6e6658160198d45280523b34711abdc124745'
1
DATA6229934543895a3c69912b6e6658160198d45280523b34711abdc124745
);

You can try both versions on: http://sandbox.onlinephpfunctions.com/code/36449dad6c5de136ae489bcbeaddd97a6a7124bc
You can change the line 1048 to test the desired code.

Rust, 23 bytes
fn main(){print!("Q");}

Used modified Perl answer's script.

Python 3, 11 bytes
print('K')#

The average value is 75.09, which rounds to 75 - K.

https://codegolf.stackexchange.com/a/207329/92080 10 bytes

PHP, 1 byte
A

Try it online!
This will just output itself. Works with almost all of the printable ASCII characters.

Whitespace, 13 bytes
Outputs Data Link Escape (0x16)
I can't figure out how to put raw whitespace into a code block, so here you go:

[space][space][space][tab][space][tab][tab][space][lf]
[tab][lf]
[space][space]

Try it online
Explanation:

[space][space][space]           Push a number onto the stack
[tab][space][tab][tab][space]   Have that number be 22 (0x16)
[lf]                            End instruction
[tab][lf][space][space]         Output character from stack

Ada (GNAT), 53 bytes
procedure GNAT.IO.F is begin Put("M"); end GNAT.IO.F;

Try it online!
Why not?

C (gcc), 15 bytes
A(){return 84;}

Average is T. Returns ASCII code.
Try it online!

13 bytes

C - 18 chars
main(){puts("S");}

bitch, 2 bytes
/1

Try it online! or verify the average.
Following up my COW answer with one in bitch . . . read nothing into that. Outputs 0 (average 48 exactly). / outputs the accumulator value (initialised to zero); 1 is a no-op here.

Scala, 10 bytes
print("N")

Online demo

Rust, 5 bytes
||'R'

Try it online, Verify
Straightforward solution, just a closure that implements Fn() -> char.

MAWP v1.1, 6 bytes
33W/:.

I tried a different approach from Dion's answer.
Try it!, Verify

I think something is wrong with the "Try it!" link...

@Dion decided to port the website over to https://8dion8.github.io/MAWP, so all try it links are broken. Here's a proper link: https://8dion8.github.io/MAWP/?code=33W%2F%3A.&input=

1+ (with NOP), 3 bytes
'1:

Try it online!
Verify!
1+ (without NOP), 4 bytes
11+:

Try it online!
Verify!

Grok, 4 bytes
I[Wq

Characters are 73 91 87 113. Average is 91, which is [.

Vyxal, 1 byte
7

Try it Online!
Somehow the average of this program turns out to be the luckiest number in universe

Zsh, 5 bytes
<<< 5

Try it online!

Vyxal, 1 byte
0

Try it Online!
Any digit works.
Or, if you think that doesn't count,
\\

Try it Online!
\ is a single-character string.

Gol><>, 3 bytes
`TH

Try it online! and Check the average character.
`T   Escape the char T and push its charcode to stack
  H  Print all values on the stack and halt

Found by making the template `<any char>H and repeating the average calculator until it converges.

Io, 8 bytes
I feel that this is too boring to find...
"Y"print

Try it online!

Pyth, 2 bytes
"!

ASCII value of " is 34, and ASCII value of ! is 33.
(33 + 34) / 2 = 33.5 = 33

Try it online!

><>, 4 bytes
" o;

Try it online!
Outputs ; using a looping string literal.

Keg, 1 byte
e

Try it online!
Haha. I'm not gonna be late to the party!

Factor, 8 bytes
"Y"print

Try it online!
This actually works...................

Ruby, 4 bytes

p 3

Try it online!
Adding a leading newline to lower the average from capital-letter land to digit land.

Rexx (Regina), 5 bytes
SAY C

Try it online!

MATLAB/Octave, 4 bytes
''''

Try it online!
Outputs single ' character. And basically it's the way to write that as an immidiate value - the outer apostrofes are to indicate the value is char array so we're left with '' which is escape code for a single apostrofe.

Excel, 2 bytes
51

For once, there isn't some overly long Excel function to get in the way.

Julia, 9 bytes
print(:W)

Try it online!
also works with
:d|>print Try it online!

Thunno 2, 16 bytes
"DṘs+ĊmĊ"DṘs+ĊmĊ

Attempt This Online!
Explanation
"DṘs+ĊmĊ"DṘs+ĊmĊ  # Full program
"DṘs+ĊmĊ"         # String literal
         DṘ       # Duplicate and push the representation
           s+     # Prepend this to the original string
             Ċ    # Convert to charcodes (using Thunno 2 encoding)
              m   # Take the mean of this list
               Ċ  # Convert it back to a character (using Thunno 2 encoding)

Alternative (but boring) answers:

1 byte: 0 (or any other number)
2 bytes: '' (a character literal)


text:
Recover boolean cells from windowed sums
Background
In Minesweeper, you will often encounter a horizontal or vertical wall of one's and two's (not yet revealed cells are marked as ?):
... 1 1 1 1 2 2 2 1 2 1 1 ...
... ? ? ? ? ? ? ? ? ? ? ? ...
... A B C D E F G H ...

It is equivalent to a problem of recovering zeros and ones in a boolean array when only windowed sums of size 3 are given, where a zero means a safe cell and a one means a mine:
A + B + C = 1
B + C + D = 1
C + D + E = 1
D + E + F = 2
E + F + G = 2
F + G + H = 2
...

If you focus on CDEF, you can logically determine that C should be zero and F should be one. If C were 1, it would mean D + E = 0, which is impossible due to D + E + F = 2. (Remember that all variables are booleans.)
Challenge
This challenge is an extension of this problem to arbitrary window size.
Given n windowed sums with window size k, recover the n+k-1 boolean cells in the original array as much as possible. It is possible that some cells cannot be determined by the given information; those cells should be marked as such in the output.
The input is the number k and an array (or any ordered collection) of n integers between 0 and k inclusive. The output is an array of zeros, ones, and unknowns, which can be represented as any three distinct values of your choice. You can assume the input is valid, n and k are at least 2, and it has at least one corresponding boolean array.
Standard code-golf rules apply. The shortest code in bytes wins.
Test cases
The output format uses ? for unknown.
k = 2

sums   =  0 0
answer = 0 0 0

sums   =  0 1 2 1 0
answer = 0 0 1 1 0 0

sums   =  1 1 1 1 1 1 1
answer = ? ? ? ? ? ? ? ?

sums   =  1 1 1 1 1 1 0 1 1
answer = 0 1 0 1 0 1 0 0 1 0

sums   =  1 1 2 1 1 1
answer = 1 0 1 1 0 1 0
---

k = 3

sums   =   1 1 1 2 2 2
answer = ? ? 0 ? ? 1 ? ?

sums   =   3 2 1 0 1 2 3
answer = 1 1 1 0 0 0 1 1 1

sums   =   1 1 1 2 2 2 2 1 1
answer = 1 0 0 1 0 1 1 0 1 0 0

sums   =   2 2 2 2 2 2 2 1
answer = 1 ? ? 1 ? ? 1 ? ? 0

sums   =   2 1 2
answer = 1 0 1 0 1
---

k = 4

sums   =    1 2
answer = 0 ? ? ? 1

sums   =    3 2 1
answer = 1 1 ? ? 0 0

sums   =    1 1 2 1 1
answer = 0 0 1 0 0 1 0 0

sums   =    1 1 2 2 2 3
answer = 0 0 ? ? 0 1 ? ? 1

I don't know Brachylog, but this problem feels well-suited for it

Imaginary bonus for any solution that takes time linear in the input size.

Jelly, 23 18 bytes
L+’Ø.ṗ+⁴\⁼¥Ƈ⁸ZṢ€Q€

Try it online!
-5 bytes thanks to @Jonathan Allan
Uses [0,1] as ?, [0] as 0, and [1] as 1.
How?
Brute force of all possible boolean matrices.
L+’Ø.ṗ+⁴\⁼¥Ƈ⁸ZṢ€Q€
   Ø.               # [0,1]
     ṗ              # Cartesian power:
L+’                 # Length of answer = length of sums + k - 1
           Ƈ          # Filter by:
      +⁴\⁼¥             # n-wise overlapping sums are equal to
            ⁸           # the given sums
             Z      # Get the lists of all possibilities for each position (some binary list)
              Ṣ€    # Sort each possibility list (0s then 1s)
                Q€  # Take unique entries from every possibility ([0],[1],or [0,1])

-5 bytes: L+’Ø.ṗ+⁴\⁼¥Ƈ⁸ZṢ€Q€ (1. inline the helper - I just used reduce (\) to make it two links (¥), but four (ʋ) would work with your helper I think; 2. a more terse way to get the final results from the possibilities found - this one gives [0], [1], or [0,1]). TIO

@JonathanAllan I tried ʋ, and it did not work. I'm not sure why; it's not part of an LCC or anything

I think that's because the dyad-nilad ṡ⁴ is treated as one link during the parsing there (a dyad with one argument defined) so it would want ɗ (which works). I do often find myself trying different chain-forming quicks in such situations, I should probably read the interpreter code.

Brachylog, 39 bytes
Bit frustrating, as a nice attempt that inverts the moving window with ~{sᶠ↙L} does not work. So this is basically just brute-force.
{tL&lʰ+-₁~l.{0|1}ᵐsᶠ↙L+ᵐ~h?∧}ᶠ\{=h|∧2}ᵐ

Try it online!
How it works
{tL&lʰ+-₁~l.{0|1}ᵐsᶠ↙L+ᵐ~h?∧}ᶠ
{                           }ᶠ find all solutions:
 tL&                           store the window size as L
    lʰ+-₁                      length of input + window size - 1
         ~l.                   the output has this as length
            {0|1}ᵐ             and contains only 0's and 1's
                  sᶠ↙L         get all windows of length L
                      +ᵐ       that summed
                        ~h?    result in the input array
                           ∧   return the output defined earlier
\{=h|∧2}ᵐ
\                              transpose the solutions
 {     }ᵐ                      map over each position
  =h                           either all solutions are equal, then return first
    |∧2                        or return 2 (should be equivalent to ∨2 but isn't)

Dyalog APL, 48 44 43 bytes
{0 1⍳(+/÷≢)¨↓s[;⍸⍵≡⍤1⍉⍺+⌿s←2⊥⍣¯1⍳2*⍺+≢1↓⍵]}

Try it online!
This program uses 2 to represent ?, and this program is run using ⎕IO←0. This is basically a brute force algorithm, and could probably be golfed.

Welcome to PPCG! Nice first answer.

Thank you, Szewczyk.

Python 3, 168 bytes
import itertools
lambda k,s:[[q[0],"?"][len(set(q))>1]for q in zip(*[z for z in itertools.product((0,1),repeat=len(s)+k-1)if[sum(z[i:i+k])for i in range(len(s))]==s])]

Fairly straightforward: brute forces over all possible binary sequences of length n+k-1, collecting all the results, and then aggregating by position, replacing with a "?" if there's multiple possibilities for a given position.
The only clever saving here is in the last step where I use zip() to join all the results together by position, and then using len(set(q))>1 to tell whether or not there's multiple possibilities for a position.
Ungolfed:
import itertools

def recover(k,sums):
  def window_sum(seq):
    return [sum(seq[i:i+k]) for i in range(len(sums))]
  valid = []
  for poss in itertools.product((0,1), repeat=(len(sums)+k-1)):
    if window_sum(poss) == sums:
      valid.append(poss)
  ans = []
  for by_position in zip(*valid):
    if len(set(by_position)) == 1:
      ans.append(by_position[0])
    else:
      ans.append("?")
  return ans

Charcoal, 45 bytes
≔⁺⊖θＬηζ⭆ＥζＥΦＥＸ²ζ◧⍘λ²ζ⬤η⁼ν№✂λξ⁺θξ¹1Σ§λι∧⌈ι∨⌊ι?

Try it online! Link is to verbose version of code. Explanation:
≔⁺⊖θＬηζ

Calculate the length of the result up-front, saving a byte.
⭆Ｅζ

Loop over each desired output.
ＥΦＥＸ²ζ

Count all possible binary patterns...
◧⍘λ²ζ

... generating padded base 2 strings...
⬤η⁼ν№✂λξ⁺θξ¹1

... keeping only those with the correct window totals...
Σ§λι

... keep only the current bit. (Yes, we throw away all of the other results each time. That's code golf for you. If you want efficiency, well I guess you're looking at more like 57 bytes.)
∧⌈ι∨⌊ι?

Of those bits, if their maximum is 0 or minimum is not 0 then print that otherwise print ?.

05AB1E, 24 bytes
1ÝDIgI+<ãʒ'üI«.VO¹Q}øÅAk

Port of @fireflame241's Jelly answer, so make sure to upvote him!
Outputs -1 for ?.
Try it online or verify all test cases. (Feel free to remove the 1('?:ï in the footer of the test suite - which converts all -1 to "?" - to see the actual output.)
Explanation:
1Ý         # Push a list [0,1]
  D        # Duplicate it
   Ig      # Push the first input-list, and pop and push its length
     I+    # Add the second input-integer `k`
       <   # Decrease it by 1
        ã  # Get the cartesian product of [0,1] with the length+k-1
ʒ          # Filter this list of potential windows by:
 'ü       '#  Push character "ü"
   I«      #  Append the input `k` to it
     .V    #  Execute it as 05AB1E code
           #   `üN` creates overlapping sublists of size `N`
       O   #  Sum each overlapping sublist
        ¹Q #  And check if it's equal to the first input-list
}ø         # After the filter: zip/transpose the remaining lists
  ÅA       # Get the arithmetic mean of each inner list
    k      # Use it to index into the [0,1] list, which results in -1 if it isn't in the
           # list for the decimal values
           # (after which the result is output implicitly)

Ruby, 113 112 bytes
->k,n{(a=0,1).product(*[a]*z=n.size+k-2).select{|x|n==x.each_cons(k).map(&:sum)}.transpose.map{|x|x.minmax.sum}}

Try it online!
Returns false cells as 0, unknowns as 1, and true cells as 2.
Also, this doesn't use new fancy numerical block variables from Ruby 2.7, so that it's still runnable on TIO.

JavaScript (ES6),  127 126  121 bytes
Expects (k)(array). Returns a string, using 123 instead of 01?.
k=>F=(a,i=w=a.length+k-1)=>i--?F(a,i)+(g=n=>n--&&!a.some(h=(v,j)=>++x%~k?h(v-=n>>j&1,j+1):v,x=0)<<(n>>i&1)|g(n))(2<<w):''

Try it online!
Commented
k =>                         // outer function taking k
F = (                        // main function taking:
  a,                         //   a[] = input array
  i =                        //   i = counter initialized to ...
  w = a.length + k - 1       //   w = length of output array
) =>                         //
i-- ?                        // decrement i; if it was not equal to 0:
  F(a, i) +                  //   prepend the result of a recursive call to F
  ( g = n =>                 //   g is a recursive function taking a counter n:
      n-- &&                 //     decrement n; stop if it was equal to 0
      !a.some(h = (v, j) =>  //     otherwise, for each v at position j in a[]:
        ++x % ~k ?           //       increment x; if it's not equal to 0 modulo k + 1:
          h(                 //         do a recursive call to the callback of some():
            v -= n >> j & 1, //           subtract the j-th bit of n from v
            j + 1            //           increment j
          )                  //         end of recursive call
        :                    //       else:
          v,                 //         stop recursion and return v
        x = 0                //       start with x = 0
      ) << (n >> i & 1)      //     end of some(); turn true into 0; turn false into 2
                             //     if the if i-th bit of n is set, or 1 otherwise
      | g(n)                 //     bitwise OR with the result of a recursive call to g
  )(2 << w)                  //   initial call to g with n = 2 ** (w + 1)
:                            // else:
  ''                         //   end of recursion on F: return an empty string


text:
Cover positions with snakes of same 'colour'
Imagine a grid where the origin square \$(0,0)\$ is at the top left of the screen, and positive \$x\$ is rightwards whereas positive \$y\$ is downwards. Coloured squares are at various positions on the grid.
In a magical void separate from the grid are multiple snake-like strips of squares, each of a fixed length and a certain colour. Colours may or may not repeat across strips.
Each of our strips can move left, right or forward from the perspective of the head but can obstruct itself. The strips basically move by popping the tail and pushing a new head, as snakes do. They are necessary and sufficient to cover every correspondingly coloured position on the grid without strip overlap.

At any one time, you select a single snake from your inventory to control. It appears at \$(0,0)\$ pointing downwards, and moves are counted after this happens (see Samples below).
Whenever you select a new snake, the previous one gets stuck where it is.

Sounds dreadful, doesn't it? It's as if you need to plan all your moves…!
What moves will solve the grid?
Input

A matrix where different colours are represented by differing positive integers, and an uncoloured position is represented by 0.
Each strip's 'colour'; its length; and, since strips may share colours, a unique identifier.

You need only consider grids solvable by the method described in the introduction.
Output
Give the unique identifier of each strip you're moving, and the sequence of moves it should make:

You may use any consistent value for up (\$-y\$ wrt the grid), any consistent value for down (\$+y\$), any consistent value for left (\$-x\$ wrt the grid) and any consistent value for right (\$+x\$).

More than one solution is typically possible. Please choose one.
Possible output types are not limited to associative arrays.

In the sample test cases below, for the sake of example only, W, A, S, D represent up, left, down and right respectively. Also for the sake of example only, these rules are followed:

In the input, the unique identifier for a strip is given first, followed by its 'colour', followed by its length.
In the output, the unique identifier for any strip is followed by the moves for that strip. Consider the sets of moves in their given order.
Unique identifiers will be letters.

Sample 1
Input — grid
0010000
0000100

Input — strips
a 1 4

Possible output
a DDDS

Result (strip narrowed for clarity): image link
Sample 2
Input — grid
0010000
0200000
0030100
0002020
0000300

Input — strips
a 1 5
b 2 7
c 3 5

Possible output
a DDDDSS
b SDDDSSDD
c SSDDSSDD

Result (strips narrowed for clarity): image link
Sample 3
Input — grid
0000000
0010120
0030000
0102000
0000000
0000310
0000000

Input — strips
a 1 3
b 1 6
c 2 7
d 3 6

Possible output
b DDDDSSDSSS
c SSSSDDDWWWWDDS
d DDSSSSSDD
a DDSASS

Result (strips narrowed for clarity): image link
Sample 4
Input — grid
000000
010000
000020
030000
020040
040100
000300
000000

Input — strips
a 1 11
b 2 8
c 3 6
d 4 9

Possible output
c SSSDDSSSD
d SSSSSDSSDDDWWW
b DDDDSSAAAASSD
a SDDDDDSSAASS

Result (strips narrowed for clarity): image link

code-golf; the shortest code in bytes wins.
The linked rules apply.
Please explain your code.
Please link to Try It Online! or another online demo.

Samples credit: Color Strips on Armor Games

This seems like one of those challenges where the "shortest solution" is the relatively boring one that tries every possible solution until it finds one that works (which might take billions of years but will theoretically finish successfully). I think it is better fit for AtCoder/SPOJ/… than code-golf.

“it appears at (0, 0) pointing downwards” ← I first interpreted this as the snake's butt appearing at (0, 0) and the head at (0, n-1), but from the examples it seems the head is at (0, 0) and the body is at (0, -1), (0, -2), ..., so maybe this could use clarification.


text:
Crazy Blazin' DOM Injection
Introduction
This problem is a challenge that has to do with DOM manipulation at scale and overcoming some issues that may be inherent in dealing with the DOM.

This challenge is interesting because limitations push us to think through things differently and lean on the strengths of languages different than what we usually use.
I created this challenge myself based on a real world problem I ran into myself (details can be provided if needed). If this challenge has any relation to a differently know problem, those similarities are coincidental.

This challenge will be scored based on fastest execution.
Challenge
You must render one of the challenge levels in the Chrome web browser (84.0.4147.89 for standardization purposes) (submissions will need to be JavaScript functions for timing purposes):

easy
medium
hard

Using JavaScript please complete the following:

Get each table displayed and add a class table-n to each table where n is a zero based index of order of the table on the screen. If a table is nested within a table the parent would be N and the child would be N+1 with the next table being N+2.
Get each row displayed in each table and add a class of table-n-row-r where r is a zero based index of rows in the table represented by table-n.
Get each cell displayed in each table and add a class of table-n-row-r-cell-c where c is a zero based index of cells in a row represented by table-n-row-r.

At the end of the challenge the web page should still be able to be interacted through in the browser, and a call to document.getElementsByClassName('table-n-row-r-cell-c'); should return one and only one cell from the DOM.
Any method available to you as valid as long as:

Access to one of the difficulty levels has been done through Chrome (84.0.4147.89)
The URL of the browser and the page displayed doesn't change
A call to document.getElementsByClassName('table-n-row-r-cell-c'); returns only one element

Output Examples
For this example we're using the easy level as input.
The abbreviated output in the DOM should be.
<!DOCTYPE html>

    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>Code Golf Challenge</title>

                1
                ...

                11
                12
                ...

            ...

There are only  and  elements used as cell elements for the challenge.
As long as document.getElementsByClassName('table-n-row-r-cell-c'); returns an element with this class, we're good to go.
Qualifying Entries
All entries need to have an execution speed of under 40 seconds for at least one difficulty level to qualify.
Timing starts when your algorithm starts, but after the page has loaded completely as all elements must be available (the browser spinner has stopped spinning).
Calculate the runtime for your method by calling performance.now() before and and after your injection method, and subtracting the first from the second as in the example below.
let t0 = performance.now();
doSomething()   // <---- The function you're measuring time for
let t1 = performance.now();
let totalTime = t1 - t0;

Winner
The entry that handles the highest difficulty within 40 seconds wins. Ties are broken by execution time at that difficulty.

It was. Then it was asked to be posted in the sandbox for review, I deleted it and posted it in the sandbox for review. It was reviewed by @Bubbler and  FryAmTheEggman . Additions and edits were made according to their suggestions.
Is there any reason that it doesn't meet standards now?

@FryAmTheEggman is there any reason that this doesn't meet standards after our review and discussion?

I totally forgot, welcome back to CG.SE!

Ignoring the specifics of this question, it is generally recommended that you keep a submission in the Sandbox for around 3 days, just to make sure that plenty of people have the chance to read over it. Furthermore, it doesn't hurt to advertise in chat asking for feedback on Sandboxed proposals. For next time, I would definitely recommend sticking by the general recommendations (i.e. 3 days, or a score of +3) for how long you should leave a proposal in the Sandbox

Well, you did not make each change that was suggested, but generally this is much better. I think there are some clarity issues, which might be a part of why you are receiving downvotes. Since I am not particularly familiar with this area I can't really suggest how to improve that.

@FryAmTheEggman I did add the changes. You it was recommended for clarity on the JS function, that was added. No bonuses or penalties for different difficulty levels (that was modified as asked). More accurate way to measure time, that was modified as well. The levels are still there, but there is no bonus, they are just used for tie breakers suggested by Bubbler.

Ah, sorry, I missed that you changed them to be a tiebreaker. That is not clear immediately from the way you wrote it, since you kept the wording about implementing any one of them. Unless I am misreading something, you also have a typo in the scoring where you say the higher difficulty is the primary condition but higher difficulty is also the tiebreak - presumable one of these should be lower?

@FryAmTheEggman I will fix that typo. Thanks for catching it.

And accounting for the specifics of this question, I'd suggest Sandboxing for much longer than the general guideline of 3 days. This is a fastest-code challenge, which tend to be harder to specify and balance than code golf; it has multiple difficulty levels; and, it deals with a specific language, which restricts who can give feedback on it.

As someone who didn't know what a DOM is, I accept that I'm not the audience for this challenge. But, I'd prefer to realize that immediately on starting to read it. (And while I didn't downvote for this, others might have.) Note that because tags are displayed at the bottom of a question (which I wish SE would change), it's not immediately clear from the intro section that this is a language-specific question for Javascript, dealing with browsers and CSS. So I'd suggest putting a sentence about that at the very start, noting there that this challenge is about fastest execution.

May I assume all tables contains exactly 10 rows, 1 thead, 1 tbody after thead, 1 row in thead, 9 rows in tbody, 10 cells in each row?

About 200 ms
function mark() {
  var t = 0, tp = '';
  var c = [], i = { r: 0, p: '', c: 0 };
  var elements = document.body.getElementsByTagName('*');
  var length = elements.length, index, v;
  for (index = 0; index < length; ++index) {
    v = elements[index];
    switch (v.tagName) {
      case 'TH':
      case 'TD':
        v.className = i.p + i.c++;
        if (i.c == 10 && i.r == 10) {
          i = c.pop();
        }
        continue;
      case 'TR':
        v.className = i.p = i.t + i.r++;
        i.c = 0;
        i.p += '-col-';
        continue;
      case 'TABLE':
        v.className = tp = 'table-' + t++;
        tp += '-row-';
        c.push(i);
        i = { t: tp, r: 0, p: '', c: 0 };
    }
  }
}

If your code runs more than 2s, you must do something wrong. I believe.