text:
Is my Rep in Stack-Exchange Form?
Premise:
Your reputation is in Stack-Exchange Form if it can be represented by decomposing your medal counts (gold, silver, and bronze counted separately) into their base-10 digits and joining them in any given order, with a few caveats.
While decomposing, each

Gold medal digit is worth three digits.
Silver is worth two digits.
Bronze is one digit.
Additionally, since SE does not display a medal type if you do not have any, a count of 0 medals for a type will not yield a [0].

Example:

[1 Gold, 2 Silvers, 3 Bronzes] will decompose into [1,1,1,2,2,3]. 321112 and 213121 are two examples of an SE-form number for these medals.
[20 Golds, 0 Silvers, 20 Bronzes] will decompose into [2,2,2,0,0,0,2,0]. 20002022 is an SE-form number.
[11 Golds, 0 Silvers, 0 Bronzes] will decompose into [1,1,1,1,1,1]. 111111 is the only SE-form number for this.

There will be no leading 0's when considering a SE number. E.g., in the 2nd example above, 00002222 -> 2222 would not be considered a SE-form number for [20,0,20].
Input/Output:
Input is a list/tuple/array/whatever of [reputation, gold_medals, silver_medals, bronze_medals] which are all non-negative integers. This is the assumed order but can be changed. Just make a note in your answer if you do.
Output is any two consistent values for true and false.
Rules:

Input will always be valid
You will always have at least 1 Rep
You can have no medals at all, which should always return false then.
The medal counts have no bearing on reality. Having several hundred golds and no bronzes is fine.
This is code-golf so shortest answer in bytes wins.

Test Cases:
#[Rep, Gold, Silver, Bronze] -> Output
[4, 0, 0, 4]       -> True
[1447, 0, 4, 17]   -> True
[74414, 4, 0, 17]  -> True
[4444, 4, 0, 4]    -> True
[4455, 0, 54, 0]   -> True
[5355, 5, 0, 3]    -> True
[53535, 5, 3, 0]   -> True
[4444, 0, 0, 4444] -> True
[444, 4, 0, 0]     -> True
[1234, 0, 0, 1234] -> True
[1234, 0, 0, 4321] -> True

[4444, 1, 0, 1]      -> False
[5555, 5, 0, 55]     -> False
[1234, 1, 23, 4]     -> False
[1, 0, 0, 0]         -> False
[1001001, 0, 10, 10] -> False

so what exactly does reputation do in the context of the challenge?

@OrangeCherries Mechanically, nothing. It inspired the challenge because I had 1447 rep and 4 silvers, 17 bronzes at the time of writing.

Is the input flexible besides the order? So could I for example take an input-list [bronze, silver, gold] and a separated second input reputation?

@KevinCruijssen Yeah that's fine. The only thing I'd say is disallowed is taking input as a list of lists of chars/digits that make up each number.

Are any truthy/falsy values allowed for output or does it have to be two consistent ones?

@NickKennedy Two consistent values. (response now sans snark)

It'd be nice to have an example that isn't just 1s and 0s, I thought the challenge dealt with binary until I read it through a few times. Maybe I'm just slow tho :)

@ConorO'Brien But the first example is [1,2,3]? I changed the 2nd to [20,0,20] just so it's more clear at a glance

@Veskah It is, but the other two examples were 1s and 0s. I was caught up on those lol

05AB1E, 16 14 13 11 10 bytes
∞×0KJ‚€{íË

Takes the medals input in the order [bronze, silver, gold] as first input, and reputation as second input.
-1 byte thanks to @Grimy.
Try it online or verify all test cases.
Explanation:
∞           # Push an infinite positive list: [1,2,3,...]
 ×          # Repeat the values in the (implicit) input-list that many times as string
            # (since the input-list contains just 3 values, the rest of the infinite
            #  list is ignored)
  0K        # Remove all 0s (so all "0", "00" and "000")
    J       # Join the strings in the list together
     ‚      # Pair this string with the (implicit) second input
      €{í   # Sort the digits in both strings in descending order
         Ë  # And check if both are now equal
            # (after which the result is output implicitly as result)

3L -> ∞ for -1.

@Grimy Sometimes it's useful that lists are truncated to the smallest one. :) Thanks!

This is 19 bytes in utf-8, not 10 bytes.

@LieRyan You're correct, it's indeed 19 bytes in UTF-8. 05AB1E uses (just for example Jelly and Charcoal) a custom codepage, where every 256 characters it knows is encoded in 1 byte each. The bytes in this 10-byte version in hexadecimal are \x19\xd7\x30\x4b\x4a\x82\x80\x7b\xec\xcb: It should be possible to run these hexadecimal bytes with the --osabie flag, but I'm not sure how to do so in the 05AB1E Elixir version to be completely honest (but I will ask some others to verify and get back to you with the answer).

@LieRyan In the 05AB1E (legacy) Python version it could be done like this (it's a different program for another challenge of course), but it should give you the idea of how the hexadecimal bytes are run.

JavaScript (ES6),  92  74 bytes
Takes input as (['gold','silver','bronze'])('rep'). Returns a Boolean value.
b=>r=>[...b.map((n,i)=>n.repeat(+n&&3-i)).join``].sort()+''==[...r].sort()

Try it online!

JavaScript (ES6), 74 bytes
Takes input as (gold, silver, bronze, 'rep'). Returns a Boolean value.
(g,s,b,r)=>(F=s=>[...s].sort()+0)(r)==F([g,g,g,s,s,b].filter(x=>x).join``)

Try it online!

MATL, 28 bytes 20 bytes 16 bytes 13 bytes
Returns 0 for false and 1 for true. This can definitely be golfed down.

[1,3,2,1]Y"t2:7)XzVXzY@Ums0>

Down to 16 bytes if the reputation score can be taken in separately, and the order is [bronze, silver, gold], reputation
Down to 13 bytes thanks to Luis Mendo
3:Y"XzVXzY@Um

Try it online!

J, 38 34 31 20 bytes
-:&(\:~&.":)]#~#\.**

Try it online!
-11 bytes thanks to FrownyFrog!

20 bytes

well 19, since you can take the medals reversed.

That is a seriously nice golf.  Tyvm!  I especially like the use of &. to remove the spaces.  Great trick.

Ruby, 69 bytes
->r,g,s,b{([g,g,g,s,s,b]-[0]).flat_map(&:digits).sort==r.digits.sort}

Try it online!

Japt, 14 13 12 bytes
íp fn ¬á øUg

Takes input as [rep, bronze, silver, gold]
Try it or Verify all test cases
Sample input: U = [1447, 17, 4, 0]
íp            Repeats each value of U by it's index amount e.g. ["","17","44","000"]
  fn          Remove all falsy values when converted to a number e.g. ["17","44"]
    ¬         Concatenate e.g. "1744"
     á        All permutations e.g. ["1744","1744","1474","1447","1474","1447","7144","7144","7414","7441","7414","7441","4174","4147","4714","4741","4417","4471","4174","4147","4714","4741","4417","4471"]
      øUg     Does it contain the first item of the input?

I've taken a few stabs at this from a couple of different angles but can't do better than 13 either.

@Shaggy Turns out the Å was unnecessary, since fn would get rid of the first value. Removing Å makes it 12 bytes

This is 16 bytes in utf-8, not 12 bytes.

@LieRyan Some golfing languages use their own encodings; Japt uses ISO-8859-1`

@EmbodimentofIgnorance, Ah, goddamnit, why didn't I spot that?! I really do feel so out of practice since I took that month off for my open bounty for Japt.

Retina 0.8.2, 45 bytes
,0
,
,(\d*),(\d*),
¶$1$1$1$2$2
%O`.
^(.+)¶\1$

Try it online! Link includes test suite. Explanation:
,0
,

Delete zero scores.
,(\d*),(\d*),
¶$1$1$1$2$2

Expand the gold and silver scores, and convert the separator to a newline.
%O`.

Sort the reputation and the expanded scores separately.
^(.+)¶\1$

Compare the sorted digits.

Racket, 149 107 98 bytes
(λ(r b s g[h(λ x(sort(string->list(apply ~a(remq*'(0)x)))char<?))])(equal?(h r)(h b s s g g g)))

Try it online!
First time golfing in Racket, so still looking for improvements...
Explanation (of the original longer version, but same idea):
(λ(r b                              ; take rep and badges as arguments
     [g(λ(x)                        ; helper function g which takes a string
         (sort                      ; and returns the sorted
           (string->list x)         ; list of characters
           char<?))])               ; (sort by ascii code)
  (equal?                           ; compare...
    (g(~a r))                       ; g called on the rep converted to string
    (g                              ; and g called on...
      (string-join                  ; the concatenation of
        (map ~a                     ; the stringified elements of
             (append*               ; the flattened list given by
               (filter              ; the elements of the following list where
                 (λ(x)(>(car x)0))  ; the badge count is nonzero:
                 (map make-list     ; repeat the badge counts
                      '(1 2 3)b)))) ; 1, 2, and 3 times respectively
        ""))))

Jelly, 10 bytes
xJ$¹ƇV,Ṣ€E

Try it online!
Argument 1: [Bronze, Silver, Gold]
Argument 2: Rep

This is 16 bytes in utf-8, not 10 bytes.

@LieRyan Jelly uses a custom code page.

Charcoal, 24 bytes
1Ｆ⁴Ｆ↨ＮχＦι⊞υκＦχ¿⁻№υι№θＩι⎚

Try it online! Link is to verbose version of code. Takes input in the order rep, bronze, silver, gold and outputs 1 if the rep is valid. Explanation:
1

Assume the rep is valid.
Ｆ⁴Ｆ↨ＮχＦι⊞υκ

Loop over the four input values. Push each digit of each value i times where i is the 0-indexed index of the value. Numeric base conversion is used here as that converts 0 to an empty array.
Ｆχ¿⁻№υι№θＩι⎚

Check the count of each digit in the array matches that in the first input. If any differ, clear the canvas.

This is 60 bytes in utf-8, not 24 bytes.

@LieRyan I didn't say they were UTF-8 bytes.

Jelly, 18 bytes
DẋṠƊ€ẋ"3RU¤FṢ⁼⁴DṢ¤

Try it online!
this is a bit bad

This is 37 bytes in utf-8, not 18 bytes.

@LieRyan Jelly (and many other golfing languages) use their own code page such that all 256 1-byte codes correspond to one of the characters used by the language.

Python 2, 80 79 77 68 bytes
lambda r,g,s,b:S((g>0)*3*`g`+(s>0)*2*`s`+(b>0)*`b`)==S(`r`)
S=sorted

Try it online!
Takes input as rep, gold, silver, bronze.

Perl 5 -lF, 62 bytes
map{@r=sort/./g,@r if($_=<>x$_)>0}1..3;@F=sort@F;say"@r"eq"@F"

Try it online!
Takes input on separate lines as
reputation
bronze
silver
gold

Husk, 10 bytes
€mdPfIṁdṘN

Try it online!
Similar to the Japt answer.
Takes [bronze,silver,gold] as first argument, rep as second argument.
Explanation
€mdPfIṁdṘN
         N natural numbers
        Ṙ  repeat medals that many times
      ṁd   get all their digits as a single array
    fI     filter out zeroes
   P       permutations
 md        mapped to their base-10 numbers
€          is rep in the list?

PowerShell, 66 69 bytes
-3 bytes thanks to mazzy
''+($args|%{"$_"*$i++*!!$_}|% t*y|sort)-eq(''+$args[0]|% t*y|sort)

Try it online!
Takes input at (Rep, Bronze, Silver, Gold)
Figure I'll take a crack at my own question. Converts the numbers toCharArrays and sorts them. Appends an empty string so the sorted arrays are converted back to space-separated strings which can then be compared.
We handle 0 medal counts with !!$_ which doubly negates the number, making it go non-zero number-> 0 -> 1 or 0 -> 1 -> 0 which is used to blank the repeat counter.

you can remove second ''+. because Powershell implicitly brings the type of second operand to the type of first operand.

Wolfram Language (Mathematica), 69 68 bytes
i=IntegerDigits
Sort@i@#==Sort[Join@@i/@Select[{##2,##3,#4},#!=0&]]&

Defines an anonymous function; takes inputs to function as [reputation, bronze, silver, gold].
I think this method for repeating silver and gold is interesting (and unique among these answers): in an anonymous function, #n represents argument n and ##n represents a sequence of arguments from argument n to the end, so if one were to expand {##2,##3,#4}, it would become {#2,#3,#4,#3,#4,#4}, which repeats each the necessary number of times while being 7 bytes less than the expanded form.


text:
Fastest way to iterate over sublattice of discrete lattice
I need to construct a functor that iterates over the linear representation of a sub-lattice of size \$d_x,d_y,d_z,d_q\$ embedded in a lattice of size \$n_x,n_y,n_z,n_q\$. The sub-lattice corner is shifted by \$(l_x,l_y,l_z,l_q)\$.
Since the functor can be called million of times, the goal is to produce the most efficient code with the least integer pressure on the CPU.
That is, given ten 16-bit unsigned integers \$d_x,d_y,d_z, n_x,n_y,n_z, l_x,l_y,l_z,l_q\$ with \$d_x\leq n_x\$, \$d_y\leq n_y\$, and \$d_z\leq n_z\$, construct the most efficient function that takes a 64-bit unsigned integer
\$0\leq i\lt d_x*d_y*d_z\$ and returns a 64-bit unsigned integer \$j\$ such that if
$$i=i_q (d_z d_y d_x) + i_z (d_y d_x) + i_y d_x + i_x$$
then
$$j=(i_q+l_q)(n_z n_y n_x) + (i_z+l_z)(n_y n_x) + (i_y+l_y)n_x + (i_x+l_x)$$
Winner solution is the one that achieves the stated goal using the least amount of cycles. Solution preferred in x86_64 assembly (pseudo-code is ok). It is ok to use any instruction that belongs to the instruction set available on Intel/AMD cpus of latest generation (SSE4,SSE3,...).

Hi, welcome to PPCG! I saw you've edited your post after it was closed for lacking a win condition. All challenges also need a win-condition tag. Since you've mentioned least amount of cycles, [fastest-algorithm] seems to be the most appropriate. I've added the tag, as well as a few other relevant tags. I've also formatted your post a bit with MathJax. If you see anything incorrect due to my edit, feel free to fix/change it again.

PS: Solutions for a specific language are discouraged, although you can always state you would like to see an answer in a specific language. I've edited your description accordingly, but left the relevant [assembly] tag just in case.

As for the challenge itself. I think you've made some typos in the formulas? I see some $i_z,i_q,i_y$, but shouldn't those be $l_z,l_q,l_y$ instead?

The integer widths don't work. Shouldn't i and j be 64-bit values?

Thank you Kevin and Peter for cleaning up my original post. Peter is right, i and j should be 64-bit values. I double checked the formulas and they are correct. Essentially, if $$(i_x,i_y,i_z,i_q)$$ are the relative coordinates in the sublattice, the coordinates in the lattice are $$(i_x+l_x,i_y+l_y, i_z+l_z, i_q+l_q)$$.

@user3646557 Ah ok, that makes sense. And now that Peter has edited the formulas further I can also see the $(i_q+l_q),(i_z+l_z),(i_y+l_y),(i_x+l_x)$ grouped together, making it more readable. I personally still don't really grasp how I could calculate this, since mathematics isn't my strongest suite tbh, but I've voted to re-open since regardless of my own lack of skill, the challenge is clear and it has a win-condition tag now. If 5 open-votes are cast and it's re-opened, perhaps someone is able to answer your question (with an efficient algorithm). :)

@Kevin, it's a mixed base conversion.

source: Stack Exchange

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

sort: votes


text:
Inverse-quotes-quine
The prospect of this challenge is:

If your program is run normally, all of the code in the speech marks (" - double quotes) should be printed.
If your program is wrapped in double quotes (in turn inverting the speech marks), the code that is normally not in quotes should be printed.

E.g:
Let's say you have the following code:
fancyStuff("myCode"); "I like".isGreat();

If I run it, I would expect an output of:
myCode
I like

However, if I wrapped it in quotes, I would get:
"fancyStuff("myCode"); "I like".isGreat();"

When this code is run, the expected output would be:
fancyStuff(
);
.isGreat();

Obviously, the above example is not a functional response in any language. Your job is to write the code that performs in this way.
Rules

Standard loopholes apply.
The printed values, in both quoted and unquoted forms, must be non-empty, or consist solely of whitespace. This also means that all programs must include at least one set of quotes.
However, trailing/preceeding whitespace is allowed.
No looking at your own code, required file names, etc.
Unmatched quotes are disallowed
If there are multiple strings, they can either be printed as newlines (as in the example), or in some other human-readable way - no arrays or objects
This is code-golf, so shortest answer in bytes wins.

Are unmatched quotes allowed, and if so, how should they be handled?

Must the output be split with newlines like in the examples?

@negativeseven no, I'll say they're not allowed.

@ErikTheOutgolfer I've updated the rules a bit, see now.

@GezaKerecsenyi So, is a separator required, or can we simply concatenate the strings?

@EriktheOutgolfer No separator is required - the only condition is that the output be a string format.

Let's say my program starts or ends with a double quote, does the program wrapped in double quotes has to output an empty leading/trailing item, or are they optional?

@KevinCruijssen If you decide to separate quotes with newlines, yes, an empty line is required. But if you concatenate them, it won't make a different anyway.

Can we use single quotes or backticks instead of double quotes?

@Shaggy you can use them in your code, but for purposes of standardisation, the 'strings' that need to be printed should be in double quotes.

How is an array not a human readable format?

@SriotchilismO'Zaic It's not a string. Some consoles could even render it as [object] if you just try to print it. Further, arrays are made for data storage; strings are made for no reason other than human readability, so they are more primarily for that purpose. I'm only counting strings/integers/floats (but in this case just strings are relevant) as human-readable.

Must strings be output in the same order they appear in our code?

I think this would have been slightly more complex if you had to print whatever was not in the quotes

@JoKing good idea - could I make a new challenge (like part 2) about that?

@shaggy yes, they do.

Python 2, 20 bytes
print";print'print'"

-7 bytes thanks to tsh
Try it online!

Old answer:
Python 2, 27 bytes
'';print";print 2*"'';print

Try it online!
Train of thought behind this answer:
Begin with a simple print, because we need to print something.
print"a"

We also need to print something in the inverted case, ie. have a print inside quotes.
print"print"

The non-inverted case is pretty good at this point. Let's focus on the inverted case. We now start with the string print, which can't be followed immediately by a print statement. Let's fix this with a semicolon.
print";print"

Good stuff. Except, the inverted code doesn't actually print anything. We'll need to print the print at the start, because it ends up in quotes, but also print whatever comes after the second quote, because it ends up in quotes too. The obvious way around this is to append print and multiply the last string by 2.
print";print 2*"print

Now the inverted code works fine, though we have to be wary of the fact that the section before the first quote and the section after the second quote need to be kept the same throughout future changes. As for the non-inverted code, it throws a syntax error - once again, we need to introduce a semicolon to separate expressions.
;print";print 2*";print

Python doesn't really like the look of that lone semicolon, so we must satisfy the snake's hunger with two of the same no-op expression, inserted before the first semicolon and the last semicolon. Most expressions will work fine in the first case, but in the second case it must follow print";print 2*" in the non-inverted code without breaking anything. We can use '', which simply gets concatenated with the prior string.
'';print";print 2*"'';print

print(";print('print()');") is also 27 bytes, and also Python 3.

@tsh This code reveals a 20-byte Python 2 solution that should have been obvious in hindsight, very nice!

CSS, 66 bytes

body:after{content:"{}body:after{content:'body:after{content:}'}"}

"body:after{content:"{}body:after{content:'body:after{content:}'}"}"

Not so much questions may be solved by CSS...

Seems that body:after also works on some implementations?

@ShieruAsakoto You are right. :after is available in most browsers for backward compatibility reason

@Shaggy But it's hard to define how "wrap your source code with quotes" works when both HTML and CSS provided.

@tsh It's fine - I didn't specify about multiple files in the rules, since I wasn't expecting such a unique answer!

HQ9+[see notes below], 1016 bytes
"Hello World"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""Hello World
Use the implementation on https://esolangs.org/w/index.php?title=HQ9%2B&oldid=59995 and compile the interpreter with MinGW GCC 5.3.0 on Windows. I'm not sure if it works with other version of compiler, since an undefined behavior of C is required to terminate the program. The buffer is 1000 bytes long. And source code greater than 1000 bytes do the trick. I'm not sure how these happened.

Maybe this is the longest HQ9+ answer on this site. (?)

"an undefined behavior of C is required to terminate the program" Undefined behavior is undefined: it can do anything.

According to page 4 of the C18 standard: "Possible undefined behavior ranges from ignoring the situation completely with unpredictable results,to behaving during translation or program execution in a documented manner characteristic of the environment (with or without the issuance of a diagnostic message), to terminating a translation or execution (with the issuance of a diagnostic message)."

@SolomonUcko But we define a language by its compiler / interpreter on this site. And the answer is fine as long as at least one compiler / interpreter may produce the correct result.

05AB1E, 4 bytes
"A"§

Outputs concatenated without separator.
Try it online or try it online with surrounding quotes.
Explanation:
        # Program without surrounding quotes will output string "A"
"A"     # Push "A" to the stack
   §    # Cast it to a string
        # (output the top of the stack implicitly as result)

        # Program with surrounding quotes will output string "§"
""      # Push an empty string to the stack
  A     # Push the alphabet to the stack: "abcdefghijklmnopqrstuvwxyz"
   "§"  # Push "§" to the stack
        # (output the top of the stack implicitly as result)

Unfortunately, this violates rule #2. While it is fine to have some empty quotes in your code, there must be at least one non-empty one in both surrounded and unsurrounded forms.

@GezaKerecsenyi Oops, read past the part "in both quoted and unquoted forms". Should be fixed now.

Japt, 4 bytes
"P"s

Try it unquoted or quoted
P is the Japt variable for the empty string and the s method slices a string - without any arguments, it does nothing.

Or, ever so slightly less trivial:
"+"u

Try it unquoted or quoted
The first one uppercases + and the second one appends u to an empty string.

Note that 4 is the minimum score for this question, since any less violates the restrictions.

C# (Visual C# Interactive Compiler), 113 112 107 70 64 bytes
Write(".f();static void f(this string s){Write(s+')'+';');}//");

Saved 5 bytes thanks to @negative seven
Unquoted and Quoted
After a while, I realized that my solution was too complicated. The newest program shown here simply hides the rest of the program in a comment to avoid errors when wrapped in quotes.
When wrapped in quotes, Write( is passed onto an extension method, which prints it along with );.

Split() -> Trim(), and var a -> _

@negativeseven Thanks, I would of never thought of using a discard!

@negativeseven Actually, my solution didn't even need to be so complicated, look at my newest edit

64 bytes using an extension method. Pretty surprised this worked out so well!

@negativeseven Thanks! And you gave me an idea for part two of the challenge: I was capturing the outside in a variable and then using Remove and Insert on it, now I can just use an extension method!

Perl 6, 11 bytes
say ".say~"

Try it online!
Prints .say~ with a trailing newline. Seems too easy. Am I missing something?
When wrapped in quotes, produces say with a space and trailing newline.

I don't think so.  It's just that p6 let's you say (ha) say $foo and $foo.say which makes it a lot easier.

Foo, 4 bytes
"P"s

Try it online! Also works in Japt.
5 bytes (UTF-8)
"A"§

Try it online! Also works in 05AB1E.
9 bytes
"!""$;"$;

Try it online! Also works in Runic Enchantments.
11 bytes
say ".say~"

Try it online! Also works in Perl 6.
20 bytes
print";print'print'"

Try it online! Also works in Python 2.
69 bytes
body::after{content:"{}body::after{content:'body::after{content:}'}"}

Try it online! Also works in CSS.
Hmm... Foo is a highly adaptable language.

"Hmm... Foo is a highly adaptable language." For anyone who don't know Foo: everything within double-quotes is output and everything else (except for a few other builtin-characters) are no-ops. "The perfect language for the job" is an understatement here. ;)

So, basically, just rip off every other solution to this challenge?!

@Shaggy The language is Foo. Almost everything with at least a pair of quotes and both expected output non-empty works in Foo in this challenge. So "a"b 1"2" also works in Foo. The only answer in this challenge that is not a Foo polyglot so far is in HQ9+, because the Foo interpreter also has the overflowing problem.

><>, 18 9 bytes
"|o<"r>o|

-9 bytes thanks to Jo King
Try it online!
(quoted)
Explanation
"|o<"r>o|
"|o<"     Pushes the quoted characters onto the stack
     r    Reverses the stack
      >o| Outputs all characters on stack & errors

""|o<"r>o|"
""          No-op
  |         Reverses the IP direction
     "r>o|" Pushes the quoted characters onto the stack (backwards)
  |o<       Outputs all characters on stack & errors

Welcome to Code Golf!

Befunge-98 (FBBI), 12 bytes
<@,k4"<@,k4"

Unquoted Quoted
Both cases print <@,k4. Either (or both) of the @s can be replaced with q instead.

Runic Enchantments, 9 bytes
"!""$;"$;

Try it online! and ""!""$;"$;"
From Kevin Cruijssen, who essentially fixed my first attempt utilizing what I did in my second.
Going down the "fungoids never have unmatched quotes" rule-bending "there's something about this that shouldn't be OK" route, alluded to in my own comment:
7 bytes
0".""$;

Try it online! and "0".""$;"
Under normal circumstances, this program executes as 0".""$;0".""$; pushing an integer 0, then the string ., concatenates $;0, NOP, concatenates an empty string, prints top-of-stack (the string .$;0) and terminates. Wrapping it in quotes produces "0".""$;" which pushes a string-0, NOPs, concatenates an empty string, prints top-of-stack, and terminates (rendering the previously un-printed integer 0 in string form). The last " is left unexecuted (and not part of the original program anyway).
Fungoids don't have string literals, they have a command that toggles "read own source as a string" mode and some form of "instruction pointer has reached the source boundary" rule (usually edge-wrap), so the same source-code-positional-byte acts as both "begin string" and "end string" instruction, creating a string literal of that entire row/column (excluding the " itself).

Super quick answer! I'm just wondering if I misunderstood something about your submission, but for me it doesn't print the $; at the end in the quoted version.

I realized that upon re-reading and am trying to puzzle out if runic can ever execute that bit. Starting to investigate "unpaired" quotes now; e.g "$; and ""$;" (Runic wrap-around quotes pairing with themselves).

@GezaKerecsenyi Let me know if my updated program violates any rules.

Umm.. How is this valid? Your program without quotes output !. (which is correct), but shouldn't your program with quotes output 0$;? PS: I don't know Runic Enchantments at all, but a potential fix based on your current layout which I think is valid would be 0"!""$;"$; (which outputs !$; as is, or outputs 0$; if surrounded with quotes). EDIT: Actually, I think you can drop the 0 and output !$; and $;.

@KevinCruijssen I think that might've been what I'd been trying to do originally and fell down a rabbit hole somewhere. Post it as your own answer dude, you earned it.

@Draco18s Nah, I don't know Runic Enchantment at all. As I said, I just looked at your answer and made an easy fix of replacing the . with the $; (which I assume is join stack and print, or just print all or something along those lines?) So you can edit your answer to "!""$;"$;, which is still 9 bytes (feel free to credit me in the answer if you'd like :) ).

@KevinCruijssen $ is "print top of stack" and ; terminates. But you essentially got a valid answer.

@draco18s the current, 9-byte solution is perfectly valid, thanks for checking.

Haskell, 31 bytes
putStr"#1;(#)=const<$>putStr--"

Try it online! Or enclosed in quotes: Try it online!

MathGolf, 4 bytes
";"q

Try it online!
The ; and q can be exchanged for a lot of different commands, including no-ops.

Ruby, 8 bytes
p";p'p'"

Try it online!
Wraps output in quotes, which may be illegal.
Ruby, 17 bytes
puts";puts'puts'"

Try it online!

JavaScript (SpiderMonkey), 25 bytes
print("-print`print()`-")

Try it online!
"print("-print`print()`-")"

Try it online!
Trivial but functional.

Japt, 4 bytes
"P"u

Unquoted, it converts the string P to uppercase. Quoted, it prints u.
Try it
Japt, 4 bytes
"P"w

Unquoted, it reverses the string P. Quoted, it prints w.
Try it

Ahem!

@Shaggy Our solutions are a bit different, there are many different solutions to this challenge

Use Q instead of P, it's more meta! ;)

R, 16 bytes
 ";print(";");"

Note that the above code is not wrapped in the additional quotation marks and has both leading and trailing spaces.
Try it (non-wrapped version)

You may want to add a note that the linked program is the non-wrapped version.

I would also add a note about the leading and trailing spaces. It's hard to notice them otherwise.

Edited, thanks for the suggestions!

AppleScript, 9 bytes
return"&"

Explained:
return"&"    -- returns "&"

Quoted:
"return"&""  -- implied return of the string "return" concatenated with ""

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


text:
Alphabet completion rate
Introduction
How much of the English alphabet does a given string use? The previous sentence uses 77%. It has 20 unique letters (howmucftenglisapbdvr), and 20/26 ≃ 0.77.
Challenge
For an input string, return the percentage of letters of the English alphabet present in the string.

The answer can be in percentage or in decimal form.

The input string can have upper and lower case, as well as punctuation. However you can assume they have no diacritics or accentuated characters.

Test cases
Input
"Did you put your name in the Goblet of Fire, Harry?" he asked calmly.

Some valid outputs
77%, 76.9, 0.7692

Input:
The quick brown fox jumps over the lazy dog

All valid outputs:
100%, 100, 1

The expected output for "@#$%^&*?!" and "" is 0.

Suggested test cases: "@#$%^&*?!", ""

If 77% and 76.9 is accepted, is 77 accepted too?

Percentages can have decimal parts too...

@GrzegorzOledzki Yes of course.

Are we guaranteed the input will contain at least one letter?

@Shaggy Based on there being a test case for "", I'm going to assume no.

@Veskah, that test case wasn't originally there.

@Shaggy Last edit for OP was 16 hours ago, your answer was at 15 and your comment at 14. I mean, you're right but ???

If 20/26 may be rounded to 0.7692, 0.769 or 0.77, can I also round it to 0.8, 1 or 0? ;-)

Is flooring the percentages okay? So, for example, return 76 for the Goblet of Fire testcase?

0.7692 is permissible. Is 00.7692? a0.7692? -0.7692?

@Khuldraesethna'Barya 00.7692 is a mathematically valid answer so it's allowed. a0.7692 and -0.7692 are not. (why would you put an a before a numerical result?)

@TeleportingGoat I wouldn't :) That was just an attempt to get you going on a slippery slope—allow the a, and there's a case to be made for -0.7692. Goodbye, 7-byter...

Python 3, 42 bytes
lambda s:len({*s.upper()}-{*s.lower()})/26

Try it online!
We filter all the non-alphabetic characters out of the string by taking the (set) difference of the uppercase and lowercase representations. Then, we take the length and divide by 26.
Python 3, 46 bytes
lambda s:sum(map(str.isalpha,{*s.lower()}))/26

Try it online!
Count the unique alphabetic (lowercase) characters, and divide by 26. In Python 2 it would require 3 more characters; two for changing {*...} to set(...), and one for making 26 a float: 26., to avoid floor division.
Python 3, 46 bytes
lambda s:sum('`'<c<'{'for c in{*s.lower()})/26

Try it online!
Same length, essentially the same as the previous one, but without "built-in" string method.

Why does the second one return 1.0 and not 1? (I didn't want to specifically disallow it so it wouldn't disadvantage specific languages, but I'm curious)

@TeleportingGoat Division with a single slash always gives floats in Python 3, even if the operands are integers. For integer division, you'd use //, but then it would always be integer division, which is obviously not what we want here. It makes sense that they didn't make the data type of the output dependent on the specific values of the operands, which means always floats, even if it's a whole number.

MATL, 8 bytes
2Y2jkmYm

Try it at MATL Online
Explanation
2Y2    % Predefined literal for 'abcdefghijklmnopqrstuvwxyz'
j      % Explicitly grab input as a string
k      % Convert to lower-case
m      % Check for membership of the alphabet characters in the string.
       % Results in a 26-element array with a 1 where a given character in
       % the alphabet string was present in the input and a 0 otherwise
Ym     % Compute the mean of this array to yield the percentage as a decimal
       % Implicitly display the result

Octave / MATLAB, 33 bytes
@(s)mean(any(65:90==upper(s)',1))

Try it online!
Explanation
@(s)                               % Anonymous function with input s: row vector of chars
             65:90                 % Row vector with ASCII codes of uppercase letters
                    upper(s)       % Input converted to uppercase
                            '      % Transform into column vector
                  ==               % Equality test, element-wise with broadcast. Gives a
                                   % matrix containing true and false
         any(                ,1)   % Row vector containing true for columns that have at
                                   % least one entry with value true
    mean(                       )  % Mean

05AB1E, 8 7 6 bytes
lASåÅA

-1 byte thanks to @LuisMendo.
Try it online or verify a few more test cases.
6 bytes alternative provided by @Grimy:
láÙg₂/

Try it online or verify a few more test cases.
Both programs output as decimal.
Explanation:
l       # Convert the (implicit) input-string to lowercase
 AS     # Push the lowercase alphabet as character-list
   å    # Check for each if it's in the lowercase input-string
        # (1 if truthy; 0 if falsey)
    ÅA  # Get the arithmetic mean of this list
        # (and output the result implicitly)

l       # Convert the (implicit) input-string to lowercase
 á      # Only leave the letters in this lowercase string
  Ù     # Uniquify it
   g    # Get the amount of the unique lowercase letters by taking the length
    ₂/  # Divide this by 26
        # (and output the result implicitly)

@LuisMendo alternatively, láêg₂/ is also a 6-byter.

@LuisMendo Thanks (and you as well Grimy)! :)

C# (Visual C# Interactive Compiler), 56 49 bytes
a=>a.ToUpper().Distinct().Count(x=>x>64&x<91)/26f

Try it online!
-6 bytes thanks to innat3

you can save 6 bytes by comparing the decimal values of the characters 50 bytes  (Character codes)

@Innat3 49 bytes by changing the && to &.

@KevinCruijssen ~2 mins off getting the -1 byte credit, already did that and was editing

@ExpiredData Np, it was an obvious golf. Was mainly directing it to Innat :)

K (oK), 19 15 bytes
Solution:
1%26%+/26>?97!_

Try it online!
Explanation:
Convert input to lowercase, modulo 97 ("a-z" is 97-122 in ASCII, modulo 97 gives 0-25), take unique, sum up results that are lower than 26, and convert to the percentage of 26.
1%26%+/26>?97!_ / the solution
              _ / lowercase
           97!  / modulo (!) 97
          ?     / distinct
       26>      / is 26 greater than this?
     +/         / sum (+) over (/)
  26%           / 26 divided by ...
1%              / 1 divided by ...

Notes:

-1 bytes thanks to ngn, 1-%[;26] => 1-1%26%
-3 bytes inspired by ngn #(!26)^ => +/26>?

I'm looking forward to the explanation! I have no idea what that 97 is doing here

Another 19 bytes alternative

%[;26] -> 1%26%

1%26%#?(26>)#97!_

Great work as always, on mobile so will update my post when I'm online!

1%26%+/26>?97!_ for 15

@streetster very nice

APL (Dyalog Extended), 10 bytesSBCS
Anonymous tacit prefix function. Returns decimal fraction.
26÷⍨∘≢⎕A∩⌈

Try it online!
⌈ uppercase
⎕A∩ intersection with the uppercase Alphabet
≢ tally length
∘ then
26÷⍨ divide by twenty-six

⌹∘≤⍨⎕A∊⌈

@ngn That's very clever, but completely different. Go ahead and post that yourself. I'll be happy insert the explanation if you want me to.

done&explained

Bash and Gnu utils (81 78 68 60 42 bytes)
bc -l<<<`grep -io [a-z]|sort -fu|wc -l`/26

-8 bytes thanks to @wastl
-18 bytes thanks to Nahuel using some tricks I didn't know:

sort -f and grep -i ignore case
sort -u is a replacement for | uniq

60 bytes: echo $(tr A-Z a-z|tr -cd a-z|fold -1|sort -u|wc -l)/26|bc -l

Right. The variable is a reminder after another attempt. Thanks!

42 bytes

Can't "grep -io [a-z]" be shortened to "grep -o [A-z]" ?

@Gnudiff Assuming ASCII, that would also match all of [^_`].

Perl 6, 27 24 bytes
-3 bytes thanks to nwellnhof
*.uc.comb(/<:L>/).Set/26

Try it online!

+1 Also, while this works just fine (and .lc would work too), from a "correctness" standpoint, .fc might be better (particularly if the challenge had non-English letters)

R, 47 bytes
function(x)mean(65:90%in%utf8ToInt(toupper(x)))

Try it online!
Converts to upper case then to ASCII code-points, and checks for values 65:90 corresponding to A:Z.

This fails when there are quotes in the input.

@C.Braun Not in my tests... For instance, the first test case on TIO includes quotes and gives the correct result. Could you give an example?

I do not quite understand what you have done in the header part on TIO, but running just the code above in an R interpreter does not work. You seem to be redefining scan to not split on quotation marks, like the default does?

@C.Braun Got it, thanks! I've explicitly made it into a function (at a cost of 3 bytes) and I think it's OK now.

PowerShell, 55 52 bytes
($args|% *per|% t*y|sort|gu|?{$_-in65..90}).count/26

Try it online!
First attempt, still trying random ideas
EDIT: @Veskah pointed out ToUpper saves a byte due to the number range, also removed extra () and a space
Expansion:
($args|% ToUpper|% ToCharArray|sort|get-unique|where{$_-in 65..90}).count/26
Changes string to all loweruppercase, expands to an array, sorts the elements and selects the unique letters (gu needs sorted input), keep only characters of ascii value 97 to 122 (a to z) 65 to 90 (A to Z), count the total and divide by 26 for the decimal output

Uppercase saves a byte

oh, just noticed you have an extra space after -in.

Java 8, 62 59 bytes
s->s.map(c->c&95).distinct().filter(c->c%91>64).count()/26.

-3 bytes thanks to @OlivierGrégoire.
Try it online.
Explanation:
s->                     // Method with IntStream as parameter and double return-type
  s.map(c->c&95)        //  Convert all letters to uppercase
   .distinct()          //  Uniquify it
   .filter(c->c%91>64)  //  Only leave letters (unicode value range [65,90])
   .count()             //  Count the amount of unique letters left
    /26.                //  Divide it by 26.0

59 bytes

@OlivierGrégoire Thanks! I always forget about c&95 in combination with c%91>64 for some reason. I think you've already suggested that golf a few times before to me.

Yes, I already suggested those, but that's OK, no worries ;-)

Way longer, but more fun: s->{int r=0,b=0;for(var c:s)if((c&95)%91>64&&b<(b|=1<<c))r++;return r/26.;} (75 bytes)

Retina 0.8.2, 45 bytes
T`Llp`ll_
+`(.)(.*\1)
$2
.
100$*
^
13$*
.{26}

Try it online! Link includes test cases. Explanation:
T`Llp`ll_

Lowercase letters and delete punctuation.
+`(.)(.*\1)
$2

Deduplicate.
.
100$*

Multiply by 100.
^
13$*

Add 13.
.{26}

Integer divide by 26 and convert to decimal.

I think retina is the only language here using percentages for the output!

Oh, nice trick with adding unary 13 before dividing! Why didn't I think of that.. >.> It would make my answer 44 bytes. I'll still leave my previous version, though.

@TeleportingGoat Probably because Retina is also the only language from the ones posted thus far which doesn't have decimal division available. Only (unary) integer-division is possible.

APL (Dyalog Extended), 8 bytes
⌹∘≤⍨⎕A∊⌈

Try it online!
loosely based on Adám's answer
⌈ uppercase
⎕A∊ boolean (0 or 1) vector of length 26 indicating which letters of the English Alphabet are in the string
⌹∘≤⍨ arithmetic mean, i.e. matrix division of the argument and an all-1 vector of the same length

K (oK), 19 bytes
1%26%26-#(!26)^97!_

Try it online!
J, 30 bytes
26%~26-u:@(97+i.26)#@-.tolower

Try it online!

32! is too broad - it makes the rest of the expression treat some punctuation chars as letters, for instance try adding : in the example input

@ngn I didn't test with punctuation at first. Thanks for reminding me.!

Retina, 57 46 35 bytes
.
$L
[^a-z]

D`.
.
100*
^
13*
_{26}

-11 bytes taking inspiration from @Neil's trick of adding unary 13 before dividing.
Another -11 bytes thanks to @Neil directly.
Rounds (correctly) to a whole integer.
Try it online.
57 46 40 bytes version which works with decimal output:
.
$L
[^a-z]

D`.
.
1000*
C`_{26}
-1`\B
.

Same -11 bytes as well as an additional -6 bytes thanks to @Neil.
Outputs with one truncated† decimal after the comma († i.e. \$0.1538\$ (\$\frac{4}{26}\$) is output as 15.3 instead of 15.4). This is done by calculating \$\lfloor{\frac{1000 × \text{unique_letters}}{26}\rfloor}\$ and then inserting the decimal dot manually.
Try it online.
Explanation:
Convert all letters to lowercase:
.
$L

Remove all non-letters:
[^a-z]

Uniquify all letters:
D`.

Replace every unique letter with 1000 underscores:
.
1000*

Count the amount of times 26 adjacent underscores fit into it:
C`_{26}

Insert a dot at the correct place:
-1`\B
.

The .* could just be . for a 1 byte saving, but you can save another 10 bytes by using Deduplicate instead of doing it manually!

@Neil Ah, didn't knew about the D-builtin, thanks! And not sure why I used .* instead of ... Thanks for -11 bytes in both versions! :)

FYI I had a slightly different approach for the same byte count: Try it online!

For the decimal version I found that -1`\B matches the desired insertion position directly.

@Neil Thanks again.

Charcoal, 11 bytes
Ｉ∕ＬΦβ№↧θι²⁶

Try it online! Link is to verbose version of code. Output is as a decimal (or 1 for pangrams). Explanation:
  Ｌ         Length of
    β       Lowercase alphabet
   Φ        Filtered on
     №      Count of
        ι   Current letter in
      ↧     Lowercased
       θ    Input
 ∕          Divided by
         ²⁶ Literal 26
Ｉ           Cast to string
            Implicitly printed

Batch, 197 bytes
@set/ps=
@set s=%s:"=%
@set n=13
@for %%c in (A B C D E F G H I J K L M N O P Q R S T U V W X Y Z)do @call set t="%%s:%%c=%%"&call:c
@cmd/cset/an/26
@exit/b
:c
@if not "%s%"==%t% set/an+=100

Takes input on STDIN and outputs a rounded percentage. Explanation:
@set/ps=

Input the string.
@set s=%s:"=%

Strip quotes, because they're a headache to deal with in Batch.
@set n=13

Start with half a letter for rounding purposes.
@for %%c in (A B C D E F G H I J K L M N O P Q R S T U V W X Y Z)do @call set t="%%s:%%c=%%"&call:c

Delete each letter in turn from the string. Invoke the subroutine to check whether anything changed, because of the way Batch parses variables.
@cmd/cset/an/26

Calculate the result as a percentage.
@exit/b
:c

Start of subroutine.
@if not "%s%"=="%t%" set/an+=100

If deleting a letter changed the string then increment the letter count.

Pepe, 155 138 bytes
rEeEeeeeeEREeEeEEeEeREERrEEEEErEEEeReeReRrEeeEeeeeerEEEEREEeRERrErEErerREEEEEeREEeeRrEreerererEEEEeeerERrEeeeREEEERREeeeEEeEerRrEEEEeereEE

Try it online! Output is in decimal form.
Explanation:
rEeEeeeeeE REeEeEEeEe # Push 65 -> (r), 90 -> (R)
REE # Create loop labeled 90 // creates [65,66,...,89,90]
  RrEEEEE # Increment (R flag: preserve the number) in (r)
  rEEEe # ...then move the pointer to the last
Ree # Do this while (r) != 90

Re # Pop 90 -> (R)
RrEeeEeeeee rEEEE # Push 32 and go to first item -> (r)
REEe # Push input -> (R)
RE RrE # Push 0 on both stacks, (r) prepend 0
rEE # Create loop labeled 0 // makes input minus 32, so the
    # lowercase can be accepted, since of rEEEEeee (below)
  re # Pop 0 -> (r)
  rREEEEEe REEee # Push item of (R) minus 32, then go to next item
  RrE # Push 0 -> (R)
ree # Do while (R) != 0

rere # Pop 0 & 32 -> (r)
rEEEEeee # Remove items from (r) that don't occur in (R)
         # Remove everything from (r) except the unique letters
rE # Push 0 -> (r)
RrEeee # Push reverse pointer pos -> (r)
REEEE # Move pointer to first position -> (R)
RREeeeEEeEe # Push 26 -> (R)
rRrEEEEee reEE # Divide it and output it

Since Pepe is only a 4 command language really it's like 34.5 bytes if you encoded it as 2 bits per r e R E?

Julia 1.0, 34 bytes
s->sum('a':'z'.∈lowercase(s))/26

Uses the vectorized version of the ∈ operator, checking containment in the string for all characters in the range from a to z. Then sums over the resulting BitArray and divides by total number of possible letters.
Try it online!

Welcome and great first answer!

Jelly, 8 bytes
ŒuØAe€Æm

Try it online!
Explanation
Œu       | Convert to upper case
  ØAe€   | Check whether each capital letter is present, returning a list of 26 0s and 1s
      Æm | Mean

C, 96 bytes
float f(char*s){int i=66,l[256]={};for(;*s;)l[1+*s++&~32]=1;for(;i<92;*l+=l[i++]);return*l/26.;}

Try it online!

Perl 5 -MList::Util=uniq -p, 24 bytes
$_=uniq(lc=~/[a-z]/g)/26

Try it online!

Stax, 9 bytes
░║üy$}╙+C

Run and debug it

You can take a byte off the unpacked version by dropping u and using |b, but the savings disappear under packing. I might have an 8-byter, but the online interpreter is being weird and buggy.

@Khuldraesethna'Barya: Nice find.
I think the bug is probably an array mutation.  I'm seeing some of that behavior now.  Working on a minimal repro...

Here's a repro of the problem I guess you're having with |b.  It incorrectly mutates its operand rather than making a copy.  I've created a github issue for the bug.  https://github.com/tomtheisen/stax/issues/29
As a workaround, |b will work correctly the first time.  After that, you may have to reload the page.
If you found a different bug, if you can provide a reproduction, I'll probably be able to fix it.

Stax 1.1.4, 8 bytes. Instructions: unpack, insert v at the start, insert |b after Va, run, remove the first v, remove |b, repack.
Yep, that's the bug I found.

@Khuldraesethna'Barya: I've released 1.1.5, and I believe this bug is fixed now.  You can let me know if you still have trouble.  Thanks.

JavaScript (Node.js), 45 bytes
s=>~-s.match(/$|([a-z])(?!.*\1)/ig).length/26

Try it online!

JavaScript (Node.js), 47 bytes
s=>(s.match(/([a-z])(?!.*\1)/ig)||[]).length/26

Try it online!

Swift 5.9, 105 100 89 bytes
let p={Float((65...90).filter(($0+"").uppercased().map(\.asciiValue).contains).count)/26}

Using Float instead of Double saved a byte.

Japt, 9 bytes
;CoU Ê/26

Try it
;CoU Ê/26     :Implicit input of string U
;C            :Lowercase alphabet
  oU          :Remove the characters not included in U, case insensitive
     Ê        :Length
      /26     :Divide by 26

Python 2, 57 bytes
lambda i:len(set(o for o in i.lower()if o.isalpha()))/26.

Try it online!
A bit longer than the Python 3 answer from ArBo but posted as a different approach in Python 2 anyway.

Ruby -n, 38 34 bytes
-4 bytes from @historcrat!
p (?A..?Z).count{|c|~/#{c}/i}/26.0

Try it online!

@histocrat you are correct

C, 95 bytes
f(char*s){int a[256]={},z;while(*s)a[*s++|32]=1;for(z=97;z<'z';*a+=a[z++]);return(*a*100)/26;}

(note: rounds down)
Alternate decimal-returning version (95 bytes):
float f(char*s){int a[256]={},z;while(*s&&a[*s++|32]=1);for(z=97;z<'z';*a+=a[z++]);return*a/26.;}

This borrows some from @Steadybox' answer.

Welcome! Good first answer. It might be helpful for people reading your answer if you provide a short explanation of your code or an ungolfed version. It may also be helpful to provide a link to an online interpreter with your runnable code (see some other answers for examples). Many use TIO, and here's the gcc interpreter

K4, 14 13 bytes
Solution:
avg .Q.a in _

Explanation:
Rather stolen from inspired by Luis Mendo's Octave solution...
avg .Q.a in _ / the solution
            _ / lowercase the input
         in   / 'in' function
    .Q.a      / "abcdefghijklmnopqrstuvwxyz"
avg           / average (mean)

Python 3, 51 49 bytes
51 -> 49 bytes, thanks to alexz02
lambda s:len({*filter(str.isalpha,s.lower())})/26

Try it online!

49 bytes
lambda s:len({*filter(str.isalpha,s.lower())})/26

@alexz02 Thank you! :)

Stax 1.1.4 online interpreter, 8 bytes, noncompeting
äQæ╟r◘Oñ

Run and debug it at staxlang.xyz!
Unpacked (9 bytes) and explanation:
Va%26!/vN
Va           Push the lowercase alphabet
  %          Length...?! Shouldn't this always be 26?
   26!       Push 26.0
      /      Divide
       vN    Subtract from one (decrement and negate)

That shouldn't work. Looking at it, you would expect an output of 0 always. Heck, it doesn't even take input! There's a bug in the online interpreter, however, which I have exploited for this answer.
Now, I've marked this answer noncompeting for a reason. As far as I can tell, this exploit requires some human interaction to set up. Here's what you gotta do:

Put your input in the input field
Unpack
Insert v at the start of the code and |b immediately after Va
Run
Remove the characters you added to the code
Repack

Now you have an 8-byte program that will give the correct output each time you run it! At least until you change the input field or reload the page.
What in the seven hells is going on:
Va%26!/vN
Va           Push the lowercase alphabet, EXCLUDING characters that existed in the input field in either case any time the vVa|b version was run
  %26!/vN    Everything else works as expected

That little bug handles case checking and filtering for free, at the expense of leaving me with the wrong set of letters (wasting two bytes on the vN). I think this can be improved rather easily, but I'm at work right now.

Haskell, 52 bytes
f s=sum[1|n<-[0..25],or[elem([c..]!!n)s|c<-"aA"]]/26

Try it online!
Avoids case conversion (which base Haskell lacks) and ASCII-code conversions (which are lengthy) in favor of writing [c..] to enumerate characters. For example, ['A'..] is a very long list that starts with ABCDEFGHI....

Ohm v2, 7 bytes
ÁαA}εÆm

Try it online!

Pyth, 9 bytes
cl@rw0G26

Try it online!
c      26 # Float division by 26 (alternative: replace 26 by lG)
 l        #   Length of
  @       #     intersection of
   r 0    #       lowercase
    w     #         input
      G   #       and the lowercase alphabet

jq -R, 36 + 3 = 39 bytes
1/length*([scan("[a-zA-Z]")]|length)

The -R flag is required, otherwise stdin needs to be a quoted string.

Does this work? For instance, it counts all occurrences, including duplicates, so the quick brown fox ends up having less than 100%. See the tests on TIO.

Emacs Lisp, 91 bytes
(lambda(a)(load"cl")(/(count-if(lambda(x)(< ?` x ?z))(remove-duplicates(downcase a)))26.0))

Try it online!

Go, 210 196 bytes
import(."strings";U"unicode")
func f(s string)float64{s=Map(func(r rune)rune{if!U.IsLetter(r){r=-1};return r},ToLower(s))
m:=make(map[rune]int)
for _,r:=range s{m[r]++}
return float64(len(m))/26.}

Attempt This Online!
Returns a float in [0,1].

C (gcc), 72 bytes
i;j;f(char*s){for(i=j=0;i++<26;)j+=index(s,i+64)!=index(s,i+96);j/=.26;}

Try it online!
-9B from c--
x86 opcode, 35 bytes
00000180: 575e 31ff ac2c 4172 030f abc7 0441 75f4  W^1..,Ar.....Au.
00000190: c1e7 06f3 0fb8 c750 df04 2458 6a1a de34  .......P..$Xj..4
000001a0: 2458 c3

Try it online!

Uiua SBCS, 9 bytes
÷26⧻◴▽±.⌵

Try it!
÷26⧻◴▽±.⌵
        ⌵  # uppercase
       .   # duplicate
      ±    # mask of cases (-1 for lower, 1 for upper, 0 for neither)
     ▽     # keep (only the letters)
    ◴      # remove duplicates
   ⧻       # length
÷26        # divided by 26

Vyxal 3, 6 bytes
ʀuȦL₂÷

Try it Online!
length of unique lowercase letters divided by 26

JavaScript (ES6), 61 54 51 bytes
s=>new Set(s.toLowerCase().match(/[a-z]/g)).size/26

57 bytes

You can't just do replace(/[^a-z]/g) because matched characters will be replaced with 'undefined' (as a string). For instance, "*abc" will create the set Set { 'u', 'n', 'd', 'e', 'f', 'i', 'a', 'b', 'c' }.

Was just about to post this myself: 51 bytes

Wolfram Language (Mathematica), 39 bytes
Length[Alphabet[]⋂ToLowerCase@#]/26.&

Try it online!

MATLAB, 53 bytes
Anonymous function taking a string:
@(a)length(unique(upper(a(isstrprop(a,'alpha')))))/26

Wolfram Language (Mathematica), 71 70 59 bytes
Count[Union@ToCharacterCode@ToUpperCase@#,x_/;64<x<91]/26.&

Try it online!
Thanks to attinat for suggesting Union to replace DeleteDuplicates.

Union is 11 bytes shorter than DeleteDuplicates.

V, 30, 29 bytes
ÓÁ
òóãˆ“±òAÝ/26.0|Óá
C="

Try it online!

EXCEL, 55 bytes
Cell A1 as input. Place in any cell by doing Ctrl+Shift+Enter . +2 bytes if {} is included in the count.
=SUM(--ISNUMBER(FIND(CHAR(ROW(A65:A91)),UPPER(A1))))/26

Oracle, 199 bytes
CREATE FUNCTION f(s LONG)RETURN FLOAT IS
r FLOAT;BEGIN
SELECT COUNT(DISTINCT c)/26 INTO r
FROM(SELECT LOWER(SUBSTR(s,LEVEL,1))c
FROM dual
CONNECT BY LEVEL<=LENGTH(s))WHERE
c>'`'AND'{'>c;RETURN r;END;

More readable version:
CREATE FUNCTION f(s LONG) RETURN FLOAT IS
    r FLOAT;
  BEGIN
    SELECT COUNT(DISTINCT c) / 26 INTO r
    FROM (
      SELECT
        LOWER(SUBSTR(s, LEVEL, 1)) AS c
      FROM dual
      CONNECT BY LEVEL <= LENGTH(s)
    )
    WHERE c > '`' AND '{' > c;
    RETURN r;
  END;

Try it on SQL Fiddle!

Haskell, 86 Bytes
Still golfable, probably.
import Data.Char
import Data.List
((/26).toEnum.length.nub.filter isLower.(toLower<$>))

Is there any better way to convert an Int to a Float?

map toLower is shorter than (toLower<$>)

C# .NET, 158 bytes
public class P{public static void Main(string[]z){var i=0;for(int q=65;q<91;q++)if(z[0].ToUpper().IndexOf((char)(q))>-1)i++;System.Console.Write(100D/26*i);}}

Try Online

MathGolf, 8 bytes
▄æl!\╧]▓

Try it online!
Based on the 05AB1E solution, so be sure to upvote that. I noticed a bug in the "contains" operator, which if resolved would remove the need of the swap.
Explanation
▄          lowercase alphabet as string
 æ         start block of length 4
  l!       push input lowercased
    \      swap top elements
     ╧     pop a, b, a.contains(b)
           loop ends here
      ]    end array / wrap stack in array
       ▓   get average of list

Factor + spelling, 44 bytes
[ >lower ALPHABET within cardinality 26 /f ]

Try it online!

>lower Convert the input to lowercase.
ALPHABET Place the lowercase alphabet on the data stack.
within Take from the input only those elements that are in the alphabet.
cardinality Count how many elements are in the resulting set.
26 /f Divide by 26 and force the result to be a float.

AWK, 72 bytes
gsub("[^a-zA-Z]",z)+gsub(z," "){for(;$++a;)b+=!c[tolower($a)]++}$0=b/.26

Try it online!
The first bit in this code is a test that's always truthy, so the associated code block will always run no matter what the input string contains.  The purpose of the gsub calls is to remove all the non-alphabetic characters and then to split the input string into space separated characters.  That re-evaluates the positional parameters, making the input a list of individual a-zA-Z characters.
gsub("[^a-zA-Z]",z)+gsub(z," "){                               }

The codeblock can then iterate over each positional parameters to process all the alphabetic characters in the input string.
                                for(;$++a;)

The body of the loop is one AWK statement that does all the real work.  It counts the number of times each unique (lowercase) character is seen.  And anytime the current counter c[...char...] is 0 it increments the tally of unique characters.
                                           b+=!c[tolower($a)]++

Once all the characters have been scanned, the final answer is the tally divided by the number of characters in the alphabet divided by 100.  Assigning that value to $0 wipes out all the other positional parameters and prints the percentage by default.
                                                                $0=b/.26

Thunno 2, 5 bytes
LẠ€Ƈm

Try it online!
Thunno 2, 7 bytes
LỊUl26/

Try it online!
Explanations
LẠ€Ƈm  # Implicit input
L      # Lowercase
 Ạ     # Lowercase alphabet
  €    # Single function map:
   Ƈ   #  Contains
    m  # Mean
       # Implicit output

LỊUl26/  # Implicit input
L        # Lowercase
 Ị       # Only alphabetic
  U      # Uniquify
   l     # Length
    26/  # Divide by 26
         # Implicit output

x86-64 machine code, 47 bytes
Standard x64 System V ABI, signature long double get_acr(char* str). The string is modified by the function, so it cannot be read-only.
57 5e 31 c9 ac ff c1 80 66 ff df 84 c0 75 f5 6a 1a df 04 24 5a d9 ee 6a 41 58 57 51 f2 ae 75 04 d9 e8 de c1 59 5f ff c0 ff ca 75 ee de f1 c3

Try it online!
Explanation
; long double get_acr(char* str)
; follows x64 SysV ABI
; input RDI: null-delimited writable string (gets modified)
; output ST0: percentage in range [0, 1]
get_acr:
    ; Get string length in rcx and convert characters to uppercase
    push rdi
    pop rsi ; get str reference in rsi
    xor ecx, ecx ; len = 0

__get_acr_convlp:
    lodsb ; get byte into rsi

    ; non-zero char: increment length and handle conversion
    ; if it is zero, we increment, do (effectively) no conversions, and store
    ; back. this +1 in ecx doesn't matter though, since it's okay if we search
    ; for letters in the zero byte later on.
    inc ecx

    ; convert by removing bit for 32 to force lowercase letters uppercase
    ; in other words, and al by ~32 (0b1101 1111, 0xdf).
    and byte [rsi-1], 0xdf

    ; loop back up if al != 0
    test al, al
    jnz __get_acr_convlp

    ; init counter rdx: do 26 times
    ; also get 26 into st1 for division later
    push 26
    fild word [rsp]
    pop rdx

    fldz ; sum starts at 0.0

    ; We only have uppercase letters now to look for
    ; Initial letter: 'A'
    push 65
    pop rax

__get_acr_loop:
    push rdi ; save rdi
    push rcx ; save rcx

    ; rcx times: search for al
    repne scasb ; go until rcx = 0 or found al (zf = 1)

    ; add 1 if zf, do nothing otherwise
    jnz __get_acr_dno

    fld1
    faddp

__get_acr_dno:
    pop rcx ; restore rcx
    pop rdi ; restore rdi

    inc eax ; next letter

    dec edx
    jnz __get_acr_loop ; loop back to top edx times

    ; Divide st0 by st1 and pop to get the fraction to return
    fdivrp st1, st0

    ret

Racket – 115 bytes
(~r(*(/(set-count(apply set(filter char-alphabetic?(string->list(string-upcase(read-line))))))26)100)#:precision 2)

Try it online!

Explanation
First, we read user input and transform it into upper case. We then turn the string into a list of characters and remove any characters that aren't alphabetic. Once done, we transform the list into a set. A Set is a data structure that can only contain unique values. That's cool because it allows us to simply count the number of elements in the set and calculate the percentage of unique letters that are used. Once all is done, we return the result as a decimal string with the precision of 2.
(~r (* (/ (set-count (apply set
                            (filter char-alphabetic?
                                    (string->list (string-upcase (read-line))))))
           26)
       100)
    #:precision 2)

Some cool things to note that I just found out is that Racket uses fractions by default to calculate large arbitrary precision. If you were to remove ~r you'd see a fraction that looks like x/y.

C (gcc), 72 bytes
Outputs via exit code
r;a[];main(c){return~c?main(getchar(r+=a[c&=95]++<c/65-c/91)):r/.26+.5;}

Try it online!
Commented
r;                // int r is zero-initialized
a[];              // same for int array a[]; it has size 1 (we'll pretend it's 96)
main(c){          // function main returns int and takes an int `c`
 return
  ~c?             // if c != -1:
   main(          //  call main() recursively with
    getchar(      //   next character from stdin or EOF(-1) (ignores argument)
     r+=          //    add the following to r:
      a[c&=95]++  //     uppercase `c`, increment the value at it's index in a[]
       <c/65-c/91 //     if (old value of a[c]) < (c/'A' - c/'[') add 1, else 0
    )             //   end call to getchar()
   )              //  end call to main()
  :               // else (we're at the end):
   r/.26+.5;      //  return the accumulated result as a % of 26, rounded
}                 // end main() function

Explanation
Alphabetic characters are in the ranges \$1000001_2..1011010_2\$ (uppercase) and \$1100001_2..1111010_2\$ (lowercase), and \$95_{10} = 1011111_2\$, so
c &= 95 makes characters uppercase and changes symbols in some way we don't care as they will not land in the same range.
For \$0 \le c \le 95\$ the equation \$\frac{c}{65} - \frac{c}{91}\$ returns 1 if \$65 \le c \le 90\$ (c is uppercase) and 0 otherwise.
So a[c &= 95]++ < c/65 - c/91 checks that isapha(c) and that this is the first time we see c in uppercase or lowercase (by incrementing the value we make sure subsequent occurrences of c will not match the expression).

Scala 3, 50 bytes
_.filter(_.isLetter).toLowerCase.distinct.size/26f

Attempt This Online!


text:
Number conversion
Assume that there is a number a. In every conversion of that number, the number can either convert itself to its value plus the value of one of its digits, or convert itself to its value minus the value of one of its digits.
In this situation, find the minimum number of conversions one has to make in order to get to the number b. If b cannot be reached, output -1.
Input
Input one line containing the integers a and b (where 1 <= a, and b <= 10^6).
Output
Output a line containing one integer, which represents the minimum amount that one has to convert the number.
Example input and output (s)
Input:  1 10
Output: 5

Why?
   1
-> 1+1=2
-> 2+2=4
-> 4+4=8
-> 8+8=16
-> 16-6=10
=> 10

The shortest program wins, as this is a code golf question.

You should make sure to specify a winning condition. This seems like it would fit under code-golf but it is unclear.

Nice challenge! It would probably be good to also provide a test case where b cannot be reached, and the function/program should return -1.

I would suggest guaranteeing that a solution can always be reached.

Or allow any behaviour, other than outputting a non-negative number, if it’s not possible to reach b

Also, this needs a few test cases, including one with output 0

Can a be greater than b?

I disagree on guaranteeing a solution can be reached. Detecting whether it can adds more to the challenge.

It can be proved that no solution if and only if 0 < b < 9 and b not in [a, 2a, 4a, 8a]

@Shaggy: This example input is no solution: 1 3

JavaScript (ES6), 98 bytes
Takes input as (a)(b). Can be very slow if there's no solution, but it should eventually return \$-1\$ (at least in theory).
a=>h=(b,k=0)=>(g=(v,n)=>n--?[...v+''].some(x=>g(+x+v,n)|g(v-x,n)):v==b)(a,k)?k:k<a+[b]?h(b,k+1):-1

Try it online!

Can this handle cases where a>b? I'm not sure if those cases are allowed by the author of the question.

@fəˈnɛtɪk Yes, I've added a test case.

Thanks. I just wasn't sure because the tests I tried caused it to timeout. They were for cases where it should return -1

05AB1E, 38 37 bytes
3Ýo*Êß8LIå*i®ë¹¸[DIå#¼Ùvy©v®y+®y-}})}¾

Can definitely be golfed a bit more..
Thanks to @tsh for the condition of the first if-statement.
Try it online or verify a few more test cases.
Explanation:
3Ý             # Push the list [0,1,2,3]
  o            # For each value, take 2 to the power that value: [1,2,4,8]
   *           # Multiply each by the first (implicit) input
    Êß         # Check that the second (implicit) input is NOT in this list
8L             # Push the list [1,2,3,4,5,6,7,8]
  Iå           # Check that the second input is in this list
*i             # If both are truthy:
  ®            #  Push -1
 ë             # Else:
  ¹¸           #  Push the first input again, and wrap it into a list
    [          #  Start an infinite loop:
     D         #  Duplicate the list at the top of the stack
      Iå       #  If the second input is in this list:
        #      #   Stop the infinite loop
      ¼        #  Increase the counter variable by 1
      v        #  Loop over each number `y` in the list:
       y©      #   Store the current number `y` in variable `®` (without popping)
         v     #   Inner loop over each digit `y2` of `y`
          ®y+  #    Add digit `y2` to integer `®`
          ®y-  #    Subtract digit `y2` from integer `®`
      }}       #  After the nested loop:
        )      #  Wrap all values on the stack into a list for the next iteration
    }¾         # After the infinite loop: push the counter variable
               # (and output the top of the stack implicitly as result)

Jelly, 33 29 bytes
0ịD;N$+Ɗ;@€)ẎL<¥Ƈȷ7Ʋ=⁴¬ȦƊ¿ẈṪ’

Try it online!
A full program that takes [[a]] as the left argument and b as the right argument.
More efficient version (36 bytes)

Python 2, 104 99 96 93 95 bytes
f=lambda a,b,i=0:i*(b in a)-(0<b<9<i)or f({x+int(c+d)for x in a for d in`x`for c in' -'},b,i+1)

Try it online!
This function takes a as a list (or set, or any other collection really), which is not ideal, but the Jelly answer does something similar it seems. My original approach with varargs couldn't be used because I needed the i parameter, with a default value, to return -1 if no answer can be found.
@tsh's prerequisites for there not being an answer are partially used. However, instead of the expensive and highly unpractical (for golfing) second part of that condition, we simply let the recursion run for a little while to see if an answer is found anyway.
Explanation
f=lambda a,b,                       # a and b are as defined in the
         i=0:                       #  challenge; i is a counter
i*(b in a)                          # Return the counter if b is found
-(0<b<9<i)                          # This is the only code needed for the
                                    #  existence problem
or f(                               # Recursively call the function
 {x+int(c+d)                        # All possible numbers in the next step
  for x in a                        # All numbers in this step
  for d in`x`                       # All digits of those numbers
  for c in' -'},                    # Either positive or negative (making
                                    #  good use of the fact that int()
                                    #  ignores leading whitespace)
 b,i+1)                             # Increase the counter

C# (Visual C# Interactive Compiler), 217 bytes
Correctly returns -1 now if b can't be reached, thanks to @tsh for the formula
(a,b)=>{var l=new List<int>(){a};int r=-1,z;if(!(b<9&!(b==a|b==2*a|b==4*a|b==8*a)))for(r=0;!l.Any(x=>x==b);r++)l.ToList().ForEach(x=>(x+"").ToList().ForEach(y=>{z=y-'0';l.Remove(x);l.Add(x+z);l.Add(x-z);}));return r;}

Try it online!

Does this just check every possible branch?

This doesn't return if there is no valid path to the number. If you put a=1 and b=3 it runs forever.

OP hasnt even specified what to return in such scenario

"If b cannot be reached, output -1."

Suggest b>8|b==a|b==2*a|b==4*a|b==8*a instead of !(b<9&!(b==a|b==2*a|b==4*a|b==8*a))


text:
Analog is Obtuse!
An analog clock has 2 hands*: Hour and minute.
These hands circle the clock's face as time goes by. Each full rotation of the minute hand results in 1/12th of a rotation of the hour hand. 2 full rotations of the hour hand signifies a full day.
As these hands are fixed to the same central point, and rotate around that point, you can always calculate the angle between the hands. In fact there are 2 angles at any given time; A larger one, and a smaller one (sometimes they will both equal 180, but that's not important)
*Our hypothetical clocks don't have second hands
Task
Given a time in 24 hour format, output the smaller angle between the hands, in degrees. If the hands are directly opposite eachother (such as at 6:00, 18:00 etc) output 180
Rules
Input may be taken as:
 - A delimiter separated string: 6:32, 14.26
 - 2 separate values, strings or ints: 6, 32, 14, 26
 - An array of 2 values, strings or ints: [6, 32], [14, 26]
You may also optionally specify that your answer requires inputs be padded to 2 digits (assuming you take strings), ie: 06:32, 06, 32, [06, 32]
You may also optionally reverse the order of the inputs, taking minute then hour, ie: 32:6, 32, 6, [26, 14]
Hour will be an integer value between 0 and 23 (inclusive)
Minute will be an integer value between 0 and 59 (inclusive)
You can assume that the minute hand snaps to increments of 6 degrees along the face (one evenly-spaced position for each minute value)
You can assume that the hour hand snaps to increments of 0.5 degrees along the face (one evenly-spaced position for each minute value per hour value)
Output must be given in degrees, not radians. You may include a trailing .0 for whole numbers
Scoring
This is code-golf so fewest bytes in each language wins!
Testcases
Input: 06:32
Output: 4

Input: 06:30
Output: 15

Input: 18:32
Output: 4

Input: 06:01
Output: 174.5

Input: 00:00
Output: 0

Input: 00:01
Output: 5.5

Input: 12:30
Output: 165

Input: 6:00
Output: 180

Input: 23:59
Output: 5.5

Sandbox post

@FryAmTheEggman "Output must be given in degrees, not radians", so I would guess not

forgot that at 5:59 hour hand is almost at 6

I was seriously considering posting something similar, except that the time would include the seconds, and that both hour and minute hands would snap to the nearest whole degree (because that's how my watch works, ignoring that it has a second hand).

Suggested test case: 00:59 -> 35.5 (a small value of $h$ with a large value of $m$ is likely to make some implementations fail).

Thanks, @Arnauld, you just cost me a byte! :p

Related: https://codereview.stackexchange.com/a/182054

JavaScript (ES6),  41 40  39 bytes
Takes inputs as (h)(m).
h=>m=>((x=4+h/3-m*.55/9)&2?12-x:x)%4*90

Try it online!
How?
Instead of working directly in the range \$[0..360]\$, we define a temporary variable \$x\$ in the range \$[0..4]\$:
$$x=\left|\frac{4h}{12}+\frac{4m}{60\times12}-\frac{4m}{60}\right|\bmod 4$$
$$x=\left|\frac{4h}{12}-\frac{44m}{60\times12}\right|\bmod 4$$
$$x=\left|\frac{h}{3}-\frac{11m}{180}\right|\bmod 4$$
The angle in degrees is given by:
$$\min(4-x,x)\times90$$
However, the formula is implemented a bit differently in the JS code, as we definitely want to avoid using the lengthy Math.abs() and Math.min().
Instead of computing the absolute value, we force a positive value in \$[0..12]\$ by computing:
$$x'=4+\frac{h}{3}-\frac{11m}{180}$$
And instead of computing the minimum, we determine in which case we are by simply doing a bitwise AND with \$2\$ -- and this is why we chose an interval bounded by a power of \$2\$ in the first place.

Jelly, 14 12 bytes
×“<¿‘Iæ%Ø°AH

Try it online!
A monadic link which takes the time as a list of two integers: hour, minute.
Thanks to @JonathanAllan for saving 2 bytes!
Explanation
×“<¿‘        | Multiply hour by by 60 and minute by 11
     I       | Find difference
      æ%Ø°   | Symmetric mod 360 [equivalent to (x + 360) mod 720 - 360]
          A  | Absolute
           H | Half

Symmetric mod? How's that work?

@Shaggy Very conveniently, it returns the value in interval (-180, 180] that's equivalent (mod 360). Those builtins...

Save two bytes by working in half degrees, with the use of Ø° for 360 and “<¿‘ for 60,11. Like so ×“<¿‘Iæ%Ø°AH TIO

I was going to say 12 characters, but it turns out Windows-1252 (and a few other encodings) can actually encode this in 12 bytes. Between the various non-ASCII characters, I didn't think a single non-Unicode encoding would cover them all, but, apparently, I'm very wrong there.

@Thanatos Some languages specialized in code-golfing have their own code-pages for the 256 characters they encode in 1 byte each. Jelly is one of them, with this custom code-page. 05AB1E, Charcoal, MathGolf, Stax, etc. are other languages with custom code-pages. Most are indeed based on Windows-1252, though. :)

MATL, 18 bytes
30*i5.5*-t360-|hX<

Accepts two inputs of hours followed by minutes. Uses the same method as this answer
Try it at MATL Online
Explanation
      % Implicitly grab first input (hours)
30*   % Multiply by 30
i     % Explicitly grab second input (minutes)
5.5*  % Multiply by 5.5
-     % Take the difference
t     % Duplicate the result
360-  % Subtract 360
|     % Take the absolute value
h     % Horizontally concatenate
X<    % Determine the minimum value
      % Implicitly display the result

Won't this fail for midnight, outputting 180 instead of 0?

Wolfram Language (Mathematica), 30 29 28 bytes
5Abs@Mod[#.{6,-1.1},72,-36]&

Try it online!
ungolfed version:
Abs[Mod[#.{30,-5.5}, 360, -180]] &

The argument of the function is # = {h,m} containing the hour and the minute. This length-two list is interpreted as a vector and the dot-product with {30,-5.5} is calculated: #.{30,-5.5} = 30*h-5.5*m. Then we calculate the symmetric modulus of 360 with Mod[#.{30,-5.5}, 360, -180] giving an angle in the interval -180..+180. Abs takes the absolute value thereof.
As all involved operators are linear, we can multiply and divide all appearing numbers however they are most convenient. By pulling a factor of 5 out of the expression and dividing all numbers in the expression by 5, the byte-count is minimized.

Alchemist, 134 bytes
_->In_h+In_m+720d+360a+f
h->60d
m+11d->
0m+d+a+0r->b
0a+0x->r
d+b+r->r+a
r+0b->
b+0d+0h+0y->5y
b+0d+5y->x
0b+0d+f->Out_x+Out_"."+Out_y

Try it online!
Explanation
_->In_h+In_m+720d+360a+f

Initial setup.  Inputs hours and minutes into h and m, sets current angle d to 360 degrees (720 half-degrees), sets up a to compute the principal angle, and sets the output flag.
h->60d
m+11d->

Each hour adds 30 degrees, and each minute subtracts 5.5 degrees.
0m+d+a+0r->b
0a+0x->r

While the r (reverse) flag is not set, each d atom should move one a atom to b.  This occurs after the minutes are all used up, to avoid a "race condition".  When there are no a atoms remaining, set r to reverse this flow.
Note that this second rule can trigger multiple times, and can even trigger before the initial setup rule.  This does not harm anything, so there's no need to prevent this.  The 0x condition handles an edge case: when the input is 6:00, there are no a atoms when the program terminates, but there are x atoms if the final result is at least 1 degree.
d+b+r->r+a
r+0b->

The reverse: when the signed angle is greater than 180 degrees, move b atoms to a to decrease the angle to output.  Stop reversing when the angle reaches "360".
b+0d+0h+0y->5y
b+0d+5y->x

When all of the degree atoms are used up, divide by 2 to get the angle to output.
0b+0d+f->Out_x+Out_"."+Out_y

After this is done, output exactly once using the f flag from the initial setup.

Python 3.8 (pre-release), 45 43 bytes
-2 bytes thanks to Erik.
lambda h,m:min(x:=abs(h%12*30-m*5.5),360-x)

Try it online!
h%12 - hour in 12-hour format
h%12*30 - angle of hour hand at the full hour
m/2 - angle the hour hand moved in m minutes
h%12*30+m/2 - current position of the hour hand as an angle
m*6 - angle of the minute hand (360°/60 = 6°)

C# (Visual C# Interactive Compiler), 47 45 bytes
h=>m=>(h=(360+h%12*30-m*5.5)%360)<180?h:360-h

Try it online!

Stax, 15 bytes
Ç╢e╛╦¡uøßmì♪║└├

Run and debug it

m = number of minutes since midnight
d = 5.5 * m
The result is min(d % 360, -d % 360).

Charcoal, 22 bytes
Ｉ↔⁻¹⁸⁰﹪⁻×³⁰⁺⁶Ｎ×⁵·⁵Ｎ³⁶⁰

Try it online! Link is to verbose version of code. Takes input as two integers. Explanation:
             Ｎ          First input
           ⁺⁶           Plus literal 6
        ×³⁰             Multiplied by literal 30
       ⁻                Minus
                  Ｎ     Second input
              ×⁵·⁵      Multiplied by literal 5.5
      ﹪            ³⁶⁰  Modulo literal 360
  ⁻¹⁸⁰                  Subtracted from literal 180
 ↔                      Absolute value
Ｉ                       Cast to string
                        Implicitly print

Perl 6, 28 bytes
((*/3-*/9*.55+2)%4-2).abs*90

Try it online!
Uses a few tricks stolen from other answers and calculates
r = abs((h/3 - m/9*0.55 + 2) % 4 - 2) * 90
  = abs((h*30 - m*5.5 + 180) % 360 - 180)

Tcl, 71 74 59 54 bytes
{{h m {x (60*$h-$m*11)%720}} {expr min($x,720-$x)/2.}}

Try it online!
saved 5 bytes by using a lambda expression

Python 3, 40 bytes
lambda h,m:180-abs(180-(h*30-m*5.5)%360)

Try it online!
h*30 - angle between noon and the hour h when the minute is 0; if the hour is equal or greater than 12, this angle can be equal or greater than 360°
m*6 - angle between noon and the minute hand
m*.5 - angle the hour hand moved forward from the full hour after m minutes (e.g: if it's 4:24, the hour hand moved forward 12 degrees from the position it was in at 4 o'clock)
h*30-m*5.5 - one of the two angles between the hour hand and the minute hand; the coefficient for m is 5.5 because m*6-m*.5=m*5.5; this is still not the answer because it can be a value greater than 360° (e.g: if h,m=13,0) or less than 0° (e.g: if h,m=12,30)
(h*30-m*5.5)%360 - this modulo takes into account the cases where the computed value above is not between 0 and 360°; this is still not the answer because it could be the ampler of the two angles, while we want the most narrow
180-abs(180-(h*30-m*5.5)%360) - this is the final result; the general rule is that x-abs(x-y) is equivalent to min(y,x-y), which would give the correct result

Python 3, 58 57 Bytes
-1/-2 Thanks to @Shaggy
h,m=eval(input())
x=(30*h-5.5*m)
print(abs(min(x,360-x)))

Naive implementation, takes input in the form of [6,32]. Some bytes can probably be shaved off the last line especially.
Python 2, 52 50 Bytes
h,m=input()
x=(30*h-5.5*m)
print abs(min(x,360-x))

30*h-5.5*m should save you a couple of bytes.

A def-style function should save some bytes as well.

@negativeseven from the challenge wording it seemed like it should be using stdin/stdout

You can drop the parentheses on the 2nd line.

The solutions actually need a few modifications (Python 2) to work correctly. The result should be less than or equal to 180, and greater than or equal to 0.

Japt, 16 bytes
*FÑ aV*5½
mUa360

Try it
*FÑ aV*5½     :Implicit input of integers U=h and V=m
*F            :Multiply U by 15
  Ñ           :Multiply by 2
    a         :Absolute difference with
     V*5½     :V multiplied by 5.5
mUa360        :Reassign to U
m             :Minimum of U and
 Ua360        :Absolute difference of U and 360

Perl 5 -MList::Util=min -p, 37 bytes
$_=abs<>*5.5-$_%12*30;$_=min$_,360-$_

Try it online!
Takes input as hours followed by minutes on a separate line because it saved a few bytes.

OK.  Fixed that.

05AB1E, 16 bytes
60*+5.5*D(‚360%ß

Takes hours as first input, minutes as second.
Try it online or verify all test cases.
Explanation:
Basically implements the following formula:
$$t = (60h+m)×5.5$$
$$r = min(t\bmod360,-t\bmod360)$$
60*               # Multiply the (implicit) hours-input by 60
   +              # Add it to the (implicit) minutes-input
    5.5*          # Multiply it by 5.5
        D(‚       # Pair it with it's negative
           360%   # Take modulo-360 on both
               ß  # And then pop and push the minimum of the two
                  # (which is output implicitly as result)

[R] , 45 bytes
 function(h,m)min(t=(60*h+m)*5.5%%360,-t%%360)

><>, 17 bytes
b*$6a**-:0)12,-*n

Try it online! (6:32)
Takes input as h, m on the stack.
Explanation
b*$6a**-:0)12,-*n
b*                Multiplies m by 11
  $               Swaps m & h
   6a**           Multiplies h by 60
       -          Subtracts m & h (v)
        :0)       Checks if v > 0 (b=0/1)
           12,-   Subtracts .5 from b (-.5/.5)
               *  Multiplies v by b (halve & abs)
                n Outputs result
b*                Errors

Pyret, 59 bytes
{(h,m):x=(30 * h) - (m * 5.5)
num-abs(num-min(x,360 - x))}


text:
Inverse-quotes-quine, inverted (pt. 2)
Based on a comment by Jo King on my previous question (called 'Inverse-quotes-quine'), I present this new question. The rules are similar, but just, the opposite:

If your program is run normally, all of the code not in the speech marks (" - double quotes) should be printed.
If your program is wrapped in double quotes (in turn inverting the speech marks), the code that is normally n̶o̶t̶ in quotes should be printed.

E.g:
Let's say you have the following code:
fancyStuff("myCode"); "I like".isGreat();

If I run it, I would expect an output of:
fancyStuff(
);
.isGreat();

However, if I wrapped it in quotes, I would get:
"fancyStuff("myCode"); "I like".isGreat();"

When this code is run, the expected output would be:
myCode
I like

Obviously, the above example is not a functional response in any language. Your job is to write the code that performs in this way.
Rules

Standard loopholes apply.
The printed values, in both quoted and unquoted forms, must be non-empty, or consist solely of whitespace. This also means that all programs must include at least one set of quotes.
However, trailing/preceeding whitespace is allowed.
The quoted and unquoted strings must print different results.
No looking at your own code, required file names, etc.
Unmatched quotes are disallowed
If there are multiple strings, they can either be printed as newlines (as in the example), or in some other human-readable way - no arrays or objects
This is code-golf, so shortest answer in bytes wins.

So, if i understand correctly, any answers in that question which print the same string for both raw and wrapped source is also valid to this one.

@tsh technically correct, but I should probably add a rule against that...

Python 2, 32 bytes
''*2;print"''*2;print"''*2;print

Try it online!
Based on my initial solution for the other variant of this puzzle.

><>, 39 16 bytes
"l2*0.|or|["090.

Try it online!
(quoted)
Explanation
        BA
"l2*0.|or|["090.
"l2*0.|or|["     Pushes the quoted characters onto the stack
            0    Pushes 0
             90. Goes to A
          [      Wipes the stack (requires the 0)
"          "090. Pushes the quoted characters onto the stack
 l2*0.           Length is 4; goes to B
      |or|       Reverses & prints the stack

A        B
""l2*0.|or|["090."
""                 No-op
  l2*0.            Length is 0; goes to A
 "l2*0.|or|["      Pushes the quoted characters onto the stack
             0     Pushes 0
              90.  Goes to B
       |or|        Reverses & prints the stack

Old answer, 39 bytes
"!~l?!<r&[orl&"0[c2*&d0.>o<~~.!?@@0+1fl

Try it online!
(quoted)
Whew, this took a while. Can probably be golfed further.
             A
"!~l?!<r&[orl&"0[c2*&d0.>o<~~.!?@@0+1fl
"!~l?!<r&[orl&"                         Pushes the quoted characters onto the stack
               0[                       Wipes the stack
                 c2*&                   Puts 24 into the register (&)
                     d0.                Goes to A
"             "0[c2*&d0.>o<~~.!?@@0+1fl Pushes the quoted characters onto the stack
 !~l?!<                                 No-op (in this case)
       r                                Reverses the stack
        &[                              Wipes the stack, preserving the top &
          o                             Outputs the top character on the stack
           r                            Reverses the stack
            l&                          Puts the current length of the stack into the register
                                        Repeats until &=0, then errors

                B
""!~l?!<r&[orl&"0[c2*&d0.>o<~~.!?@@0+1fl"
""!~                                      No-op
    l?!<                                  Reverses the IP direction
""!~l?!                                 " No-op
                            ~~.!?@@0+1fl  If the length is 0, go to B
""!~l?!<r&[orl&"                        " Pushes the quoted characters onto the stack (backwards)
                            ~~.!>@@0+1fl  No-op (length != 0)
                         >o<              Outputs all the characters on the stack, then errors

(Note: when I "wipe" the stack, it really creates a new stack; the old stack is still there and accessible)

05AB1E (legacy), 5 bytes
·"·"·

Outputs concatenated without separator.
Try it online or try it online with surrounding quotes.
Explanation:
         # Program without surrounding quotes will output string "··"
·        # Double the top of the stack, which is empty, so an empty string is pushed
 "·"     # Push string "·" to the stack
    ·    # Double it (2*). Since the legacy version is built in Python, the string is
         # concatenated with itself: "··"
         # (output the top of the stack implicitly as result)

         # Program with surrounding quotes will output string "·"
"·"      # Push string "·" to the stack
   ·     # Double it to string "··"
    "·"  # Push string "·" to the stack
         # (output the top of the stack implicitly as result)

Gol><>, 9 bytes
 `H"H` "H

Try it online! Quoted version.

><>, 17 bytes
"af0.|o<"i!.1!0<9

Try it unquoted! Quoted!

Runic Enchantments, 11 bytes
!"!""!$;"$;

Try it online! and "!"!""!$;"$;"
Just a one-byte 'inversion' of the prior answer (and 1 byte for having to include the inverting-byte as part of a string literal as well).
Explanation
Note that . is a NOP command and used as a spacer where other commands are not executed or otherwise removed for explanatory purposes.
!" is effectively NOP, resulting in the execution of only ...."!$;"$; which prints the contents of the code not contained between quote-pairs (!........$;)
Wrapping everything in quotes causes the first !" to be string literal, resulting in "!".."!$;"$;. and which prints the parts of the program contained within quote-pairs ("!" and "!$;").


text:
Letter Boxed, part 2: this time, solve it
This challenge is a sequel to Letter Boxed Validator.
The New York Times has a daily online game called Letter Boxed (the link is behind a paywall; the game is also described here), presented on a square as follows:

You are given 4 groups of 3 letters (each group corresponds to one side on the picture); no letter appears twice. The aim of the game is to find words made of those 12 letters (and those letters only) such that:

Each word is at least 3 letters long;
Consecutive letters cannot be from the same side;
The last letter of a word becomes the first letter of the next word;
All letters are used at least once (letters can be reused).

In this challenge, you are given the letters, and a dictionary. The goal is to output a valid solution, which minimizes the number of words used. If there is no solution, any consistent output is acceptable.
For the input {{I,C,O}, {M,R,E}, {G,N,S}, {A,P,L}}, a valid solution is PILGRIMAGE, ENCLOSE. Another valid solution is SOMNOLENCE, EPIGRAM. The following are not valid:

PILGRIMAGE, ECONOMIES (can't have CO since they are on the same side)
GRIMACES, SOPRANO (L has not been used)
PILGRIMAGE, ENCLOSURE (U is not one of the 12 letters)
ENCLOSE, PILGRIMAGE (last letter of 1st word is not first letter of 2nd word)
CROPS, SAIL, LEAN, NOPE, ENIGMA (number of words is not minimal)

Input
Input consists of a dictionary, and of 4 groups of 3 letters. It can be in any suitable format.
Output
A list of words giving a solution to the challenge. There may be several acceptable solutions: you should output at least one, but may output several if you want.
Test cases
The test cases use this dictionary. If using a large dictionary is too difficult on TIO, you may use instead the dictionary {PILGRIMAGE, ENCLOSE, SOMNOLENCE, EPIGRAM, ECONOMIES, GRIMACES, SOPRANO, ENCLOSURE, CROPS, SAIL, LEAN, NOPE, ENIGMA, OVERFLOWS, STACK, QUESTIONABLY, QUARTZ, ZIGZAG, GHERKIN, CODE, GOLF, NO, I, DO, NOT, IN}, but your code should in principle work on a larger dictionary.
Note that the solution is not necessarily unique; these are possible solutions.
Input={{I,C,O}, {M,R,E}, {G,N,S}, {A,P,L}}.
Solution: PILGRIMAGE, ENCLOSE
Input:{{OSA}, {FVK}, {WEL}, {CTR}}.
Solution: OVERFLOWS, STACK.
Input: {{BCD}, {FGH}, {JKL}, {MNP}}.
No solution.
Input: {{AQT}, {LUI}, {BOE}, {NSY}}.
Solution: QUESTIONABLY
Input: {{QGN}, {ZUR}, {AHK}, {ITE}}.
Solution: QUARTZ, ZIGZAG, GHERKIN.
Scoring:
This code-golf, lowest score in bytes wins!

Sandbox link

Do I receive the dictionary as input?

@EmbodimentofIgnorance Yes, dictionary is part of the input. Clarified.

Such a large dictionary is going to be hard to embed in TIO links -- if it's possible at all. I'd recommend to provide a much smaller dictionary including all words used in the solutions and just a couple of other useless ones.

@Arnauld OK, I've added a small dictionary which should be enough for all test cases.

Jelly, 38 bytes
iⱮⱮL>2ƊƇẠƇ’:3IẠƲƇŒPU=ḢɗƝẠ$ƇFQL=ʋƇ12ịḷḢ

Try it online!
A dyadic link taking the flattened letters as left argument and the dictionary as right. Returns a list of strings of one of the shortest solutions, or a zero if there is no solution.
Full explanation to follow once it’s a bit better golfed.


text:
Output the nth 'boring' number
There are 9 main types of numbers, if you categorise them by the properties of their factors. Many numbers fall into at least one of these categories, but a few don't. The categories are as follows:

Prime - no integer divisors other than itself and one
Primitive abundant - A number \$n\$ whose factors (excluding \$n\$) sum to more than \$n\$, but for any factor \$f\$ of \$n\$, the sum of the factors of \$f\$ sum to less than \$f\$
Highly abundant - A number \$n\$ whose factors (including \$n\$) sum to more than that of any previous number
Superabundant - A number \$n\$, such that the sum of the factors of \$n\$ (including \$n\$) divided by \$n\$ is greater than the sum of factors of \$g\$ over \$g\$ for any value \$0<g<n\$
Highly composite - A number \$n\$ which has more factors than \$g\$, where \$g\$ is any number such that \$0<g<n\$
Largely composite - same as highly composite, but \$n\$ can have also have equally as many factors as \$g\$
Perfect - A number that is exactly equal to the sum of its factors (excluding itself)
Semiperfect - A number that can be made by summing up two or more of its factors (excluding itself)
Weird - A number \$n\$ that is not semiperfect, but which's divisors sum to more than \$n\$.

A so-called 'boring number' is any positive, non-zero integer which does not fit into any of these categories.
Your job is to create the shortest possible program which can, given a positive number \$n\$, outputs the \$n\$th boring number.
Note: I am aware there are more categories, but I wanted to avoid using mutually exclusive ones (such as deficient and abundant), because then every number would fall into one of them.
Rules

Standard loopholes apply; standard I/O methods apply.
All inputs will be positive, non-zero integers, a single output is expected.
n can be 0- or 1- indexed.
This is code-golf, so shortest answer in bytes wins.

Tests
The first 20 boring number are:
9, 14, 15, 21, 22, 25, 26, 27, 32, 33, 34, 35, 38, 39, 44, 45, 46, 49, 50

Do the factors of $n$ include $1$ or no? Just making sure

@ValueInk - Yep.

If I understand right, a number that is neither perfect, semiperfect, nor weird has to be deficient, which makes a lot of the other conditions redundant.

Why isn't 16 a boring number?

I think I got it, 16 is highly abundant as the number itself should be included in the sum and 1+2+4+8+16 = 31 > 28 = 1+2+3+4+6+12

JavaScript (ES6),  226 220  209 bytes
Saved 11 bytes thanks to @HermanL
Input is 1-indexed.
f=(x,n=m=c=1,D=k=>k?n%k?D(k-1):[k,...D(k-1)]:[],S=a=>s=eval(a.join`+`))=>(S(a=D(n))>m?m=s:0)|(s=a.length)<3|(s<c?0:c=s)|a.reduce((a,x,i)=>i?[...a,...a.map(y=>[...y,x])]:a,[[]]).some(a=>S(a)>=n)||--x?f(x,n+1):n

Try it online!
Optimizations are based on the following properties:

All primitive abundant numbers are either semiperfect or weird.
All highly composite numbers are largely composite.
All superabundant numbers are highly abundant.

-9 bytes by inlining the D function (as it is only used once) TIO

@HermanL Thanks! (Inlining D doesn't actually change anything, but your more concise rewrite of the function definitely does.)

Another 2 bytes saved: TIO

05AB1E, 43 39 36 33 24 bytes
∞ʒpyLRÑOć‹PyÑ¨©æOyå®Oy›O_}Iè

-4 bytes thanks to @Mr.Xcoder.
-12 bytes thanks to @Grimy (of which -5 are because "Highly composite numbers higher than 6 are also abundant numbers", and -4  because "'The sum of N's divisors is greater than N' is equivalent to 'The sum of some subset of N's divisors is greater than N'").
0-indexed.
Try it online or output the first \$n\$ values of the sequence.
Explanation:
∞           # Push an infinite list of positive integers: [1,2,3,...]
 ʒ          # Filter it by, leaving only the integers `y` which are truthy for:
  p         #  1) Check if `y` is a prime
  yL        #  Create a list in the range [1, `y`]
    R       #  Reverse the list to range [`y`, 1]
     Ñ      #  Get the divisors of each integer
      O     #  Sum the inner lists together
       ć    #  Extract the head; pop and push remainder-list and head
        ‹P  #  2) Check if each value in the remainder-list is smaller than the head
  yÑ        #  Get the divisors of `y`
    ¨       #  Remove the last item (`y` itself)
     æ      #  Powerset; get all possible combinations of these divisors
            #  (this includes both an empty list and all divisors of `y`)
      O     #  Sum each inner combination-list
       y@à  #  3) Check if any sum is larger than or equal to `y`
  O_        #  And only leave the integers in the filter which are falsey for all checks
}Iè         # After the filter: Index the input-integer into the filtered list

1) covers the check for Prime
2) covers the checks for Highly Abundant, Superabundant, Largely composite and Highly composite
3) covers the checks for Perfect, Semiperfect, Weird, and Primitive Abundant

@Grimy Thanks. Not sure how I missed yå.. Such an obvious golf. But thanks for the 2FyLÑRNmOć‹P}. I had the feeling I could somehow combine some parts, but wasn't sure how. And yes, I indeed noticed I still used the X from the old version in the explanation.

@Grimy Oh, very nice optimizations!

ć‹P can be Zk_ (same byte-count but easier to type).

Java, 208 bytes
Input is 1-indexed.
interface a{static void main(String[]a){int i=0,n=0,x=1,z=1,j,u,f,b;for(;n<new Integer(a[0]);n+=f>=i?0:1/++b){for(i+=j=u=f=b=1;++j<i;)if(i%j<1){f+=j;b=0;u++;}x=f>x--?b=f:x;z=u>=z?b=u:z;}System.out.print(i);}}

in readable form:
interface a
{
    static void main(String[]a)
    {
        int i=0,n=0,x=0,z=0,j,u,f,b;
        for(;n<new Integer(a[0]);n+=f>=i?0:1/++b)   //checks perfect, semiperfect, weird, and p. abundant numbers
        {
            for(i+=j=u=f=b=1;++j<i;)if(i%j<1){f+=j;b=0;u++;}    //checks prime numbers
            x=f>x--?b=f:x;              //checks highly abundant and superabundant numbers
            z=u>=z?b=u:z;               //checks largely and highly composite numbers
        }
        System.out.print(i);
    }
}

Suggest f<i?1/++b:0 instead of f>=i?0:1/++b and f+=i%j<1?j+=b=0*u++:0; instead of if(i%j<1){f+=j;b=0;u++;} and u>z instead of u>=z

Jelly, 28 bytes
Æd,Æs)Ṫ_$<Ø.S;Æṣ<$;Ẓ¬$Ạµ#}1Ṫ

Try it online!
A full program taking a single argument N and outputting the 1-indexed boring number.
Takes advantages of the optimisations noted in the description of @Arnauld’s answer, but not based on the JavaScript code.
Explanation
Æd,Æs)Ṫ_$<Ø.S;Æṣ<$;Ẓ¬$Ạµ#}1Ṫ

                       µ#}1  | Run the following for each number from 1 increasing in steps of 1 until we have as many true values as indicated by the argument, then return the numbers for which it was true:
     )                       | - For each number from 1 up to the currently tested number:
Æd                           |   - Count of divisors
  ,                          |   - Paired with:
   Æs                        |     - Sum of divisors
      Ṫ_$                    | - Tail (divisor count and sum for current number) minus divisor count and sum for all smaller numbers
         <Ø.                 | - Check if each [divisor count difference, divisor sum difference] < [0, 1]
            S                | - Sum (will sum the checks of divisor count difference and divisor sum difference separatelt)
             ;               | - Concatenate to:
              Æṣ<$           |   - Whether proper divisor sum less than current number
                  ;          | - Concatenate to:
                   Ẓ¬$       |   - Whether number is not prime
                      Ạ      | - All of these (only true for boring numbers)
                           Ṫ | Finally, take the tail (the requested boring number)

In contrast to many of the Jelly code explanations I’ve written, this almost goes from left-to-right!

Python 2, 155 bytes
n=input();k=D=N=0
while n:k+=1;L=[d for d in range(1,k+1)if k%d<1];S=sum(L);W=len(L);K=S-k;x=K<2or S>D or W>=N or K>=k;n-=1-x;N=max(W,N);D=max(D,S)
print k

Try it online! first n entries