text:
Make a rectangle from a collection of (sliced) squares
Inspired by Make a Rectangle from a Triangle.
Task
There is a famous formula on the sum of first \$n\$ squares:
$$
1^2 + 2^2 + \dots + n^2 = \frac{n(n+1)(2n+1)}{6}
$$
It is known that this number is composite for any \$n \ge 3\$.
Now, imagine a collection of row tiles (a tile of shape \$1 \times k\$ with the number \$k\$ written on each cell), and you have 1 copy of size-1 tile, 2 copies of size-2 tiles, ... and \$n\$ copies of size-\$n\$ tiles.
[1]  [2 2]  [2 2]  [3 3 3]  [3 3 3]  [3 3 3] ...

Then arrange them into a rectangle whose width and height are both \$ \ge 2\$. You can place each tile horizontally or vertically.
+-----+---+-+-+
|3 3 3|2 2|1|2|
+-----+---+-+ |
|3 3 3|3 3 3|2|
+-----+-----+-+

Output such a matrix if it exists. You don't need to indicate the boundaries; just output the resulting matrix of integers. Your program may do whatever you want if the solution doesn't exist.
I believe there exists a solution for any \$n \ge 3\$. Please let me know if you find a proof or counterexample!
Standard code-golf rules apply. The shortest code in bytes wins.
Examples
n = 3: (2x7 example)
3 3 3 3 3 3 1
3 3 3 2 2 2 2

n = 4: (3x10 example)
4 4 4 4 4 4 4 4 2 2
4 4 4 4 3 3 3 2 2 1
4 4 4 4 3 3 3 3 3 3

n = 5: (5x11 example)
5 5 5 5 5 4 4 4 3 3 3
5 5 5 5 5 4 4 4 3 3 1
5 5 5 5 5 4 4 4 3 3 2
5 5 5 5 5 4 4 4 3 3 2
5 5 5 5 5 4 4 4 4 2 2

n = 6: (7x13 example)
6 6 6 6 6 5 5 5 5 5 3 3 3
6 6 6 6 6 5 5 5 5 3 3 3 1
6 6 6 6 6 5 5 5 5 4 3 3 3
6 6 6 6 6 5 5 5 5 4 4 4 2
6 6 6 6 6 5 5 5 5 4 4 4 2
6 6 6 6 6 5 5 5 5 4 4 4 2
6 6 6 6 6 6 4 4 4 4 4 4 2

related but different: https://codegolf.stackexchange.com/q/143216/15599

Seems like $n=10$ is either very hard or has no solution.

A solution for n=10 @Arnauld I'm working on an explicit construction, but not completed yet.

@newbie Nice. Well, my algorithm either finds a solution almost instantly or after a looooooong time for some values (10, 33, 34, 41...). ¯\(ツ)/¯

The title is wrong: you are making a rectangle from rectangles, not squares

@isaacg Do you have any better title?

@Bubbler "Make a thick rectangle from a collection of thin rectangles"

@Bubbler or just "Make a rectangle from a collection of tiles"?

It sure seems like there ought to be some nice geometrical reason this always works, similar to the proofs for sum of squares and cubes themselves.  Have you posted on math stackexchange?

Python 2, 238 ... 186 bytes
-2 bytes thanks to @Arnauld!
-5 bytes thanks to @ovs!!
-6 bytes thanks to @Jonathan Allan!!
n=input()
p=w=~n*n*(~n-n)/6
e=range(n+1)
def f(a,b,c,d=[]):1>a>exit(c);1>b>f(a-1,w,c+[d]);g=n;exec"e[g]-=1;g<=b>-1<e[g]>f(a,b-g,c,d+[g]*g);e[g]+=1;g-=1;"*n
while 1:1>p%w>f(p/w,w,[]);w-=1

Try it online!
Notice that the above code only used horizontal tiles. To prove it's correct...

C++ (gcc), 4355 bytes
This code is an explicit construction using only horizontal tiles for \$n>6\$. It can produce correct solutions (at least) up to \$n=99\$.
#include <bits/stdc++.h>
using namespace std;
void dim(int x,int&p,int&q)
{
	int u[]={x,x+1,x+x+1},o=0;
	while(u[o]%2) ++o; u[o]/=2;
	o=0; while(u[o]%3) ++o; u[o]/=3;
	sort(u,u+3);if(x%3==1)swap(u[0],u[1]);
	p=u[0];q=u[1]*u[2];
}
int o[100][99999],c[99999],g[99999];
void brute(int n,int& v,int& u,bool t)
{
	for(int i=1;i<=n;++i) c[i]=i;
	if(t)
	{
		u=n*(n+1)*(2*n+1)/6,v=2;
		while(u%v) ++v;
		if(n>=5) v=u/v;
		u/=v; c[2]-=n==6;
	}
	for(int i=1;i<=v;++i)
	{
		int s=u,cnt=0;
		for(int j=n;j>=1;--j) while(s>=j&&c[j])
		{
			s-=j, --c[j]; for(int k=j;k--;) o[i][++cnt]=j;
		}
	}
	c[2]+=t&&n==6;
	for(int i=u;i>=u-1&&i;--i)
		for(int j=1;j<=v;++j) if(!o[j][i])
		{
			int x=0; while(!c[x]) ++x;
			--c[x]; int l=x; --j;
			while(l--) o[++j][i]=x;
		}
}
int s0[99999],s1[99999];
//find a subset of a with sum b
//guaranteed b is half of a's sum
//guaranteed a is consecutive
pair<vector<int>,vector<int>> solve2(vector<int> a,int b)
{
	if(!a.size()) return make_pair(a,a);
	int w=0,s=0,as=a.size();
	for(int i=0;i<as;++i)
		s0[i+1]=s0[i]+a[i],
		s1[i+1]=s1[i]+a[as-1-i];
	while(w<a.size()&&s+a[w]<=b)
		s+=a[w++];
	assert(w!=a.size()&&w>0);
	for(int l=0;l<w;++l)
	{
		int r=w-1-l;
		int p=s0[l]+s1[r];
		if(p>b) continue;
		int q=b-p;
		if(!(a[l]<=q&&q<=a[as-r-1]))
			continue;
		//first l, last r, q.
		vector<int> A,B;
		for(int j=0;j<l;++j) A.push_back(a[j]);
		A.push_back(q);
		for(int j=as-r;j<as;++j) A.push_back(a[j]);
		for(int j=l;j<as-r;++j)
		{
			if(a[j]==q) q=-1;
			else B.push_back(a[j]);
		}
		return make_pair(A,B);
	}
	assert(0);
}
int main()
{
	int n,p,q;
	cin>>n;
	assert(n>=3);
	if(n<=6) brute(n,p,q,1);
	else
	{
		if(n%3==1)
		{
			int x=n%3,pp,qq;
			dim(x,p,q);
			brute(x,p,q,0);
			while(n!=x)
			{
				//x+1...x+3
				int xx=x+3; dim(xx,pp,qq);
				assert(pp-p==2&&qq-q==x*3+6);
				for(int i=x+1;i<=x+3;++i) c[i]=i;
				int mr=x/6;
				for(int i=1;i<=p;++i)
				{
					int cnt=q;
					vector<int> rv;
					if(i<=mr) rv=vector<int>{x+2,x+2,x+2};
					else rv=vector<int>{x+1,x+2,x+3};
					for(int j:rv)
					{
						assert(c[j]); --c[j];
						for(int k=j;k--;) o[i][++cnt]=j;
					}
				}
				vector<int> rv;
				for(int i=x+1;i<=x+3;++i)
					for(int j=c[i];j;--j) rv.push_back(i);
				pair<vector<int>,vector<int>> s=solve2(rv,qq);
				for(int i=p+1;i<=pp;++i)
				{
					int cnt=0;
					for(auto j:(i==pp)?s.first:s.second)
					{
						assert(c[j]); --c[j];
						for(int k=j;k--;) o[i][++cnt]=j;
					}
				}
				p=pp; q=qq; x=xx;
			}
		}
		else
		{
			int x=n%6,pp,qq;
			dim(x,p,q);
			brute(x,p,q,0);
			while(n!=x)
			{
				int xx=x+6; dim(xx,pp,qq);
				if(n%6==0)
					assert(pp-p==1&&qq-q==24*x+90); //[1 2 3 4 5 6]*3+[2 3 5 5 6 6]
				else if(n%6==2)
					assert(pp-p==2&&qq-q==12*x+39); //[1 2 3 4 5 6]+[1 1 2 3 5 6]
				else if(n%6==3)
					assert(pp-p==2&&qq-q==12*x+45); //[1 2 3 4 5 6]+[1 2 4 5 6 6]
				else if(n%6==5)
					assert(pp-p==1&&qq-q==24*x+78); //[1 2 3 4 5 6]*3+[1 1 2 2 4 5]
				else assert(0);
				vector<int> uv;
				if(n%6==0) uv=vector<int>{2,3,5,5,6,6};
				else if(n%6==2) uv=vector<int>{1,1,2,3,5,6};
				else if(n%6==3) uv=vector<int>{1,2,4,5,6,6};
				else uv=vector<int>{1,1,2,2,4,5};
				for(int j=1;j<4/(pp-p);++j)
					for(int k=1;k<=6;++k) uv.push_back(k);
				for(int i=x+1;i<=x+6;++i) c[i]=i;
				for(int i=1;i<=p;++i)
				{
					int cnt=q;
					for(auto j_:uv)
					{
						int j=j_+x;
						assert(c[j]); --c[j];
						for(int k=j;k--;) o[i][++cnt]=j;
					}
				}
				vector<int> rv;
				for(int i=x+1;i<=x+6;++i)
					for(int j=c[i];j;--j) rv.push_back(i);
				if(pp-p==2)
				{
					pair<vector<int>,vector<int>> s=solve2(rv,qq);
					for(int i=p+1;i<=pp;++i)
					{
						int cnt=0;
						for(auto j:(i==pp)?s.first:s.second)
						{
							assert(c[j]); --c[j];
							for(int k=j;k--;) o[i][++cnt]=j;
						}
					}
				}
				else
				{
					int i=pp,cnt=0;
					for(auto j:rv)
					{
						assert(c[j]); --c[j];
						for(int k=j;k--;) o[i][++cnt]=j;
					}
				}
				p=pp; q=qq; x=xx;
			}
		}
	}
	cerr<<p<<","<<q<<"\n";
	for(int i=1;i<=p;++i,cout<<"\n")
		for(int j=1;j<=q;++j)
			cout<<setw(2)<<o[i][j]<<" ";
	if(n>6)
	{
		for(int i=1;i<=n;++i) c[i]=i;
		for(int i=1;i<=p;++i)
			for(int j=1;j<=q;++j)
			{
				int u=o[i][j];
				assert(u>=1&&u<=n);
				for(int k=2;k<=u;++k)
					assert(o[i][++j]==u);
				--c[u];
			}
		for(int i=1;i<=n;++i) assert(!c[i]);
	}
}

Try it online!

How does the construction work?
It's an incremental construction. Consider \$n \bmod 6\$, we can have these values for height and width of rectangles:

\$n/6\times (n+1)(2n+1)~(n\bmod 6=0)\$
\$(2n+1)/3\times n(n+1)/2~(n\bmod 6=1)\$
\$(n+1)/3\times n(2n+1)/2~(n\bmod 6=2)\$
\$n/3\times (n+1)(2n+1)/2~(n\bmod 6=3)\$
\$(2n+1)/3\times (n+1)n/2~(n\bmod 6=4)\$
\$(n+1)/6\times n(2n+1)~(n\bmod 6=5)\$

(dimensions might be \$1\$ for \$n\leq 6\$ so these small cases are handled manually)
So the main idea of my construction is:

We construct rectangles with the heights and widths as in above list.
If \$n\bmod 3 \neq 1\$, construct the solution for \$n-6\$ recursively, add in \$n-5,n-4\cdots n\$. The height of the rectangle will only increase 1 or 2.
If \$n\bmod 3=1\$, construct the solution for \$n-3\$ recursively and add in \$n-2,n-1,n\$. The height of the rectangle will only increase 2.
We first carefully assign the new numbers to the added columns, and then put rest of the numbers into one or two added rows.

The rest of the job is some careful casework to pick the numbers. These details are left as an exercise to the readers (Be ready for some long and tedious casework!). If you complete all the details, this should become a formal proof for the existence of the solutions (and using only horizontal tiles!).

you can save 2 bytes with p=~n*n*(~n-n)/6

You can get rid of the if statements in f: 1>a>exit(c);1>b>f(a-1,bb,c+[d],bb);g=n.

I see what you mean, thanks! @ovs

A somewhat complicated 1 byte save removing the multi-line while here

...in fact, save 3 more removing the and I used here

Start wide and save 2 more

@Arnauld No it won't, it will find bogus results

As a bonus starting wide gives results much more quickly too - 7-44 no longer time out (45 is where we hit default recursion limits).

2 bytes shorter and a lot slower by replacing the while loop with exec.

Seems starting wide and just greedily placing tiles for each row can straightly find answer for... 8-357. @JonathanAllan Thanks!

This backtrack is surprisingly fast. My c++ port can find answer for 2-3000 with lightning speed :o

JavaScript (ES6), 188 bytes
A shorter version inspired by @newbie's answer.
f=(n,w=2)=>(g=(h,a,m,r=[])=>h%1||r[w]?1:r[w-1]?--h*g(h,a,M=[...m,r]):a.every((_,j,[...a])=>a[j]++>j++||g(h,a,m,[...r,...Array(j).fill(j)])))(n*(~n-n)*~n/6/w,Array(n).fill(0),[])?f(n,w+1):M

Try it online!
Commented
f = (                           // f is a recursive function taking:
  n, w = 2                      //   n = input, w = width of matrix
) => (                          //
g = (                           // g is a recursive function taking:
  h, a,                         //   h = height of matrix, a[] = array of counters
  m, r = []                     //   m[] = matrix, r[] = current row
) =>                            // (g returns 0 for success or 1 for failure)
  h % 1 ||                      // if h is not an integer or
  r[w] ?                        // the length of r[] is w + 1 (i.e. r[] is too long):
    1                           //   abort
  :                             // else:
    r[w - 1] ?                  //   if the length of r[] is w:
      --h *                     //     decrement h and force success if h = 0
      g(                        //     do a recursive call with:
        h, a,                   //       h and a[] unchanged
        M = [...m, r]           //       a new matrix M[] with r[] appended
      )                         //     end of recursive call
    :                           //   else:
      a.every((_, j, [...a]) => //     for each entry at position j in a[]:
        a[j]++ > j++ ||         //       unless a[j] is greater than j,
        g(                      //       do a recursive call with:
          h, a, m,              //         h, a[] and m[] unchanged
          [ ...r,               //         j added j times to the current row
            ...Array(j).fill(j) //         NB1: both j and a[j] where incremented above
          ]                     //         NB2: a[] is a local copy defined in this loop
        )                       //       end of recursive call
      )                         //     end of every()
)(                              // initial call to g with:
  n * (~n - n) * ~n / 6 / w,    //   h = n(n+1)(2n+1) / 6 / w
  Array(n).fill(0),             //   a[] initialized to n 0's
  []                            //   an empty matrix
) ? f(n, w + 1) : M             // return M[] on success, or try again with w + 1

JavaScript (ES6),  297  287 bytes
A brute-force search, which always try to put the biggest available rectangles first.
f=(n,i=2,k=n*(~n-n)*~n/6,A=n=>n?[0,...A(n-1)]:[])=>k%i||!(g=(m,a,x,y=m.findIndex(r=>r.some(v=>!v*~++x,x=-1)))=>~y?a.some((v,j)=>[0,1].some(r=>v<(o=n-j)&o<=(r?i-y:k/i-x)&&g(M=m.map(r=>[...r]),b=[...a],b[(h=p=>p--?h(p,M[y+r*p][x+!r*p]=o):j)(o)]++))):1)(A(i).map(_=>A(k/i)),A(n))?f(n,i+1):M

Try it online!

Wolfram Language (Mathematica), 148 bytes
finds random matrix with only horizontal tiles.
It is very slow for n>5 but this is code-golf...
(While@!MatrixQ[Join@@@(w=TakeList[d=RandomSample@Flatten[Table[#~Table~#,#]&/@Range@#,1],r=RandomChoice@IntegerPartitions[#(#+1)/2][[2;;-2]]])];w)&

Try it online!
here is also a very quick random generator for test cases up to 6
Wolfram Language (Mathematica), 97 bytes
(While@!MatrixQ[Join@@@(w=Partition[RandomSample@Flatten[Table[#~Table~#,#]&/@Range@#,1],3])];w)&

Try it online!


text:
Sum in 2540 sums
This is my attempt to pair code-shuffleboard with code-golf.
You need to write a full program or function that sums all codepoints of the input string. If there is no input, you can output any number, including 0.
Rules

The input will always be in printable ASCII.
The sum of the codepoints of your source must be exactly 2540.

If your language uses its own code page, you should use it to calculate your program's codepoints.
If you used Unicode in your code you have to use Unicode bytes to calculate your program's length.

Null bytes (which don't contribute to your codepoint sum) are banned.
The program must not work with any consecutive substring removed.
The conversion of codepoints are required.
This is code-golf. Your score is the length of your source code, the shorter being better.

Does it need to be a complete program?  Some of the answers are functions.

If I'm using 05AB1E, do I have to count it in the SBCS?

Is there any reason you picked 2540? Just curious.

This doesn't seem to meet the precise definition of [tag:pristine-programming] in the tag wiki since pp requires the program to error while this requires the program to not work.  Not sure though if the tag wiki should be editted or the tag should be removed.

If there is no input, is it required to output 0?

Seems there're some other problems with [tag:pristine-programming] that requires the program to not work.

Some answers are accepting an array of integer code-points while most are performing conversion from strings, are the former acceptable or is the conversion to code-points a requirement?

About the score being the length of the code, does that mean I can use a character count instead of bytes?

Python 3, 11 10 9 bytes
Thanks @MariaMiller for finding the right Unicode character, saving 1 byte!

ࠂ,=sum,

Try it online!
This is essentially just sum, padded with extra characters to reach the sum of 2540. Usage is ࠂ(s) where s is a byte string (which acts like both string and integer array). Feels kinda cheaty, but ¯\_(ツ)_/¯.
The first character in source code is the Unicode character with codepoint 2050 (Samaritan letter Gaman). This character might not be displayable depending on your browser.

The previous solution is longer but has nice Unicode characters:
11 bytes

ϕ,ϴ=sum,9

Try it online!

9 bytes

Haskell, 25 bytes
b~zw=sum(fromEnum`map`zw)

Try it online!
The ~ is not an infix operator, but a marker for a lazy pattern match on argument zw of b, while conveniently being the largest-valued ASCII character at 126. The infix-ized `map` is also used because the backtick has a large ASCII value of 96. With both of these, we can avoid any spaces or other whitespace, which have low ASCII values.
The dense 24-byter
z~zz=sum$fromEnum`map`zz

comes just short in its sum of 2525, 15 too small. Its average ASCII value is 105.21, with the only values below 97 (for a) being = at 61, $ at 36, and E at 69. An improvement would like involve finding an alternative for one of these.
(Non-ASCII characters can surely do better by having higher character values, but I'm not doing that because this is more interesting.)

22-byte Haskell version with non-ascii btw.

Brain-Flak, 32 bytes
<[[[{({}()<>)<>}<>({{}[()]})]]]>

Try it online!
Explanation
First the observations I made my first time around (that solution and its explanation is below) continue to be important here. We need and even number of () pairs for a valid answer.
This time however we are going to use a starting program that already has an even number of ()s.
{({}()<>)<>}<>({{}[()]})

This program first increments every element by 1 then calculates the sum of 1 less than every element.  If we look at all possible ways to delete from this without causing a bracket mismatch here are what they do:
{(()<>)<>}<>({{}[()]}) # Never halts
{({}<>)<>}<>({{}[()]}) # Sums 1 less than every element
{({}())<>}<>({{}[()]}) # One more than above
{({}()<>)}<>({{}[()]}) # Never halts
{({}()<>)<>}({{}[()]}) # No output
{({}()<>)<>}<>({[()]}) # Never halts
{({}()<>)<>}<>({{}[]}) # Complex output still incorrect
{(<>)<>}<>({{}[()]})   # Never halts
{({})<>}<>({{}[()]})   # Sums 1 less than every element
{({}()<>)<>}<>({{}})   # Sums 1 more than every element
{()<>}<>({{}[()]})     # Sums 1 less than every element
{({}()<>)<>}<>({})     # Adds 1 to every element
{<>}<>({{}[()]})       # Sums 1 less than every element
{({}()<>)<>}<>()       # Adds 1 to every element
{}<>({{}[()]})         # Outputs 0
{({}()<>)<>}<>         # Adds 1 to every element
<>({{}[()]})           # Outputs 0
{({}()<>)<>}           # Outputs nothing
({{}[()]})             # Sums 1 less than every element

So this is a good starting place.  To make it the correct sum I use the same method I outlined for the first attempt.

Now we just need the proper combination of [..]s <..>s and ((..){}){}s to hit 2540.  Unfortunately while [..]s would be ideal seeing as they have the highest codepoint average I can't seem to get it to work with any of them present.

This time we are luckier and the winning combination is <[[[..]]]>.
Brain-Flak, 34 bytes
<<<<<<<<(((({{}})){}){}){}>>>>>>>>

Try it online!
Explanation
The code that does the task is ({{}}).  But we need to pad it to 2540.  The main issue is that apart from () every pair has an even total.  This means we need and even number of () pairs, and at the same time our starting code uses only 1 () pair.
On top of this unlike [] or <> () pairs are not so easy to add.  The one way we can do that is to wrap the entire program in (..){}, so to rectify our issue we alter the base program to
(({{}})){}

Now we just need the proper combination of [..]s <..>s and ((..){}){}s to hit 2540.  Unfortunately while [..]s would be ideal seeing as they have the highest codepoint average I can't seem to get it to work with any of them present.  The one that works is the one used above.

Is there a way to make {...{foo<>}...}<> work as padding?

I started with {({{}})(<>)}<>  (with an extra () to make things even) and ran a program which determined that there was no way to add {}s, <>s and []s which resulted in the correct amount

@Nitrodon I realized that I can also add ()s in even amounts so I ran it again and got <<[[[[{{({{}})(((<>)))}}]]]]>><>, which is still 32 bytes.

C# (Visual C# Interactive Comρiler), 13 bytes
I had to abuse the IO so that C# can be comρetitive once in its entire existence. Takes char codes as ints as inρut. To make this seem less terrible, this acceρts any IEnumerable<int> instead of only an array.

ρ=>ρ.Sum();

Try it online!
Alternatively, for less byte savings (30 bytes):
This includes the most descriptive variable name ever on this website.

strS=>strS.Select(p=>+p).Sum()

Try it online!

Did you just mispell Compiler into Comriler? Also comretitive, accerts (ρ is rho in greek.)

Nope, the homoglyph attack is intentional.

If I remove the last ;, I get a lambda that just works as well. But it shouldn't be working according to the rules.

05AB1E, 17 bytes
žĆs"þþþþþx"g6QôkO

Try it online!
This was made by Kevin Cruijssen.
Explanation
žĆ                # Push codepage
  s               # Swap
   "þþþþþx"       # Push a string of length 6
           g      # Get the length of the string (6)
            6Q    # And compare it with 6 (True -> 1)
              ô   # Split into chunks
               k  # Index into the codepage
                O # Sum

Original idea, 63 48 36 29 bytes
-15 bytes by using 1! and replacing the !.
-12 bytes by dropping the factorial entirely, and using ≠ instead of 1.
-7 bytes by using тн and replacing the н. I'm not sure if this is allowed though, because with no input, it just outputs 49.
тžĆ"ʒʒʒʒʒʒʒʒʒʒKþþþ"gè.VôžĆskO

Try it online!
Explanation
т                             # Push 100
 žĆ                           # Push the codepage
   "ʒʒʒʒʒʒʒʒʒʒKþþþ"           # Push a string of length 14
                   g          # Get the length of the string
                    è         # Index into the codepage (н)
                     .V       # Run н (first digit of 100)
                       ô      # Split into chunks of 1
                        žĆ    # Push codepage
                          s   # Swap with input
                           k  # Find each char in codepage
                            O # Sum

17 bytes

brainfuck, 41 39 bytes
(I haven't tested exhaustively)
Uses 3 strategies for wasting the codepoint sum: repeating all < and >, nesting the innermost [ and ] unneccessarily, and adding and later removing the same number to/from the output.
Runs in an interpreter with large cells and wrapping/bidirectional memory, which TIO isn't :(. Outputs by charcode.
++++++[[[[[[[<<<+>>>-]]]]]],]<<<------.

Java (JDK), 25 bytes
Ƌ->Ƌ.codePoints().sum()

Try it online!
All alternatives I tried failed:
s->s.chars().sum() // Function<String,Integer>
s->s.sum()         // Function<IntStream,Integer>
java.util.stream.IntStream::sum
...

I just came up with an identical answer only to scroll down and find yours here. :)

For the IntStream, 13 bytes

@MariaMiller Thanks, but l->l.sum() (without the semi-colon) is also a valid lambda, so that answer is invalid because the rules say that there may not be a substring of the answer that also works.

Okay, here's another one that doesn't violate that rule

Python 3, 26 bytes
lambda ŏ:sum(ŏ.encode())

Try it online!

Python 2, 28 bytes
lambda	eZ:sum(bytearray(eZ))

Try it online!

Hopefully it's fixed now :\

Looks like the sum of this code is 2450? The alternative seems to work out to the specified 2540.

I don't think your non-printable answer sums to 2540, since Ì has code point 204. I replaced it the correct code point 335. TIO.

Thanks for that, @Surclose Sputum. IDK why I keep messing up my answer :(

That's because your function only works with ASCII characters. For UTF-8 encoding, an ASCII character is encoded into 1 byte that is the same as its codepoint. However, a non-ASCII character is encoded into multiple bytes. Here is a demonstration.

Python 2, 28 bytes
lambda	zva:sum(map(ord,zva))

Try it online!
Uses a tab after the lambda.

Your code contains 2 newlines, which could be removed. The actual sum without newlines is 2520. "The program must not work with any consecutive substring removed".

@GB Nice catch, fixed.

Ruby -nl, 28 26 bytes
-2 bytes from GB.
p $_.chars.sum{|ay|ay.ord}

Try it online!

-2 bytes: use p instead of $> and name your variable 'ya'

Perl 5, 29 bytes
for(split//,<>){$u+=ord}say$u

Try it online!

PHP, 35 bytes
FOR(;$zz=$argn[$u++];)$a+=ORD($zz);

Try it online!
OK I'm cheating a little bit here, but the shorter code I found for PHP having too much codepoints sum already (2549), I'll interpret the question in a litteral sense:

"program or function that sums all codepoints of the input string" -> it is not said I have to display the result, above code actually sums it :D (yeah I know, implicit rules.. well!)
"you can output any number, including 0" -> well I can, but if not forced to, I won't :P

Wolfram Language (Mathematica), 28 bytes
A[J_]:=Tr@ToCharacterCode[J]

Try it online! Defines a named function A that takes a string as input and returns the sum of its ASCII codepoints. ToCharacterCode converts a character to its codepoint (and outputs a list of codepoints when fed a string of characters) and Tr sums them.

GolfScript, 28 bytes
'zzzzzzzzzzzh'+{}/]{+}*1446-

Try it online!

APL (Dyalog Unicode), 15 bytes
üüd←⎕UCS⍞⋄+/üüd

Try it online!
A full program that takes a single line from STDIN as input.
The ASCII characters are shuffled around within the default codepage (along with APL symbols and accented characters), and many useful characters appear at the high half (character value > 128). Accented characters are valid to use in an identifier, and ü has the highest character value among them.
This code achieves "The program must not work with any consecutive substring removed" by separating the Unicode conversion ⎕UCS and sum +/ into two statements.
The character ⎕ alone is over nine thousand (pun intended) in Unicode, so APL can't compete using Unicode scoring.
How it works
üüd←⎕UCS⍞⋄+/üüd
        ⍞        ⍝ Take a line of input from stdin
    ⎕UCS         ⍝ Convert to Unicode codepoints
üüd←             ⍝ Assign to variable
         ⋄       ⍝ Statement separator
          +/üüd  ⍝ Sum

Python, 30 bytes
Works in Python 2 and 3.
lambda abZ:(sum(map(ord,abZ)))

Try it online!
Alternative 30-byter:
lambda aN,b=ord:sum(map(b,aN))

Try it online!

JavaScript (Node.js), 28 bytes
Ă=>eval(Buffer(Ă).join`+`)

Try it online!
Submission only works on ASCII. Although it source code contains non-ASCII.
This one based on code by Arnauld.

JavaScript (Node.js), 31 bytes
s=>Buffer(s).map(c=>w+=c,w=0)|w

Try it online!

Another trivial one.

Red, 37 bytes
func[-][!: 0 forall -[!: ADD ! -/1]!]

Try it online!
Nothing original. - is the input string, ! is the sum. For each character in the input string I add its value to the sum. Red is case insensitive, so I use ADD instead of add (and isntead of the + operator) in order to match 2540. forall iterates over the entire series (list) and at each iteration returns the remaining series - just like cdr in LISP or rest in Racket. That's why I use /1 to obtain the first element in the series.

Charcoal, 15 bytes
ＩΣＥＳ⁺⊗⊗⊗⊗ＬPP⌕γι

Try it online! Link is to verbose version of code. Only works on printable ASCII, so I can't feed it its own source code, even if I could create it in the right code page. Explanation:
   Ｓ            Input string
  Ｅ             Map over characters
              ι Current character
            ⌕   Find index in
             γ  Printable ASCII
    ⁺           Plus
          PP    Literal string `PP`
         Ｌ      Length
     ⊗⊗⊗⊗       Doubled four times
 Σ              Take the sum
Ｉ               Cast to string
                Implicitly print

Hex dump in Charcoal's code page:
C9 91 C5 D3 AB 9E 9E 9E 9E CC 50 50 9B E7 E9

Common Lisp, 42 bytes
(LAMBDA(%)(APPLY'+(MAP'CONS'CHAR-CODE %)))

This was found by trial and error using the following test: basically the code is printed to string, with some spaces removed (but not all, otherwise it parses badly), then it is read back to lisp and evaluated with its own representation.
(let ((string (remove #\space
                      (princ-to-string
                       '(lambda(%)(apply'+(map'cons'char-code %))))
                      :count 6)))
  (values string
          (funcall (eval (read-from-string string)) string)))

This returns both the code as string, and its sum:
"(LAMBDA(%)(APPLY'+(MAP'CONS'CHAR-CODE %)))"
2540

Usually you call map as follows, (map 'list function sequence), where list is the type of result you want to build with map. Any Lisp type can be given, but obviously it should be a sequence. Here I used cons (lists are made of cons cells) to change the count, but the consequence if that is that there will be an error if the input is an empty sequence, since it cannot be expressed as a cons cell.

Ruby, 19 13 12 bytes
->΃{΃.sum}

Try it online!
The weird char probably isn't displayed, so it's ASCII 899.

Oops, now I'm at the top of the ones that aren't cheaty.

><>, 22 bytes
"̛̜"-&57i:&+&1+?.&n;

Try it online!
Contains two two-byte unicode characters, which can't be removed since they are used to set the initial value of the accumulator. Relies on the official interpreter's quirk of normalizing jump coordinates back to 0 if they are outside the code box (for parity).

source: Stack Exchange

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

sort: votes


text:
Mixed fractions without delimiters
Help! I printed a bunch of rational numbers with no spaces or other delimiters other than the / in the fractions. There is, however, good news! All the numbers are positive. There are no improper fractions, every numerator is less than its denominator and any integers are represented directly, not as fractions. Any non-integers greater than 1 are represented as an integer followed by a fraction. Every fraction is reduced to lowest terms, no numerator and denominator have any common factors other than 1.
Using this information, and given a string that I've printed, I need you to tell me what the original numbers could have been. If there are multiple possibilities, I want to know all of them.
Examples
given as input => output.
1 => 1
1/2 => 1/2
12/3 => 1,2/3 and 1 2/3 (or, equivalently, 5/3)
2/34 => 2/3,4 (cannot be 2/34 because 2 and 34 share a factor of 2)
12/35 => 12/35 and 1 2/35 and 1,2/35 and 1,2/3,5
12/345/678/9 => 1,2/3,4,5/6,7,8/9 and 5/3,29/6,71/9 and 5/3,45/67,8/9 and ...
Rules
You can assume there is at least one valid way to delimit the input.
Your results can contain improper or mixed fractions, you can represent 5/3 as 5/3 or 1 2/3. You can use any kind of delimiters, as long as each type of delimiter (start and end of a list, between numbers, between integer and fraction in a mixed fraction, between numerator and denominator in a fraction) is unique and consistent. You can take input from stdin, or function parameters, or command line options. You can print your results, or return them from a function, or even just leave them in a variable.

I was following this challenge fine up until the part where the input could contain multiple /s.  I think this addition is confusing and poorly explained.  Not to mention I think the challenge is more interesting without it.

@AdHocGarfHunter the input is just one or more numbers concatenated. some of the numbers are integers, some fractions, some mixed integer + fraction.

Sorry I do understand it.  I just am critical of it.

It would've been a lot easier if you only required one output..

It would also be much easier without mixed fractions.

Should add every numerator is less than its denominator int o example

Haskell, 480 bytes
c""=[]
c('/':x)=c x
c x|(f,b)<-span(/='/')x=f:c b
i x[]=[[x]]
i x(y:z)=(x:y):z
s[x]=[[[x]]]
s(x:y)=[p|s<-s y,p<-[i x s,[x]:s]]
m[[b],[c]]=[[b++'/':c]]
m[[a,b],[c]]=[[a++'+':b++'/':c],[a,b++'/':c]]
m([b]:((c:d:e):f))=map((b++'/':c):)$m$(d:e):f
m([a,b]:((c:d:e):f))=[p++s|s<-m((d:e):f),p<-m[[a,b],[c]]]
m((x:y):z)=map(x:)$m$y:z
l=length
o i=[o|s<-sequence$map s$c$i,and[n<d&&gcd n d==1|i<-[1..l s-1],
 let[n,d]=read<$>[last$s!!pred i,s!!i!!0]],
 and[l(s!!i)>1|i<-[1..l s-2]],o<-m s]

Try it online!
Haskell, 650 bytes
chunks""=[]
chunks('/':xs)=chunks xs
chunks xs|(front,back)<-span(/='/')xs=front:chunks back

insert x[]=[[x]]
insert x(y:ys)=(x:y):ys

splits[x]=[[[x]]]
splits(x:xs)=[p|s<-splits xs,p<-[insert x s,[x]:s]]

merges[[b],[c]]=[[b++'/':c]]
merges[[a,b],[c]]=[[a++'+':b++'/':c],[a,b++'/':c]]
merges([b]:((c:d:e):f))=[(b++'/':c):s|s<-merges$(d:e):f]
merges([a,b]:((c:d:e):f))=[p++s|
 s<-merges((d:e):f),p<-merges[[a,b],[c]]]
merges((x:xs):ys)=map(x:)$merges$xs:ys

origins input=[m|s<-sequence$map splits$chunks$input,
 and[length(s!!i)>1|i<-[1..length s-2]],
 and[n<d&&gcd n d==1|i<-[1..length s-1],
 let[n,d]=read<$>[last$s!!pred i,s!!i!!0]],m<-merges s]

Try it online!

JavaScript (V8), 188  185 bytes
f=([c,...x],y='')=>c?f(x,y+c)-f(x,y+[,c])-f(x,y+' '+c):y.split`,`.some(e=>e.replace(/(?:[1-9]\d* ?)??(?:([1-9]\d*)\/([1-9]\d*))?$/,g=(_,a,b)=>+a>=b|!_?1:a?g(1,b%a,a):b-1||''))||print(y)

Try it online!

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


text:
Euler's Geometry Puzzle
Today (or tomorrow, depending on your timezone, by the time of posting) is the birthday of the great mathematician and physicist Leonhard Euler. To celebrate his birthday, this challenge is about one of his theorems in geometry.
For a triangle, we define its incircle to be the largest circle inside the triangle and its circumcircle to be the circle that passes through all of the traingle's vertices.
Consider a triangle in a plane, we plot the center of its incircle I (sometimes called incenter) and the center of its circumcircle O (sometimes called circumcenter). Let \$r\$ be the radius of the incircle, \$R\$ be the radius of circumcircle, \$d\$ be the distance between I and O. Euler's theorem in geometry states that \$d^2=R(R-2r)\$.
The challenge
In the spirit of this theorem, your task, is for a triangle given by the lengths of its three sides, output \$d\$ (the distance between incenter I and circumcenter O described above).

Your code needs to take only the length of the three sides of triangle and output \$d\$. Inputs and outputs can be in any reasonable format.
The absolute error or relative error from your output and correct answer must be no greater than \$10^{-2}\$.
It's guaranteed that the three side lengths are positive integers and can form a non-degenerate triangle.
Standard loopholes are forbidden.

Since this is a code-golf, the shortest code in bytes wins!
Examples
In the samples, the outputs are rounded to 3 decimal places. You, however, are free to round them to more decimal places.
[a,b,c]       -> d
[2,3,4]       -> 1.265
[3,4,5]       -> 1.118
[3,5,7]       -> 3.055
[7,9,10]      -> 1.507
[8,8,8]       -> 0.000
[123,234,345] -> 309.109

List of sample inputs:
[[2,3,4],[3,4,5],[3,5,7],[7,9,10],[8,8,8],[123,234,345]]

JavaScript (ES7),  80 74 66  65 bytes
(a,b,c)=>(s=a+b+c,(p=a*b*c/s)*p/4*(s/=2)/(s-a)/(s-b)/(s-c)-p)**.5

Try it online!
How?
This is derived from:

The semiperimeter \$s\$ of the triangle:
$$s=\frac{a+b+c}{2}$$

The circumradius \$R\$ of the triangle:
$$R=\frac{abc}{4\sqrt{s(s-a)(s-b)(s-c)}}$$

The product of the inradius \$r\$ and the circumradius:
$$rR=\frac{abc}{2(a+b+c)}=\frac{abc}{4s}$$

Euler's theorem:
$$d=\sqrt{R(R-2r)}=\sqrt{R^2-2rR}=\sqrt{R^2-\frac{abc}{2s}}$$

Clever... using the perimeter at first, and then halving it.

62 bytes

@newbie Nice! But I think I'll leave this one unchanged, since the shorter version has already been posted by Tim Pederick.

Python 3, 66 bytes
This formerly took advantage of the new assignment expressions ("walrus operator") introduced in Python 3.8. Thanks to commentors, I've taken that out, so it works on previous versions too!
lambda a,b,c:((a*b*c/(b+c-a)/(a+c-b)/(a+b-c)-1)*a*b*c/(a+b+c))**.5

Try it online!
It's based on the same calculations described in Arnauld's answer, but using the perimeter \$p\$ instead of the semiperimeter \$s\$:
$$
\begin{aligned}\\
p&=a+b+c\\
 &=2s
\end{aligned}\\
\therefore d=\sqrt{R^2-\frac{abc}{p}}\\
\text{and } R^2=\frac{\left(abc\right)^2}{p(p-2a)(p-2b)(p-2c)}
$$
The grand total savings of this rearrangement is... two bytes.
Factoring \$p\$ out and expanding the terms in the denominator means I don't have to store \$p\$, saving another three bytes. I also stored the product \$abc\$ in a variable \$m\$, which saved some bytes at first... but it could later be factored out, turning the brackets-and-walrus into a liability, not a savings! Here's the final formula:
\begin{aligned}
d&=\sqrt{\frac{\left(abc\right)^2}{p(p-2a)(p-2b)(p-2c)}-\frac{abc}{p}}\\
&=\sqrt{\left(\frac{abc}{(b+c-a)(a+c-b)(a+b-c)}-1\right)\frac{abc}{p}}
\end{aligned}

70 bytes

@dingledooper: Thanks! I'd just realised the same thing myself: storing $m$ meant that I could multiply by it instead of squaring, saving a byte.

Actually... 66 bytes

@newbie And here I thought factoring out $m$ wouldn't save anything... I hadn't realised that it meant being able to drop a pair of parentheses. Thanks!

@dingledooper: facepalm Thanks. Done.

05AB1E, 23 22 21 20 15 14 bytes
PDIœÆPt/<*IO/t

-5 bytes porting @Neil's Charcoal answer, so make sure to upvote him!!
-1 byte thanks to @Grimmy.
Try it online or verify all test cases.
Explanation:
P              # Take the product of the (implicit) input-list
               #  [a,b,c] → abc
 D             # Duplicate it
  Iœ           # Get all permutations of the input-triplet
               #  [a,b,c] → [[a,b,c],[a,c,b],[b,a,c],[b,c,a],[c,a,b],[c,b,a]]
    Æ          # Reduce each by subtracting:
               #  → [a-b-c,a-c-b,b-a-c,b-c-a,c-a-b,c-b-a]
     P         # Take the product of that
               #  → (a-b-c)(a-c-b)(b-a-c)(b-c-a)(c-a-b)(c-b-a)
               #   → (a-b-c)²*(b-a-c)²*(c-a-b)²
      t        # Take the square-root
               #  → sqrt((a-b-c)²*(b-a-c)²*(c-a-b)²)
       /       # Divide the initially duplicated product by it
               #  → abc/(sqrt((a-b-c)²*(b-a-c)²*(c-a-b)²))
        <      # Decrease it by 1
               #  → abc/(sqrt((a-b-c)²*(b-a-c)²*(c-a-b)²))-1
         *     # Multiply it by the initial product
               #  → abc(abc/(sqrt((a-b-c)²*(b-a-c)²*(c-a-b)²))-1)
          IO/  # Divide it by the input-sum
               #  → abc(abc/(sqrt((a-b-c)²*(b-a-c)²*(c-a-b)²))-1)/(a+b+c)
             t # And take the square-root of that
               #  → sqrt(abc(abc/(sqrt((a-b-c)²*(b-a-c)²*(c-a-b)²))-1)/(a+b+c))
               # (after which it is output implicitly as result)

Or as a single formula:
$$d=\sqrt{\frac{abc\left(\frac{abc}{\sqrt{(a-b-c)^2\times(b-a-c)^2\times(c-a-b)^2}}-1\right)}{a+b+c}}$$

My attempt to port the formula I came up with clocks in at 17 bytes, which is bad, since it's only 18 in Charcoal...

@Neil Nice approach! I got it down to 15 bytes porting your answer. Was about to go eat dinner, so will update it afterwards. :)

Ah, right, I couldn't find · in info.txt, and trying to use x tied the stack into knots, preventing me from using PD. Nice!

@Neil You're not the first one who couldn't find ·; I see answers overlooking it so many times for some reason.. I personally never really use the info.txt but use the wiki Commands page instead (although it is lacking some new builtins every now and then..) Btw, using the x we could still end up at 15 bytes: PDIxsOαP/<*IO/t. ;)

It doesn't help that one says a * 2 and the other says 2 * a...

@Neil Haha, ok, that indeed explains a lot.. You'll have to direct those complains to Adnan, since he made the info.txt file (and 05AB1E language).

IOI·-P => IœÆPt for -1 (verify all)

@Grimmy Oh, nice! Thanks.

Charcoal, 31 18 bytes
Ｉ₂∕×⊖∕ΠθΠ⁻Σθ⊗θΠθΣθ

Try it online! Link is to verbose version of code. Takes input as a vector of doubles and outputs a double. Explanation:
$$ \begin{align}d
&=\sqrt{R(R-2r)}\\
&=\sqrt{R^2-2Rr}\\
&=\sqrt{\left(\frac{abc}{4\Delta}\right)^2-\frac{abc}{2s}}\\
&=\sqrt{\frac{(abc)^2}{16\Delta^2}-\frac{abc}{2s}}\\
&=\sqrt{\frac{(abc)^2}{2s(2s-2a)(2s-2b)(2s-2c)}-\frac{abc}{2s}}\\
&=\sqrt{\frac{abc}{2s}\left(\frac{abc}{(2s-2a)(2s-2b)(2s-2c)}-1\right)}\\
\end{align} $$
where \$ 2s=a+b+c \$ and \$ \Delta=\sqrt{s(s-a)(s-b)(s-c)} \$.
            ⊗θ      `[2a, 2b, 2c]`
         ⁻Σθ        Vectorised subtract from `a+b+c`
        Π           Take the product
     ∕Πθ            Divide `abc` by that
    ⊖               Decrement
   ×          Πθ    Multiply by `abc`
  ∕             Σθ  Divide by `a+b+c`
 ₂                  Take the square root
Ｉ                   Cast to string
                    Implicitly print

Java 8, 67 bytes
(a,b,c)->Math.sqrt(a*b*c*(a*b*c/(b+c-a)/(a+c-b)/(a+b-c)-1)/(a+b+c))

Try it online.
Not much to say. Uses the same formula as in @TimPederick's Python answer, which was based on @Arnauld's JavaScript answer, but which uses a rather similar formula as @Neil's Charcoal answer.
$$d=\sqrt{\frac{abc\left(abc\div(b+c-a)\div(a+c-b)\div(a+b-c)-1\right)}{a+b+c}}$$

Added another level of indirection! T_T

Io, 87 bytes
Port of Arnauld's answer.
method(a,b,c,((y :=b*a*c/(z :=((b+c-a)*(c+a-b)*(a+b-c)/(x :=a+b+c))**.5)/x)*(y-z))**.5)

Try it online!

C (gcc), 76 72 bytes
Saved 4 bytes thanks to ceilingcat!!!
#define f(a,b,c)sqrt(a*b*c*(a*b*c/(0.+b+c-a)/(a+c-b)/(a+b-c)-1)/(a+b+c))

Try it online!
Port of Kevin Cruijssen's Java answer.

APL (Dyalog Unicode), 22 bytes
.5*⍨×/÷+/÷¯1+⊢×.÷+/-+⍨

Try it online!
Yet another port of Tim Pederick's Python answer.
$$
\begin{align}
d&=\sqrt{\left(\frac{abc}{(b+c-a)(a+c-b)(a+b-c)}-1\right)\frac{abc}{a+b+c}} \\
&=\sqrt{\frac{abc}{\frac{a+b+c}{\frac{abc}{(b+c-a)(a+c-b)(a+b-c)}-1}}}
\end{align}
$$
Kind of ugly, but this is precisely what the code does. Requires ⎕DIV←1, i.e. division by 0 gives 0 (otherwise a=b=c case will throw an error).
How it works
.5*⍨×/÷+/÷¯1+⊢×.÷+/-+⍨  ⍝ Input: a 3-length vector [a b c]
                 +/-+⍨  ⍝ (a+b+c) - [2a, 2b, 2c] = [b+c-a, c+a-b, a+b-c]
             ⊢×.÷       ⍝ product([a,b,c] ÷ above)
          ¯1+           ⍝ above minus 1
    ×/÷+/÷  ⍝ product(a,b,c) ÷ (sum(a,b,c) ÷ above)
.5*⍨        ⍝ square root

Forth (gforth), 90 bytes
: f dup 2over * * s>f fdup 3. do dup 2over - - s>f f/ rot loop 1e f- f* + + s>f f/ fsqrt ;

Try it online!
Port of Kevin Cruijssen's Java answer. Since the inputs are positive integers, it takes the input from the data stack and returns the result through the FP stack.
A separate FP stack makes the task a bit easier, but having to work through three alternating sums explicitly is definitely a pain.
In order to copy top three elements, I used dup 2over which converts a b c into a b c c a b. Thankfully I didn't need exactly "3dup" because addition + and multiplication * are commutative, and alternating sums (c - (a - b)) are calculated for all three rotations (abc, bca, cab).
: f ( a b c -- f:result )
  dup 2over * * s>f fdup  ( a b c ) ( f: prod prod )
  3. do dup 2over - - s>f f/ rot loop  ( a b c ) ( f: prod prod/rots )
  1e f- f* + + s>f f/ fsqrt
;


text:
Are you ready to meet the Elite-Four?
To be able to challenge the Elite-4 of top programmers, you need to show your badges first, that qualify you as a potential programmer-master. However, there's a twist. Once you show a badge, it is collected, which means you can't re-show it. So better come prepared! There are n badge collectors, each has a known list of accepted_badges. Given a list of your badges, your task is to find out, if you can access elite-four or if you require more badges. You can indicate this by printing a truthy-value for the first case or a falsey-value in the second case.
Example
accepted_badges: [ [a, b, c], [a, b, d], [d, e, f]]

If you have the badges [a, b, d]  you can pass. Simply give your a badge to the first collector (accepted_badges[0]), your b badge to the second and your d badge to the last collector. So this is a truthy case.
If you have the badges [a, b, c] you are in bad luck. The last collector doesn't accept any of it.
If you have the badges [b, c, d] you can also pass. Here  you will need to give your c badge to the first collector, the b badge to the second and the final collector will get the d badge.
If you have the badges [a, e, f] you will not be admitted, because you would have to use your a badge twice (since the first collector takes it away from you), which is not possible.
Input:

A list* of your badges
  A 2Dlist* of badge collectors and their accepted badges

*list can be the following:
1. a list, i.e. [a, b, c, ...] or [[a,b,c],[c,d,e]]
2. a list with first element = number of elements i.e. [3, a, b, c] or [ [2], [3, a, b, c], [1, a]]
2. a string     "abcd..."
3. a string with leading number of elements i.e. "3abc"
4. a seperated string i.e. "abc,def,ghi"
5. a separated string with leading numbers of elements i.e. "3abc,2ab,5abcdef"
6. or any other convenient input format you can think of

Assumptions:
You may assume:

any list to never be empty
input letters to always match [a-z]
your number of badges matches the number of badge collectors

You may not assume:

that any list is sorted

Test cases (list format):
['a','b','c','d']
[['a','b','c'],['d','e','f'],['b','c','d'], ['c', 'g']]
Truthy

['a', 'a', 'a']
[['a', 'b', 'c'], ['a', 'd', 'e'], ['a', 'b', 'e', 'f']]
Truthy

['a', 'a', 'f']
[['a', 'c', 'f'], ['a', 'd'], ['b', 'c']]
Falsey

['x', 'y', 'z', 'w']
[['x', 'y'], ['x', 'y'], ['z', 'w'], ['x', 'y']]
Falsey

['p', 'q', 'r', 's', 't']
[['p', 'q', 'r'], ['r', 'q', 'p'], ['r'], ['s', 't'], ['p', 'q', 'r', 's', 't']]
Truthy

['p', 'q', 'r', 's', 't']
[['p', 'q', 'r', 's', 't'], ['p', 'q', 'r', 's'], ['p', 'q', 'r'], ['p', 'q'], ['p']]
Truthy

Test cases (String format):
"abcd"
"abc def bcd cg"
Truthy

"aaa"
"abc ade abef"
Truthy

"aaf"
"acf ad bc"
Falsey

"xyzw"
"xy xy zw xy"
Falsey

"pqrst"
"pqr rqp r st pqrst"
Truthy

"pqrst"
"pqrst pqrs pqr pq p"
Truthy

Lastly, this is codegolf so the answer with the least number of bytes wins. Please refrain from using any standard-loopholes.

Would've been nice if the list items in the test cases were already strings....

Added string formatted testcases

Thanks but I meant for them to be quoted :) That way I could copy&paste into the code without having to do much input formatting; these new strings still don't solve my problem :(

Oh of course. Will keep that in mind for future challenges.

Your first test case has 1 too many badges or 1 too few badge checkers.

Whoops, fixed it.

I suggest adding the case [a, e, f] to the example, so it will cover all of the rules.

@Nitrodon with what accepted badges?

I mean the worked example at the top, with the same accepted badges [ [a, b, c], [a, b, d], [d, e, f]].

I think this is already covered by the 3rd test case. What is different?

It's covered by the fourth test case (not the third), but not by the worked example.

I'm not sure allowing 6. as input is a good idea. Somebody is bound to abuse it.

@infinitezero Is this the entrance contest for Elite-Four? It seems to be really hard to solve...

@infinitezero: The [a, e, f] example that Nitrodon is suggesting fails, even though you have a matching badge for every collector, because you can't use your a badge twice (for the first two collectors, who don't accept e or f). This is covered in the test cases but it is missing from the more verbose explanation where you list and explain three examples. I suggest appending this as a fourth explanation to ensure that the explanation contains all of the requirements.

Added the example.

return "no"

05AB1E, 8 bytes
.»â€˜JIå

Try it online!

Python 2, 68 bytes
One of the few cases where itertools is useful.
lambda b,a:s(b)in map(s,product(*a))
s=sorted
from itertools import*

Try it online!

Why do you have f=\ in some separate header?

To call a lambda function, we have to assign a name to it. However in CGCC, we apparently don't need to include the f=. The only time you need to specify its name is in a recursive call.

You know that there's a bounty for this?

Yes, I am in fact aware of that bounty. Unfortunately, it expired long ago, so I doubt that I'm eligible for it.

Python 2, 70 bytes
f=lambda s,l:l and any(f(s.replace(x,'',1),l[1:])for x in l[0])or''==s

Try it online!
Tries every possible character from each list entry in turn, removing it from the target string s if present, and checking if we end up with the empty string. The s.replace(x,'',1) removes at most one copy of x in the string s.
An annoying issue is that in the base case where l==[], we get an error when we try to read l[0] even if the result doesn't matter, making it hard to cut the l and. It "almost" works to save a byte as below, but we get an error when l becomes empty because the l[0] is evaluated before the if l is tested and fails.
f=lambda s,l:s==''or any(f(s.replace(x,'',1),l[1:])for x in l[0]if l)

Try it online!
69 bytes
f=lambda s,l:any(f(s.replace(x,'',1),l[1:]+[[]])for x in l[0])or''==s

Try it online!
Pad l to the right with empty lists.
69 bytes
f=lambda s,h,*t:t and any(f(s.replace(x,'',1),*t)for x in h)or s in h

Try it online!
Takes input as the target string, followed by a splatted list of lists.

69 bytes
f=lambda s,l:any(f(s.replace(x,'',1),l[x in l[0]:])for x in s)or[]==l

Try it online!
A "dual" method based on ovs' solution, iterating over characters in the target string and removing from the list.

Haskell, 54 bytes
import Data.List
(.permutations).any.flip elem.mapM id

Try it online!
Without imports, 85 bytes
x#[]=[[x]]
x#(a:b)=(x:a:b):map(a:)(x#b)
(.foldr((=<<).(#))[[]]).any.flip elem.mapM id

Try it online!

Python 2, 79 bytes
f=lambda a,b:a==[]or any(f(a[x in a[0]:],b[:i]+b[i+1:])for i,x in enumerate(b))

Try it online!

05AB1E, 9 bytes
-1 byte thanks to @KevinCruijssen
œεøε`¢]PZ

Try it online!

Can't really think of a better method either thus far. But you can save a byte by changing the }P}Z to ]PZ: 9 bytes.

Haskell, 66 65 bytes
Port of my Python answer.
-1 byte thanks to @AdHocGarfHunter.

b#(a:s)=or[x!b#s|x<-a,elem x b]
b#x=1>0
x!(a:b)|a==x=b|w<-x!b=a:w

Try it online!

, is shorter than && by a byte.

@AdHocGarfHunter this fails with parse error on input ‘|’. I think replacing && with , only works in guards?

?

@AdHocGarfHunter thanks for helping me out. I was literally replacing && with ,, which obviously didn't work.

Erlang (escript), 138 bytes
Aaargh! Erlang's cartesian product is eeeeevil! (It saved 20 bytes anyway.)
f(A,B)->lists:member(lists:sort(A),[lists:sort(tuple_to_list(C))||C<-sofs:to_external(sofs:product(list_to_tuple([sofs:set(I)||I<-B])))]).

Try it online!
Explanation
Here ... stands for nest the previous line inside this position.
f(A,B)-> % Take 2 items.
[sofs:set(I)||I<-B] % Convert every item of B into a sofs set

list_to_tuple(...) % Convert the input list into a tuple

sofs:product(...)  % Cartesian product of this set tuple

sofs:to_external(...) % Pick the value of the cartesian product

C<-...            % Assign it to the variable C

[lists:sort(tuple_to_list(C))||...] % For every item, convert the tuple to a list
                                    % And then sort that list

lists:member(lists:sort(A),...).    % Is argument 1 a member of the processed list?
```

C (gcc), 170 168 bytes
Edited: Switched to returning 1 from inner main calls to save a byte not needing to negate the return value when assigning into u. Also another byte saved thanks to @ceilingcat for reminding me about index instead of strchr.
f;char*l,*u;main(n,x)char**x;{if(f++){if(n){for(int i=0;l[i];i++)if(u[i]&&index(*x,l[i])){u[i]=0;u[i]=main(n-1,x+1);}return 1;}exit(1);}u=strdup(l=x[1]);main(n-2,x+2);}

Try it online!
A relatively straightforward recursive backtracking search. Takes input as command-line arguments, the first being the list of badges you have in a single character string (e.g. abcd) and each other argument being the list of badges accepted by each station in similar format. Contrary to traditional exit code logic the program's exit code is 0 when you cannot pass and 1 when you can pass, mainly because the return value of main is used in the program and it works out better that way. There is no output on stdout.
Originally I'd written a subroutine for the search part after initializing some state in main but when I abstracted the globals and saw the function signature was int (int, char**) I couldn't resist pulling it all back in and recursing on main.
Degolfed somewhat for viewing pleasure:
f;char*l,*u;                                                // Declare some storage. f is a counter used to only run the setup code on the original call to main. l gets assigned to be a pointer to the list of badges held. u is used as a buffer to track which badges are currently still available to be used.
main(n,x)char**x;{                                          // Typical golfed main declaration.
       if(f++){                                             // Only run the code in the if statement on subsequent calls to main (as a global f defaults to being initialized to 0).
               if(n){                                       // Catch the recursion base case (if n == 0 there are no stations left to pass).
                       for(int i=0;l[i];i++){               // Iterate over the badges we have available. i needs to be declared here since each recursive call needs to iterate over badges separately.
                               if(u[i]&&index(*x,l[i])){   // If the badge is available to be used (the entry in u for the badge is nonzero), and the badge is accepted by the next station...
                                       u[i]=0;              // Mark the badge as unavailable for the recursive call
                                       u[i]=main(n-1,x+1); // Recursively call main with the current station removed. If a sequence passing all stations is found the program exits immediately, so if main returns on an inner call it will always return 1; by assigning this into u we mark the badge as available again afterwards if we backtrack out of this call to continue searching.
                               }
                       }
                       return 1;                            // If we went over all our badges and couldn't get through this station, we need to backtrack the search so return 0 and continue.
               }
               exit(1);                                     // If there are no stations left we passed through all of them so immediately exit with code 1.
       }
       u=strdup(l=x[1]);                                    // Initialize storage for u. Initially I used calloc here, but since the needed length of u is the length of the list of badges held, strdup gets the job done while saving on bytecount (Just with the parity of the usage checks inverted since strdup means all the entries we care about are initialized to nonzero values).
       main(n-2,x+2);                                       // Make the first recursive call, with our new args starting at the first station's accepted badge list.
}                                                           // If we made it to the end without exiting the program, main will default to returning 0 since no return call was specified.

I hoped for a C solution! Great job. I would have never dared to call main() recursively :o

The switch to the ternary operator introduces a bug since setting u[i] to 0 is removed in order to have one statement. Consider the input abcd, ac, def, cd, a; it incorrectly indicates you can pass even though this would require using badge a twice.

162 bytes

Python 3, 85 84 bytes
f=lambda b,r:b==""or any(B in r[0]and f(b[:i]+b[i+1:],r[1:])for i,B in enumerate(b))

Try it online! Golfed 1 byte by switching to an explicit enumeration.

JavaScript (ES6),  69  68 bytes
Takes input as (b)(a), where \$b[\:]\$ are the collector badges as a list of sets and \$a[\:]\$ is our list of badges.
b=>g=a=>1/a||a.some((v,i)=>b[a.length-1].has(v)*g(a.filter(_=>i--)))

Try it online!
Commented
b =>                       // b[] = collector badges as a list of sets
  g = a =>                 // g is a recursive function taking our list of badges
    1 / a ||               // yield +Infinity if a[] is empty
    a.some((v, i) =>       // otherwise, for each badge v at position i in a[]:
      b[a.length - 1]      //   test whether the collector at index a.length - 1
      .has(v) *            //   accepts the badge v
      g(                   //   multiply by the result of a recursive call where:
        a.filter(_ => i--) //     the i-th badge is removed from a[]
      )                    //   end of recursive call
    )                      // end of some()

Charcoal, 37 bytes
Ｓθ⊞υθＦθ«Ｓι≔υη≔⟦⟧υＦηＦΦκ№ιλ⊞υΦκ¬⁼λμ»¿υ¹

Try it online! Link is to verbose version of code. Outputs - if you can challenge the Elite Four. Explanation:
Ｓθ

Read the badges.
⊞υθ

Start with a single entry with all badges remaining.
Ｆθ«

Loop over each guard.
Ｓι

Input the badges he accepts.
≔υη≔⟦⟧υＦη

Save the list of badges remaining so that we can clear it and still loop over the list.
ＦΦκ№ιλ

See whether this guard will accept any of these badges.
⊞υΦκ¬⁼λμ

If so then push the possible sets of remaining badges to the list. (If e.g. two guards both accept the same two badges then this could create duplicates depending on which badge you give to which guard but this does not affect the final result.)
»¿υ¹

If it was possible to give all the guards a badge then print a -.

@Arnauld Usually I remember to paste in the succinct byte count, yes...

Perl 5 -lpa, 86 79 bytes
$"="}{";@a=<>;chomp@a;map{$b=$F[0];$\|=!grep!$_,map$b=~s/$_//,/./g}glob"{@a}"}{

Try it online!
First line of input is the badges you hold.  Subsequent lines are the ones needed.  On each line, badges are comma separated.

Perl 6, 40 bytes
{@^a.permutations.map(*Z∈@^b).max.min}

Try it online!
Explanation
Basic approach is to work out every possible combination of our collectors badges against the other collectors badges and see if any combination is possible.
@^a.permutations computes all permutations of the list of your badges [abcd] -> [[abcd],[abdc]...]
.map(*Z∈@^b) For each of these permutations, zip each element of the resulting list (*Z) with whether each item is present in the corresponding other badge collector's badges (@^b).  [abcd],[[abc][def][bcd][cg]] -> ((True False True False) (True False True True) ...)
.max Return the highest element in the list, i.e. the one with the most Trues.
.min Return the lowest element in this list, i.e. true if all the elements are true, else false.

Python 3, 86 bytes
lambda a,b:any(all(map(str.count,b,c))for c in permutations(a))
from itertools import*

Try it online!
-7 bytes thanks to xnor

It looks like you can use str.count in place of  str.__contains__.


text:
Draw the prime race tracks
Odd prime numbers are either in the form of 4k+1 or 4k+3 where k is a non-negative integer. If we divide the set of odd prime numbers into two such groups like this:
4k+3  |   3     7  11          19  23      31          43  47      59      67  71
      |
4k+1  |      5         13  17          29      37  41          53      61          73

we can see that the two groups are kind of racing with each other. Sometimes the so-called 'upper' group wins and sometimes the 'lower' one is on track. In fact, Chebyshev discovered that in this race, the upper group wins slightly more often.
The problem
Let's assume that we are interested in knowing the shape of this race track up to a certain number. Something like this:

The upper and lower horizontal lines indicate that the next prime stays in the same group, while the slanted lines indicate a 'jump' from one group to the other.
Now assume that the underline character _ represents a lower horizontal line and the overline character ‾ (U+203E) represents an upper one. The slanted lines are represented by slash / or backslash \ characters.
Challenge
Write a program or function that gets a number N as input, and draws this prime race track up to N, in a kind of ASCII-art-form described as above (Well, it's not an actual ASCII-art since it would contain a non-ASCII character).
Rules

N is an integer and not necessarily a prime number. Draw the race path for the primes up to, (and maybe including) N.
For a valid N as input, the output shall only be composed of these four characters ‾_/\. No other character, space or separator is allowed (except maybe at the end of output).
The output can either be in a text file or stdout or wherever supports displaying those characters. But an actual plot (like the blue figure above) is not desired.
This is code-golf, so the shortest code in bytes wins.

Examples
Here is a list of possible inputs and their acceptable outputs.
N < 5        no output or maybe an error message whatsoever
N = 5        \
N = 20       \/‾\_/
N = 100      \/‾\_/‾\/\_/‾\/\/‾\/‾\_

Trivia
The resulting plots of this challenge may actually resemble the derivative of the plots shown in there.

Do we really have to use a non-ASCII character? Can we replace ‾ by -?

@LuisMendo Don't you agree that it would be ugly?

Yes, - is uglier than ‾ in this context. But to me it's even worse to require a non-ASCII character, especially for ASCII-art

@LuisMendo What's your suggestion? Should I change the rules? By the way, this is why I said kind of ASCII-art-form and wasn't implying an actual ASCII-art.

Did you just downvote? Dude...

No, I didn't. But I was tempted

I would have allowed - as a alternative to ‾ (answerer's choice), or maybe I'd have required graphical output (however, it's not advised to allow both ASCII-art and graphical output in the same challenge). Requiring Unicode rules out some languages

Something you might not be aware of is that challenges about primes have been way overdone over the course of this site. So, while I think the ASCII art visualization based on modulus is a nice idea for a challenge, the fact that a solution needs to start with either generating primes or calling a primes built-in means that writing a solution will feel somewhat samey to many past challenges.

To follow with my previous comment, something like \/ \ / \/\ / \/\/ \/ \   (space instead of _ or ‾)  looks quite nice to me. But I guess it's too late to change now, as there are two answers

@xnor I am already thinking about writing an answer in C# and I think a creative way is possible to circumvent the prime built-in problem by noticing that all primes up to a certain number are needed. So I might be able to just check the integer remainder along a saved list. Just a vague idea. I'll give it a try

As others have mentioned, I would indeed advice to use - or ~ instead of ‾. Here another challenge using those same characters where the same is done. The main reason to allow this is to open up the challenge to more languages, because there are quite a few languages that can't even use non-ASCII characters, so they would be unable to complete just because of that single character in an otherwise good challenge.

^ might also be a decent-looking alternative.

To follow @xnor's comment, this seems like a chameleon challenge to me.  If your language doesn't already have a built-in to find primes, most of the code is going to be spent calculating that rather than the output.

Mathematical remark (further reading if desired): we believe that the upper group wins not slightly more often, but in fact about 99.59% of the time.

Downvoted because it's impossible without Unicode, and because the main part of the challenge is seeing if the number is prime or not.

@S.S.Anne they will also need to determine if the number is odd. Eat it

@polfosol Determining if the number is odd is trivial compared to determining if a number is prime. The easiest solution for determining if a number is odd is a modulo by 2, while determining if the number is prime without a builtin at least consists of computing the square of a factorial modulo n. I will not "Eat it" kind sir, thank you for the offer.

05AB1E, 31 26 19 bytes
…\/_ŽW ç«ÀIÅP¦4%üeè

-5 bytes by taking inspiration from @HyperNeutrino's Jelly answer.
-7 bytes thanks to @Grimmy.
Outputs as a list of characters.
Try it online (the J in the footer is to join the list together to pretty-print it).
Explanation:
…\/_                 # Push the string "\/_"
    ŽW               # Push compressed integer 8254
       ç             # Convert it to a character with this codepoint: "‾"
        «            # Append it to the earlier string: "\/_‾"
         À           # And rotate it once to the left: "/_‾\"
          IÅP        # Push a list of all primes <= the input-integer
                     #  i.e. 50 → [2,3,5,7,11,13,17,19,23,29,31,37,41,43,47]
             ¦       # Remove the first value
                     #  → [3,5,7,11,13,17,19,23,29,31,37,41,43,47]
              4%     # Take modulo-4 on each value
                     #  → [3,1,3,3,1,1,3,3,1,3,1,1,3,3]
                ü    # For each overlapping pair:
                     #  → [[3,1],[1,3],[3,3],[3,1],[1,1],[1,3],[3,3],[3,1],[1,3],[3,1],[1,1],[1,3],[3,3]]
                 e   #  Get the number of permutations; short for ⌊a!/|a-b|!⌋
                     #   → [3,0,6,3,1,0,6,3,0,3,1,0,6]
                  è  # And index each into the earlier created string
                     # (0-based and with wraparound, so the 6 is index 2 in this case)
                     #  → ["\","/","‾","\","_","/","‾","\","/","\","_","/","‾"]
                     # (after which the result is output implicitly as result)

See this 05AB1E tip of mine (section How to compress large integer?) to understand why ŽW  is 8254.

Python 2 (IronPython), 87 bytes
I'm using IronPython here to display the unicode character ‾, since Python can't print it.
P=a=b=1
s=''
exec"if P%a:s+='\/‾_'[b%4/2-a%4];b=a\nP*=a*a;a+=1\n"*input()
print s[2:]

Try it online!
Explanation
The idea of calculating primes comes from this answer, which uses Wilson's theorem. To figure out which character to print, we use the following formula: \$ \frac{b \bmod 4} 2 - a \bmod 4 \$, where \$ a \$ and \$ b \$ represent the current and previous prime numbers. Here is a table to show how this works:
 a mod 4 | b mod 4 | a'/2-b'
---------+---------+---------
    1    |    1    |   -1
    1    |    3    |   -3
    3    |    1    |    0
    3    |    3    |   -2

And in Python negative indices wrap around to the end of the string, so each index maps to its own character.

Wolfram Language (Mathematica), 102 bytes
TIO doesn't display U+203E...
""<>(Partition[Prime@Range[2,PrimePi@#]~Mod~4,2,1]/.{{3,1}->"\\",{3,3}->"‾",{1,1}->"_",{1,3}->"/"})&

Try it online!

J, 50 bytes
1('/^\_'{~[:(+_1&|.*1&=)1+2*@-/\4&|)@}.(#~1&p:)@i.

Try it online!
Had to replace ‾ with ^ because the formatting on TIO screws up otherwise.
This uses < N convention.

Jelly, 20 bytes
ÆRḊ%4ḄƝṣ9ị“\/_”j⁽ø¤Ọ

Try it online!
-3 bytes thanks to Jonathan Allan
Explanation
ÆRḊ%4ḄƝṣ9ị“\/_”j⁽ø¤Ọ  Main Link
ÆR                    Primes up to N
  Ḋ                   All but the first (3, 5, 7, 11, ...)
   %4                 Modulo 4
     ḄƝ               Convert each pair (overlapping run of 2) to binary (even though the digits are 1 and 3, this still works because it's just 2 x first digit + second digit) - 1,1: 3; 1,3: 5; 3,1: 7; 3,3: 9
       ṣ9             Split on 9 (the upper bar)
         ị“\/_”       Index into "\/_" (3 is _, 5 wraps around to /, 7 wraps around twice to \)
               j⁽ø¤   Join on 8254
                   Ọ  Convert from char code to character; doesn't affect characters, only the 8254s

8254 can be written as ⁽ø¤ (converter - link also in the tutorial on the wiki)

You can also avoid testing for less than three like this.

@JonathanAllan Oh, that's clever. Also thanks, I keep forgetting about that thing lol.

JavaScript (ES6), 86 bytes
n=>(g=x=>x>n?'':['\\_/‾'[(P=n=>n%--d?P(n):d<2)(d=x)&&(q==(q=x%4))|q&2]]+g(x+1))(q=4)

Try it online!
Commented
n => (                  // n = input
  g = x =>              // g is a recursive function taking the current integer x
    x > n ?             // if x is greater than n:
      ''                //   stop recursion
    :                   // else:
      [                 //   make sure to turn undefined into an empty string
        '\\_/‾'[        //     pick the relevant character:
          ( P = n =>    //       P is a helper function taking n:
              n % --d ? //         decrement d; if d does not divide n:
                P(n)    //           try again until it does
              :         //         else:
                d < 2   //           return true if d = 1 (i.e. n is prime)
          )(d = x)      //       initial call to P with n = d = x
          &&            //       if x is not prime, ['\\_/‾'[false]] ~> empty string
          (             //       if x is prime:
            q ==        //         yield 1 if q is equal to ...
            (q = x % 4) //         ... the new value of q which is x mod 4
          ) | q & 2     //         bitwise OR with q & 2 for the direction
        ]               //     end of character lookup
      ] + g(x + 1)      //   add the result of a recursive call with x + 1
)(q = 4)                // initial call to g with x = q = 4

Python 3.8, 105 103 96 89 88 bytes
f=lambda n,i=3,j=5,t=24:n//j*" "and"\/‾_"[i%4//2-j%4]*(P:=t%j>0)+f(n,[i,j][P],j+1,t*j)

Try it online!
-1 byte thanks to @xnor!
Explanation:
This is a recursive function that increases j from 5 to n. If j is prime,  the function compares it to the previous prime i to determine the race track character.
The following expression evaluates to 1 or 0 depending on whether j is prime or not:
t%j>0

where t is factorial(j-1). This uses Wilson's theorem, taken from @xnor's answer on another prime problem.
Given 2 consecutive prime i and j, the following code determines the character (shamelessly stolen from @dingledooper's answer):
"\/‾_"[i%4//2-j%4]

A one-byte shorter way to handle the base case here is n//j*"?"and.

Thanks @xnor! I tried that before and somehow confused myself into thinking that it doesn't work. :(

Retina 0.8.2, 65 bytes
.+
$*
1
_1$`
^.{6}|_(11+)\1+(?!1)|1111|1(1?)
$2
_1
/1
1/
‾
1_
\

Try it online! Explanation:
.+
$*

Convert N to unary.
1
_1$`

Count up to N, using _ to separate the unary values, thus assuming all odd primes have a remainder of 1 (modulo 4) by default.
^.{6}|_(11+)\1+(?!1)|1111|1(1?)
$2

Delete 1, 2 and their separators; delete all composite numbers and their separators; reduce the odd primes modulo 4, and identify the primes with a remainder of 3 (modulo 4).
_1
/1

Still assuming that the prime previous to a prime with a remainder with 3 has a remainder of 1, change the _ to a /.
1/
‾

But if it turns out that the previous prime also has a remainder of 3, then change the / to a ‾.
1_
\

Any remaining primes with a remainder of 3 must have a next prime with a remainder of 1, so change the _ to a \\.

Erlang (escript), 118 bytes
Erlang doesn't support negative indices so I had to do my own. (Also it doesn't display ‾, so it's replaced with ^.)
p([_])->[];p([H|T])->[lists:nth(H rem 4+1rem(hd(T)rem 4),"_/\\^")|p([A||A<-T,A rem H>0])];p(X)->tl(p(lists:seq(2,X))).

Try it online!
Replaced formula
  a % 4  |  b % 4  | a + 1%b
---------+---------+---------
    1    |    1    |   1
    1    |    3    |   2
    3    |    1    |   3
    3    |    3    |   4

Husk, 26 bytes
J'¯†!"¦/_"x9ẊoB2em%4t↑İp

Try it online!


text:
Conway's Monster
This challenge is in honor of mathematician John Conway who passed away April 11, 2020 due to COVID-19. He was famous for coming up with the Game of Life cellular automaton and many other mathematical contributions such as the surreal numbers and the monster group.
The advanced math of those topics is out scope for this programming challenge, though I strongly recommend people watch the various Numberphile videos about Conway. In one of those videos Conway says that he'd like to know why the monster group exists before he dies. It's unfortunately too late for that now but we can honor his memory in a very small way by exploring in code the strange number associated with the group.
Challenge
The monster group is the largest sporadic simple group in the branch of group theory in mathematics. But the only thing to know for this challenge is that its order, or number of elements it contains is:
808017424794512875886459904961710757005754368000000000

Your task is to write a program that outputs this number. However, to keep this from being trivial, your program may not contain any digits, 0 through 9. That is, your program may not contain any of the ten characters 0123456789.
Your output must be the precise digits of the number:
808017424794512875886459904961710757005754368000000000

or the digits with appropriate commas:
808,017,424,794,512,875,886,459,904,961,710,757,005,754,368,000,000,000

(Commas , are allowed in your code.)
Any usual output method is valid. No input should be required. The shortest program in bytes wins.
If it helps anyone the factorization of the number is:
2^46 * 3^20 * 5^9 * 7^6 * 11^2 * 13^3 * 17 * 19 * 23 * 29 * 31 * 41 * 47 * 59 * 71

(Factorization is not valid output.)

Are non-Ascii digits like ⁴ acceptable?

@JonathanAllan Certainly.

How is this not a duplicate of the 2014 version of this challenge?  The only difference what number is being output.

@AdHocGarfHunter Yeah, to an extent. This number is more complex and may have different strategies - though I understand you could say that about lots of numbers. If the community wants it closed then so be it ¯\(ツ)/¯

I don't consider this a duplicate at all, just another challenge in the same genre. Different target numbers are quite different--ranging from easy targets (like 2014) to theoretically difficult ones (such as incompressible numbers in the sense of Chaitin). Interesting ones would usually be between these two extremes, like this monster challenge. They're like any code-golf puzzle--you need to find hidden patterns in the target that you can exploit. But different numbers have different patterns! (That this challenge can be interesting is borne out by the variety of solutions already posted.)

I'm disappointed there aren't any solutions that actually use the group theory aspect of this number (no clue how to in R which is the only language I'm any good at, but maybe in something like mathematica?)

I feel obligated to link to the real codegolf monster related to John Conway: tetris made in Game of life: https://codegolf.stackexchange.com/questions/11880

For anyone interested, here are all the divisors of Conway's monster whose hexadecimal representation consists of letters exclusively. (Which is what the 2nd version in my answer is based upon.)

Because code golf doesn’t favour unreadable languages enough ;)

It's a pity that an homage to John Conway excludes FRACTRAN, which doesn't have a clearly-defined source encoding but is fundamentally made of integer literals.

Sledgehammer, 4 bytes
 31 bits, to be overly specific
please upvote the author of this awesome language instead of me
⣶⣖⡥⣕

(this is a very awesome Mathematica compressor, and it really excels at compressing code with only a few powerful built-ins)
In this case, the built-ins are GroupOrder and MonsterGroupM, because of course they exist.
In case this somehow helps, the exact bits contained in the code are 01110111 01110101 10110010 1011010, the corresponding Mathematica code is GroupOrder@MonsterGroupM[], and the internal suffix code is call["MonsterGroupM", 0], call["GroupOrder", 1], where 0 and 1 are the argument counts.

Python 2, 61 bytes
Port of Neil's answer.
-5 bytes thanks to @Surclose Sputum!
for i in"  @@G^dddrstuuuvwxxy{|~~~~~":True*=ord(i)
print True

Try it online!

Python 3, 60 58 bytes
Thanks to @Surculose Sputum for saving 2 more bytes!
k=True
for i in b"?G^dddrstuuuvwxxy{|~~~~":k*=i+i
print(k)

Try it online!

61 bytes

60 bytes with a bytestring in Python 3.

@ovs Thanks, funnily enough I tried to use a b-string in Python 2. I guess I forgot that it only works in Python 3.

What is this True*=ord(i)? How does that work?

Somehow in Python2, True and False are modifiable variables. @justhalf

Another 61 byter in Python 2. I tried to gather all cubes into a common string, but couldn't save enough characters. :(

58 bytes in Python 3 by doubling each character before multiplying together.

@SurculoseSputum thanks! Clever improvement

@SurculoseSputum Indeed, it saves me 3 bytes in my answer too!

Bit of a late reply, but for Python 3 you can sub "True" with just 1 because you dont need a modifiable variable that is also a built in any more.

@Underslash Well, the source code cannot contain numbers...

@dingledooper You know, that would make sense :)

Jelly, 21 bytes
⁴Ḥ®x“ÆÑ¥©µ"µ£€× œ‘;Æ¡

Try it online!
How?
$$|M|=13\times 43!+16\times 42!+4\times 41!+6\times 40!+9\times 39!+34\times 38!+9\times 37!+2\times 36!+12\times 35!+17\times 34!+32\times 33!+30\times 32!$$
So...
⁴Ḥ®x“ÆÑ¥©µ"µ£€× œ‘;Æ¡ - Main Link: no arguments
⁴                     - literal 16
 Ḥ                    - double = 32
  ®                   - recall from register = 0
   x                  - times = [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]
    “ÆÑ¥©µ"µ£€× œ‘    - list of code-page indices = [13,16,4,6,9,34,9,2,12,17,32,30]
                  ;   - concatenate = [13,16,4,6,9,34,9,2,12,17,32,30,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]
                   Æ¡ - convert from factorial base to integer

For what it's worth a naive base-250 compression is 25 bytes AND contains digits: “Æ4Ḍ⁹|oGO⁷pNJ6þḤ)Ė⁽u2ẏẏż’

Nice! I didn't know that factorial representation of the number

Neither did I, but I don't think it's all that unexpected for it to have a fairly nice representation in the factorial number system.

Darn, this was the method I was going to use - iterated and descending factorials. Absolutely well done, mate. Very crisp solution!

@Mathgeek go for it - unless your solution was also going to be in Jelly and would be longer I see no reason not to use the same idea!

Charcoal, 32 29 bytes
ＩΠＥ/Gdddrstuuuvwxxy{|~~~~~⊗℅ι

Try it online! Explanation: Converts the characters to their ASCII character codes, doubles them, then takes the product. Edit: Saved 3 bytes by porting @SurculoseSputum's golf of @dingledooper's Python 3 answer.
However, Charcoal can just compress the output text... except that compression of the whole text includes an 8, so you have to print it in two parts:
”)¶″³L⬤j$a◧EτB⊟[βω⁵↓≧Ｏ””|～ⅉE

(Compressing the string in the first program doesn't help as the resulting string contains a digit.)
Try it online! Link is to verbose version of code.

I still see a "6" there.

@Almo Thanks; I discovered that I'd also pasted the wrong link anyway. The new one is a byte longer sadly.

Wolfram Language (Mathematica), 34 32 bytes
Thanks @my pronoun is monicareinstate for shaving 2 bytes!
Someone has to do this...
Print@GroupOrder@MonsterGroupM[]

Try it online!

32 bytes by @ instead of // and []: Try it online!

Alright, thanks! @mypronounismonicareinstate

You can save a few bytes by writing GroupOrder@MonsterGroupM[]&. This is a function (which on here is equivalent to a program by default) that outputs the correct number regardless of the input.

Even shorter would be GroupOrder@*MonsterGroupM, which is the same as Greg Martin's function when called with no arguments

Ruby, 67 bytes
"nn/HM|Q:iv^YxO[e}%W}}WTBn}}}}}}}}".bytes{|i|$><<(i+?A.ord)%?_.ord}

Try it online!
By coincidence, the range of digit pairs is 0 to 94, which only just fits in the ASCII range.
(i+?A.ord)%?_.ord = (i+65)%95. The 65 offset ensures no digit characters in the magic string.
By default numbers are printed without leading zeros, so digit pairs in the range 00..09 require two characters in the magic string. The other digit pairs require one character.

MATL, 35 bytes
'nTIFBCAAAAA@A@A@A@@A'tfYqwIEW-^X$p

Try it online!
Explanation
This uses the prime factorization of the number:
\$ 808017424794512875886459904961710757005754368000000000 \\ = 2^{46} · 3^{20} · 5^9 · 7^6 · 11^2 · 13^3 · 17 · 19 · 23 · 29 · 31 · 41 · 47 · 59 · 71. \$
'nTIFBCAAAAA@A@A@A@@A' % Push this string
t                      % Duplicate
f                      % Indices of nonzero chars: gives [1 2 3 ... 19 20]
Yq                     % n-th prime, element-wise: gives [2 3 5 ... 67 71]
w                      % Swap
IEW                    % Push 3, multiply by 2, exponential with base 2: gives 64
-                      % Subtract, element-wise: subtracts 64 from the code point
                       % of each character of the string. Gives [46 20 9 ... 0 1]
^                      % Element-wise power. Gives [2^46 3^20 5^9 ... 1 71]
X$                     % Convert to symbolic (to achieve arbitrary precision)
p                      % Product. Implicit display

Java 8, 86 bytes
v->"ᾑ䐑Ἂ㉌⊡▒д᭞ᵸ᪑".chars().forEach(c->System.out.print(~-c))

Try it online.
Explanation:
v->  // Method with empty unused parameter and no return-type
  "ᾑ䐑Ἂ㉌⊡▒д᭞ᵸ᪑".chars().forEach(c->
     //  Loop over the characters of this string as integer codepoints:
    System.out.print(~-c))
     //   Print this integer - 1 to STDOUT

The string contains the characters with the codepoints:
8081,17425,7946,12876,8865,59905,9618,1076,7006,7544,6801,1,1,1,1,1,1,1

Outgolfed! It's a different output and algorithm so I'm writing my own answer instead of simply golfing yours ;)

@OlivierGrégoire Ah, didn't realize that was shorter, haha. The first version of the C answer used a similar approach.

Jelly, 37 30 bytes
ØẠiⱮ“tTIFBC”;⁽<(B¤
³ÆRṁ¢ż¢*/€P

Encodes the number as a list of exponents to primes, probably could be optimized with cleverer builtins
ØẠiⱮ“tTIFBC”;⁽<(B¤
    “tTIFBC”       the string "tTIFBC"
  iⱮ               find indices of each character in
ØẠ                 the alphabet in both cases "A..Za..z"
             ⁽<( ¤ the number 16041
                B¤ converted to binary
            ;      append

³ÆRṁ¢ż¢*/€P
 ÆR         all primes below
³           100
   ṁ        shaped like
    ¢       the above line
     ż      zipped with
      ¢     the above line
       */€  exponent for each pair
          P product

-7 bytes by encoding the final 0/1 sequence as binary
Try it online!

05AB1E, 29 28 27 bytes
-1 byte thanks to @KevinCruijssen
•∍ýö/V$Éb´‰ŒrƶÜλFÄôS•¦¾T<×«

Try it online!

05AB1E, 21 bytes
Answer suggested by @KevinCruijssen as a port of the Jelly answer by @JonathanAllen
₆ÍRžwŸ!•Pǝ½ζÄž,Ā•₆в*O

Try it online!

27 bytes

21 bytes by porting the approach used in JonathanAllan's Jelly answer.

13 bytes by porting the approach used in Bubbler's Jelly answer

Haskell, 91 bytes
import Data.Numbers.Primes
product[p^length[';'..c]|(c,p)<-zip"hNC@<=;;;;;:;:;:;::;"primes]

Try it online! (has an extra 2 bytes for x=)
Probably suboptimal but I had a lot of fun writing it. I encode the prime exponents (including zeroes for the primes it doesn't have prior to 71) as a string using the character's relative distance from :. the rest is a simple matter of zipping the exponents against an infinite list of all primes, raising those primes to that power, and taking the product.
Edit: forgot to take the x= out of the source code on here.

almost... idk why product is returning a negative number tbh

@ASCII-only it's because length always returns an Int and this number is too big to be stored as an Int so it overflowed into the negatives. In my code I made sure the type of x was ambiguous so that GHC would default it to Integer which is arbitrary precision.

C (gcc), 84 \$\cdots\$ 81 83 bytes
Saved a byte thanks to ceilingcat!!!
Added 2 bytes to fix a bug kindly pointed out by gastropner.
*s;f(){for(s=L"nn/HM|Q:iv^YxO[e}%W}}WTBn}}}}}}}}";*s;)printf("%d",(*s+++'A')%'_');}

Try it online!
Port of Level River St's Ruby answer.

Oh wait... We got a problem here. 02 :(

@newbie Yikes! Just saw that too! T_T

Sorry, the direct approach is smaller. That %'_' doesn't actually save anything.

Think you need to sacrifice two bytes to change those numbers into chars to avoid digits.

@gastropner Oops, miss that.  Now fixed.  Well spotted - thanks! :-)

Vyxal, 27 25 bytes
Thanks to Underslash for -2 bytes because numbers.
»$⇩∪£¼ɾǏ℅yṙ`₆gǏ¦¨λ»kεk×**

Try it Online!
Unfortunately, the compressed form of the number contains a 2 and a 0. This is a different number, multiplied by another number multiplied by another number, to get the target number.
»$⇩∪£¼ɾǏ℅yṙ`₆gǏ¦¨λ»        # Push 11482618231106483731969943632999939453125
                   kε      # Push 32768
                     k×    # 2147483648
                       **  # Multiply all the numbers
                           # Implicit output

25 bytes by dividing the number by 2^31 and 2^15, compressing that, and then multiplying to get the correct output.

Wolfram Language (Mathematica), 93 bytes
FromDigits[LetterNumber/@Characters@"h h agdbdgideabhgehhfdeii difaga geg  egedcfh         "]

Try it online!

GroupOrder[MonsterGroupM[]] saves 66 bytes.

@MeesdeVries of course there is a mathematica built in... it is already posted in another answer

Oops, I didn't even read all the answers before commenting. My bad. :-)

Bash + Core utilities, 67 bytes
tr o-z /-:<<<xpxpqwtrtwytuqrxwuxxvtuyyptyvqwqpwuwppuwutsvxppppppppp

Try it online!

Octave, 50 bytes
prod(primes('G').^sym('hNC@<=;;;;;:;:;:;::;'-':'))

Try it online!

This deserves more votes! I'm impressed!

brainfuck, 183 171 170 bytes
++++++++[>+++++++>++++++<<-]>.>.<.>.+.<-.---.>+.<.+++.++.>++.+.
----.+.<-.-.>+++.<+..--.>-.+.<+++..>-----.++++.<.---.>---.<+.>.
-.<.--.++.>..<--.++.--.-.-.+++.++.>.........

Try it online!
Linebreaks added for readability so not included in the byte count.

C++ (gcc), 82, 76 bytes
Kudos to @ceilingcat for -6 bytes
void f(){for(auto s:L"ƴ")printf("%i",s);printf("%i%i%i",!f,!f,!f);};

Try it online!
C++ (gcc), 82 bytes
void f(){for(auto s:L"ƴ")printf("%i",s);printf("%i%i%i",NULL,NULL,NULL);};

Try it online!
My first ever Code Golf submission! :)
Explanation: The loop part of the function prints a decimal representation for each Unicode character in the string. I was really stumped as to how to print zeros without being allowed to have 0 in the code. I just added NULL characters cast to int.

Also, welcome to CGCC!

@ceilingcat - Thanks for the welcome and the tips. Of course! A boolean of a function name always exists. That's clever.

-3 bytes by replacing auto and void with int, and removing the semi-colon at the end.

@StealingMana You can't keep #include<cstdio> out of your code as it's needed for your function to work. In other words it has to be it part of your byte count.

Suggest int instead of auto

Jelly, 14 bytes
“ ½‘!P×“ḥɗeŀƊ’

Try it online!
Just saw alephalpha's answer before edit and thought "what if I port it to Jelly?" and it worked.
Uses the formula from this comment:

31!10!27079205916672

then I noticed that 27079205916672 is a multiple of 32, so I changed the formula to

32!10!846225184896

cutting one more byte from the compressed number.
The Jelly code does "“ ½‘ (32, 10) !P factorial each and product × times “ḥɗeŀƊ’ 846225184896".

JavaScript (Node.js),  79 78  58 bytes
Saved 20 (!) bytes thanks to @tsh
A port of Neil's approach.
_=>eval(Buffer("?@^ddrtuuuvwxxy{|~~~~Ȁ掀").join`n*`+'n')

Try it online!

JavaScript (Node.js), 93 bytes
_=>eval('ZxEDCCCCBAECEBBBBn*ZxEAAFEEEFECn*ZxFFCn*ZxFDDAAEn*ZxAZZZZZZZZZZn'.replace(/Z/g,+[]))

Try it online!
The idea here was to look for factorizations of \$N\$ with factors whose hexadecimal representation only contains letters and \$0\$'s, so that we only need to replace \$0\$'s with a substitute character.
There are countless possibilities. We use this one:
0xEDCCCCBAECEBBBB * 0xEAAFEEEFEC * 0xFFC * 0xFDDAAE * 0xA0000000000

JavaScript (Node.js), 101 bytes
_=>eval("FxHOOFdNebfLLMHOGdFMcFGKKffKn*In**HFn<<JLn".replace(/[A-Z]/g,c=>c.charCodeAt()%(~[]+[+[]])))

Try it online!
The encoded expression is:
0x2990d8ebf667291d07c0155ff5n*3n**20n<<46n

Maybe _=>eval(Buffer("  @@G^dddrstuuuvwxxy{|~~~~~").join('n*')+'n')?

Use " ^ddrtuuuvwxxy{|~~~~~Ȁ掀" may save 1 byte

are we allowed to end the output by a "n" like this?

@Kaddath It is notation for BigInt type. If you try to convert the result to String, the n will disappear. For example, you may print the result to a file by fs.writeFileSync('1.txt', f()). And you won't get n in the file.

@tsh Thanks, it's a great answer of course, however, if I would be picky, the challenge being "Your output must be the precise digits of the number", the output is not exactly right and the code would be only missing +'' at the end..

@Kaddath Maybe this should be asked in meta as I didn't find a relevant enough post in there (but I didn't spend much time on it).

@Arnauld I was just curious, you are far more experienced in golf rules than me ^^ I particularly follow your answers because I code in JS for work, but it seems impossible to outgolf you so I usually choose PHP for my answers :D

54

Java (JDK), 81 bytes
v->"XPXPQWTRTWYTUQRXWUXXVTUYYPTYVQWQPWUWPPUWUTSVXPPPPPPPPP".chars().map(n->n-' ')

Try it online!
If Java's int allowed for (much) more than 32 bits, the following (65 bytes) would have worked:
v->",--------<?DGLRT\\^hhhpppptv|".chars().reduce(',',(a,b)->a*b)

Ruby, 50 47 bytes
p eval (%w(Gv/ R>t. &DhP)*" @QQH}bMA").bytes*?*

Try it online!
Thanks histocrat for -1 byte, ad Jo King for pointing out some silliness in the original answer.

K4, 64 bytes,
Solution:
,/$.Q.a?"iaiabhecehjefbcihfiigefjjaejgbhbahfhaafhfedgiaaaaaaaaa"

Explanation:
Really boring, lookup each letter in the alphabet (e.g. "b" => 1), convert to string and flatten
    ,/$.Q.a?"iaiabhecehjefbcihfiigefjjaejgbhbahfhaafhfedgiaaaaaaaaa" / solution
            "iaiabhecehjefbcihfiigefjjaejgbhbahfhaafhfedgiaaaaaaaaa" / a -> 0, b -> 1 etc
       .Q.a?                                                         / lookup in built-in alphabet a-z
      $                                                              / convert to string
    ,/                                                               / flatten

Perl 6, 42 bytes
say [*] ²X*'``}}}~~~~~yuuuwr\t|{^;G'.ords

Try it online!
Uses the same strategy of reducing the ordinal values of a string by multiplication as other answers, but also multiplies each element by 2 beforehand to save a byte on representing all those powers of two.

Red, 88 78 bytes
foreach c"XPXPQWTRTWYTUQRXWUXXVTUYYPTYVQWQPWUWPPUWUTSVXPPPPPPPPP"[prin c - sp]

Try it online!

Io, 79 bytes
"ᾑ䐑Ἂ㉌⊡▒д᭞ᵸ᪑"foreach(i,(-i)bitwiseComplement print)

Try it online!

Pyth, 41 bytes
*F^MC,fP_TSC\G+C\.xLG"ujgcdbbbbbabababaab

Try it online!
*F^MC,fP_TSC\G+C\.xLG"ujgcdbbbbbabababaab    Implicit: G=lower case alphabet

                   L "ujgcdbbbbbabababaab    For each character in the string...
                  x G                        ... find it's index in the alphabet
              +C\.                           Prepend 46 (character code of .) - these are the prime powers
           C\G                               71
          S                                  Range 1-71
      fP_T                                   Filter keep the primes in the above
     ,                                       Pair the primes with the prime powers
    C                                        Transpose
  ^M                                         Map exponent operator over each pair
*F                                           Take product of the result, implicit print

Deadfish~, 164 bytes
iiisdo{d}oiiisdo{d}oioisiiiodddoddosoiiioiiodddddoioddddoioisdododdoiiiooddoddoioddsoo{d}oiisodsodddo{d}ioisiiio{d}iodoiisiiioddoiio{d}ooiisioiioddododoiiioii{o{d}}

Try it online!

C (gcc), 77 bytes
*s;f(){for(s=L"pp!'JO~S<kx`[zQ]g kf YVDp        ";*s;)printf("%d",*s++-' ');}

Assumes that wchar_t and int have the same size. This way we can make the string wide and we can omit the type when declaring s.
A naive approach: group the digits in blocks of 1–3, each of which is an integer between 0 and 127 with no leading 0. Since character 0 can't be present in the string, characters are encoded as their value plus some constant. The constant is 32, which has the advantage of keeping all characters printable.
C (gcc), 78 bytes
Bonus: without relying on wchar_t and int having the same size. We save 1 byte (the L) by not having a wide string, but lose 1 byte because the implicit-int declaration *s is replaced by the explicit type name char.
f(){for(char*s="pp!'JO~S<kx`[zQ]g kf YVDp        ";*s;)printf("%d",*s++-' ');}

Try it online!

><>, 36 bytes
|.ab*n!?+il"ØØØØØØÕìëöøèúúæò÷õîÐÐÄp"
Try it online!
It's based on a hand-optimized list of partial products of the prime factors of the number, each fitting within a byte.

MathGolf, 18 bytes
8462NG4896]y♂!♥!**

Try it online.
Explanation:
8462NG4896    # Push the integers 8,4,6,2,25,18,4,8,9,6
          ]   # Wrap the stack into a list
           y  # Join it together, and implicitly convert it to an integer: 846225184896
♂!            # Push 10!: 3628800
♥!            # Push 32!: 263130836933693530167218012160000000
**            # Multiply all three values on the stack together
              # (after which the entire stack is output implicitly as result)

Javascript, 93 characters
_=>'ÉÉŠ£¨×¬•ÄÑ¹´Óª¶ÀyÄ¿y~Ä¤½yyyyyyyyy'.split``.map(c=>c.charCodeAt()-'y'.charCodeAt``).join``

The function returns "808017424794512875886459904961710757005754368000000000".
Explanation: Each character in the string is encoding two characters in the target. Because low character codes are a mess, we offset them by 121 ("y"). I also had to pad some extra 0s (y's) into the string because for instance a "y" and "yy" both convert to "0".
Port of Kevin Crujissen's answer (63 characters):
v=>"ᾑ䐑Ἂ㉌⊡▒д᭞ᵸ᪑".split``.map(c=>~-c.charCodeAt()).join``

R, 99 bytes
cat(match(strsplit("iaiareyhjefmihfiigefjjaejgrkhfhaafhfedgiaaaaaaaaa","")[[T]],letters)-T,sep="")

Fairly simple zero-based mapping from digits to letters, and using T as a substitute for 1.

BRASCA, 72 66 bytes
`B:B:;A><>AC>?;<BA?BB@>?CC:>C@;A;:A?A::?A?>=@B:::::::::`![al-mA{]x

Try it online!
Explanation
`B:B:;A><>AC>?;<BA?BB@>?CC:>C@;A;:A?A::?A?>=@B:::::::::`            - Push the number, with the ASCII code shifted by 10
                                                        ![a  mA{]x  - Foreach in stack:
                                                           l-       -    Subtract 10 from the charcode
                                                                    - Implicitly output it

PARI/GP, 60 bytes
print(vecprod(Vec(Vecsmall("$$$G^ddhhhprstvwxxxxy{|~~~~"))))
Attempt This Online!
Takes the product of the ASCII codes of the characters.
Here is the Mathematica code to find the string "$$$G^ddhhhprstvwxxxxy{|~~~~".

C#, 61 bytes
_=>"ᾐ䐐Ἁ㉋⊠░г᭝ᵷ᪐␀␀␀␀␀␀␀".Select(x=>+x+"")

Try it online!

Converts a series of characters to their codepoints and then converts that to a string:
ᾐ  8080
䐐  17424
Ἁ  7945
㉋  12875
⊠  8864
  59904
░  9617
г  1075
᭝  7005
ᵷ  7543
᪐  6800
␀  0

␀ here is a null byte (U+0000)


text:
Write a program that checks the consistency of modern mathematics
Modern mathematics has been formalised using set theory by various systems of axioms. Zermelo Frankel set theory with the axiom of choice (ZFC) forms an intuitive set of axioms and is hence most popular, though stronger choices exist.
Inspiration: A Relatively Small Turing Machine Whose Behavior Is Independent
of Set Theory by Adam Yedidia and Scott Aaronson
In this paper, a 7918-state Turing machine has been discovered that "checks" the consistency of ZFC. More specifically, it has been proven impossible to prove the machine as either halting or non-halting within ZFC. Note that if the program actually halts in a finite number of steps, its behaviour is also provably halting in any reasonable axiomatic system since we can enumerate this finite number of steps explicitly. Therefore halting can only mean an inconsistency in ZFC itself.
A 1919-state TM was also discovered subsequently
The method they've used (for the 8000 state machine) is to identify a mathematical statement whose truth has been proven to imply the consistency of ZFC, in this case Friedman's mathematical statement on graphs (section 3.1 of the paper), then written a program in a higher level language to check that, then converted it to a Turing machine
Your task: Write a program in any accepted language on this site (not necessarily a Turing machine) which cannot be proven as halting or non-halting within ZFC. This is code golf, so shortest program wins.
Your program must be deterministic, it cannot use "random" numbers or take external "random" input.
Likely method to go about this would be to identify a mathematical statement which is already known to be independent of ZFC or a stronger system, and check that - though this is by no means the only way to go about it. Here's a list of such statements to get you started.
Related: Analogous challenge for Peano arithmetic

NQL: 335 characters
In The Busy Beaver Frontier page 12, Scott Aaronson mentions that Stefan O'Rear found a 748-state Turing machine that halts iff ZF is inconsistent. Here is the code that compiles to that Turing machine from a higher-level programming language called NQL, based on Laconic. I'm not very familiar with this language, but applying basic golfing techniques yields 397 characters:
global x;global lcm;global l;global num;global denom;global i;global a;global b;global c;global d;proc main(){lcm=1;while(true){x=x+1;l=lcm;while(lcm!=(lcm/l)*l||lcm!=(lcm/x)*x){lcm=lcm+1;}if(x>253){num=0;denom=1;i=1;while(i<=lcm){num=num*i+denom;denom=denom*i;i=i+1;}a=num-denom*x;a=a*a;b=denom*denom;c=0;d=1;i=1;while(i<=x){c=c*i+d;d=d*i;i=i+1;}c=c*c;c=c*c*x;d=d*d;d=d*d;if(a*d>b*c){return;}}}}

I confirmed that the same output is produced as the original program with
diff <(python3 nqlaconic.py --print-tm riemann-matiyasevich-aaronson.nql) \
<(python3 nqlaconic.py --print-tm riemann-matiyasevich-aaronson-golfed.nql)

Applying variable name shortening (this changes the output) yields 335 characters:
global x;global v;global l;global z;global y;global i;global a;global b;global c;global d;proc main(){v=1;while(true){x=x+1;l=v;while(v!=(v/l)*l||v!=(v/x)*x){v=v+1;}if(x>253){z=0;y=1;i=1;while(i<=v){z=z*i+y;y=y*i;i=i+1;}a=z-y*x;a=a*a;b=y*y;c=0;d=1;i=1;while(i<=x){c=c*i+d;d=d*i;i=i+1;}c=c*c;c=c*c*x;d=d*d;d=d*d;if(a*d>b*c){return;}}}}

Given its C-like syntax, I imagine the code could be easily adapted to other languages and shortened further.

I've walked into a room of gods.