Python 3, 80 79 59 bytes

^{-1 byte thanks to Arnauld-20 byte thanks to ArBo}

lambda x:[60*x-i+80for i in b'uomigc`]a^[XWUTRQ'[(x>1)*8:]]

Try it online!

R, 64 bytes

function(n,`!`=utf8ToInt)c(60*n-!"",(!"#%),/")[n<2])

Try it online!

Ports the amazing answer found by Rod.

R, 85 73 68 bytes

function(n)setdiff(0:(60*n),combn(rep(c(0:20%o%1:3,25,50),n),n,sum))

Try it online!

Brute force generates all possible scores with n darts, then takes the appropriate set difference.

Credit to OrangeCherries' Octave solution for reminding me of combn.

5 more bytes thanks to Robin Ryder's suggestion of using %o%.

JavaScript (ES6), 55 bytes

Based on the pattern used by Rod.

n=>[...1121213+[n-1?33:2121242426]].map(x=>s-=x,s=60*n)

Try it online!

Jelly, 19 bytes

20Ż;25×Ɱ3ẎṖœċ⁸§ṪṖḟƊ

Try it online!

Python 2, 125 bytes

lambda n:set(range(60*n))-set(map(sum,product(sum([range(0,21*j,j)for j in 1,2,3],[25,50]),repeat=n)))

from itertools import*

Try it online!

Python 3, 126 125 bytes

lambda n:{*range(60*n)}-{*map(sum,product([i*j for i in range(21)for j in(1,2,3)]+[25,50],repeat=n))} 

from itertools import*

Try it online!

Octave, 91 bytes 73 bytes 71 Bytes

Another brute force method. Not sure about the rule on the 'f=' part for anonymous functions

@(n)setdiff(0:60*n,sum(combnk(repmat([x=0:20,x*2,x*3,25,50],1,n),n),2))

Down to 73 Bytes thanks to Giuseppe

Down to 71 Bytes by replacing nchoosek with combnk

Try it online!

MATL, 25 bytes

:!21:q*25tEvGZ^!stX>Q:qX~

Try it online!

Explanation

Brute force approach.

:!     % Implicit input n. Push column vector [1;2;...;n]

21:q   % Push row vector [0 1 ... 20]

*      % Multiply with broadcast. Gives a matrix with all products

25     % Push 25

tE     % Duplicate, double: gives 50

v      % Concatenate everything into a column vector

GZ^    % Cartesian power with n. Gives a matrix with each n-tuple on a row

!s     % Sum of each row

tX>    % Duplicate, maximum. This gives 60*n

Q:q    % Push row vector [0 1 ... 60*n]

X~     % Symmetric difference. Implicit display

Perl 6, 42 bytes

{^60*$_∖[X+] [[|(^21 X*^4),25,50]xx$_,]}

Try it online!

Brute force solution that works out all possible dart values.

Perl 6, 39 bytes (37 chars)

This is definitely using a massive sledgehammer but it works. (It doesn't just brute force it, it brutally brute forces it)

{^60*$_∖[X+] (|(^21 X*^4),25,50)xx$_}

Try it online!

Here's an explanation of it:

{                                   } anonymous block for the 

       ∖                                set difference of

 ^60*$_                                   - 0 .. max score (60 * throwcount)

        [X+]                    xx$n      - the cross addition (throwcount times) of 

             (                 )              all possible score values, being 

              |(    X*  )                       flattened cross multiplication of

                ^21   ^4                          0..20 and 0..3 (for double and triple)

                         ,25,50                 and 25 and 50

The X* ^4 cross multiplier generates a lot of duplicate values (there will be 20+ zeros involved and that's before doing the cross addition), but that doesn't cause any problems since we use the set difference ∖ which works with the unique values.

This currently fails for $n == 1 (which should return an empty set), but there is an issue filed and will likely work in future versions. JoKing's version is a teeny bit longer, but works for $n == 1 in current Rakudo.

Jelly, 28 bytes

21Ḷ×þ3R¤;25;50FœċµS€³×60¤R¤ḟ

Try it online!

Charcoal, 36 bytes

Ｉ⁺Ｅ…wvtsqpmjgkhea_[YS⎇⊖θ⁹¦¹⁷℅ι×⁶⁰⁻θ²

Try it online! Link is to verbose version of code. Uses @Rod's algorithm; brute force would have taken 60 bytes. Works by truncating the string to 9 characters if the input is greater than 1, then taking the ordinals of the characters and adding the appropriate multiple of 60.

J, 48 bytes

(2&>#35 44,q:@1474249423),60&*-1 4 8 14,q:@13090

Try it online!

Attempted a brute force solution, but was not able to beat this translation of Rod's idea.

Perl 5 -n, 96 bytes

$"=',';@b=map{(25,50,$_,$_*2,$_*3)}0..20;%k=map{(eval,1)}glob"+{@b}"x$_;$k{$_}||say for 0..$_*60

Try it online!

It was optimized for code length rather than run time, so it's kind of slow. It generates a lot of redundant entries for its lookup hash. Running the @b array through uniq speeds it up greatly, but costs 5 more bytes, so I didn't do it.

Stax, 24 bytes

¿ß☺o↕αg╠╩╬ò▼í¬«¥↕▄í■♣▓î►

Run and debug it

It's pretty slow for n=3, and gets worse from there.