[Question]
  [
I was surprised to not find this asked already, though there is a great question on darts checkouts: [Darts meets Codegolf](https://codegolf.stackexchange.com/questions/20076/darts-meets-codegolf)
Your challenge is to calculate which scores are not possible with 'n' darts below the maximum score for 'n' darts. E.g. for n=3, the maximum possible score is 180 so you would return [163,166,169,172,173,175,176,178,179]
For a bare bones rule summary:
Possible scores for a single dart are:
* 0 (miss)
* 1-20, 25, 50
* double or triple of 1-20
Rules:
* standard code golf rules apply
* you must take a single parameter 'n' in whatever way your language allows and return a list/array of all unique scores below the maximum score which cannot be scored with n darts. You may also print these values to the console.
* order of results is unimportant
* shortest code in bytes wins
  
[Answer]
# [Python 3](https://docs.python.org/3/), ~~80~~ ~~79~~ ~~59~~ 57 bytes
-1 byte thanks to Arnauld  
-20 bytes thanks to ArBo  
-2 bytes thanks to negative seven
```
lambda x:[-i-~x*60for i in(x<2)*b'a[YUSOLI'+b'MJGDCA@>=']
```
[Try it online!](https://tio.run/##K6gsycjPM/6fZhvzPycxNyklUaHCKlo3U7euQsvMIC2/SCFTITNPo8LGSFMrST0xOjI02N/HU107Sd3Xy93F2dHBzlY99n9BUWZeiUaahqGmJheMbYTENkZim2hq/gcA "Python 3 – Try It Online")
[Answer]
# [Perl 6](https://github.com/nxadm/rakudo-pkg), 42 bytes
```
{^60*$_∖[X+] [[|(^21 X*^4),25,50]xx$_,]}
```
[Try it online!](https://tio.run/##K0gtyjH7n1upoJamYPu/Os7MQEsl/lHHtOgI7ViF6OgajTgjQ4UIrTgTTR0jUx1Tg9iKCpV4ndja/2n5RQpxJgrVXAoKxYmVCkoq8Qq2dgpKOnpqaVy1/wE "Perl 6 – Try It Online")
Brute force solution that works out all possible dart values.
[Answer]
# JavaScript (ES6), ~~55~~ 54 bytes
*Saved 1 byte thanks to @Shaggy*
Based on the pattern used by [Rod](https://codegolf.stackexchange.com/a/187110/58563).
```
n=>[...1121213+[n-1?33:2121242426]].map(x=>n-=x,n*=60)
```
[Try it online!](https://tio.run/##FYlBDoIwEAC/sre2lm4sVQ7o4kMIhwbBQHCXgDH8vtbMYTKZOX7j3m/T@nEszyGNlJiaFhG9LzPBtuz8I4T6X@UlU3UdvuOqD2rY0VHwiaqzSaNsmoHA34DhDtcsaw30wrssAy7yytuCqkFljZoNzjKxVgUoY9IP "JavaScript (Node.js) – Try It Online")
[Answer]
# [Perl 6](https://github.com/nxadm/rakudo-pkg), 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!](https://tio.run/##K0gtyjH7n1upoJamYKvwvzrOzEBLJf5Rx7ToCO1YBY0ajTgjQ4UIrTgTTR0jUx1TA82KCpX42v/WXFzKxYkgXRqGmtYKygpJpekKmXkKRYnZpSn5ConFCvlpCkYGhpa6Bma6hpZcULVGmtYwpjGQqawA5ZiAzSjPL8ou1gEaVaJQkpidWqxQkp@vkJOfl66Qll@kEOLp/x8A "Perl 6 – Try It Online")
Here's an explanation of it:
```
{                                   } anonymous block for the 
       ∖                                set difference of
 ^60*$_                                   - 0 .. max score (60 * throwcount)
        [X+]                    xx$_      - 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](https://github.com/rakudo/rakudo/issues/2025) and will likely work in future versions. [JoKing's version](https://codegolf.stackexchange.com/a/187125/30284) is a teeny bit longer, but works for `$n == 1` in current Rakudo. 
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 19 bytes
```
20Ż;25×Ɱ3ẎṖœċ⁸§ṪṖḟƊ
```
[Try it online!](https://tio.run/##ATIAzf9qZWxsef//MjDFuzsyNcOX4rGuM@G6juG5lsWTxIvigbjCp@G5quG5luG4n8aK////Mw "Jelly – Try It Online")
[Answer]
# [MATL](https://github.com/lmendo/MATL), ~~25~~ 23 bytes
*Thanks to [@Giuseppe](https://codegolf.stackexchange.com/users/67312/giuseppe), who fixed a mistake and golfed 2 bytes!*
```
25tE3:!21:q*vZ^!stP:wX-
```
[Try it online!](https://tio.run/##y00syfn/38i0xNXYStHI0KpQqywqTrG4JMCqPEIXKAEA)
### Explanation
Brute force approach.
```
25      % Push 25
tE      % Duplicate, double: gives 50
3:!     % Push column vector [1;2;3]
21:q    % Push row vector [0 1 ... 20]
*       % Multiply with broadcast. Gives a matrix with all products
v       % Concatenate everything into a column vector
Z^      % Implicit input: n. Cartesian power with exponent n
!s      % Sum of each row
tP      % Duplicate, flip: The first entry is now 60*n
:       % Push row vector [1 2 ... 60*n]
w       % Swap
X-      % Set difference. Implicit display
```
[Answer]
# [J](http://jsoftware.com/), ~~48~~ 45 bytes
```
2&>(35 44,q:626b66jh)&,60&*-1 4 8 14,q:@13090
```
[Try it online!](https://tio.run/##y/qvpKeepmBrpaCuoKNgoGAFxLp6Cs5BPm7/jdTsNIxNFUxMdAqtzIzMkszMsjI01XTMDNS0dA0VTBQsFAxBUg6GxgaWBv81uVKTM/IV9K3qFNIUDJE5RsgcY67/AA "J – Try It Online")
*-3 bytes thanks to FrownyFrog*
Attempted a brute force solution, but was not able to beat this translation of Rod's idea.
[Answer]
# [R](https://www.r-project.org/), 64 bytes
```
function(n,`!`=utf8ToInt)c(60*n-!"
",(!"
#%),/")[n<2])
```
[Try it online!](https://tio.run/##K/qfpmCjq/A/rTQvuSQzP08jTydBMcG2tCTNIiTfM69EM1nDzEArT1dRSZCPm4OdlYWJUUlHQ1FJXFZeWVVTR19JMzrPxihW83@ahqEmV5qGEYgw1vwPAA "R – Try It Online")
Ports the [amazing answer found by Rod](https://codegolf.stackexchange.com/a/187110/67312).
# [R](https://www.r-project.org/), ~~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!](https://tio.run/##Fco9DoAgDEDh3VO4mLSmJvwEB@NpRJowUAzg@RGXN3x5pfN8bp1f8S1mAcEa2h2ZQR2wq1WQfE6XQAkP@IFGLXnRhyXjyCmkMQjVNyF2Bo0Tg/ljsX8 "R – Try It Online")
Brute force generates all possible scores with `n` darts, then takes the appropriate set difference.
Credit to [OrangeCherries' Octave solution](https://codegolf.stackexchange.com/a/187112/67312) for reminding me of `combn`.
5 more bytes thanks to [Robin Ryder](https://codegolf.stackexchange.com/users/86301/robin-ryder)'s suggestion of using `%o%`.
[Answer]
# [Octave](https://www.gnu.org/software/octave/), ~~91 bytes~~ ~~73 bytes~~ 71 Bytes
Another brute force method. 
```
@(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!](https://tio.run/##FcNBCoAgEADAr3jcjUU2ow6B0D@ig5VChBZp4e@tYOZYknlscUILKWUZIGC0ad2cA@47rgLF28Ny@DnscNnTmwRj1twrplypb0OqpZYnqingTyEWBw2WFw "Octave – Try It Online")
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), 22 bytes
```
-S*60Q+M^+yB25*M*U4U21
```
[Try it online!](https://tio.run/##K6gsyfj/XzdYy8wgUNs3TrvSychUy1cr1CTUyPD/f2MA "Pyth – Try It Online")
Times out in TIO for inputs greater than 3.
```
-S*60Q+M^+yB25*M*U4U21Q   Implicit: Q=eval(input())
                          Trailing Q inferred
                 U4       Range [0-3]
                   U21    Range [0-20]
                *         Cartesian product of the two previous results
              *M          Product of each
          yB25            [25, 50]
         +                Concatenate
        ^             Q   Cartesian product of the above with itself Q times
      +M                  Sum each
                            The result is all the possible results from Q darts, with repeats
  *60Q                    60 * Q
 S                        Range from 1 to the above, inclusive
-                         Setwise difference between the above and the possible results list
                          Implicit print
```
[Answer]
# [Stax](https://github.com/tomtheisen/stax), 24 [bytes](https://github.com/tomtheisen/stax/blob/master/docs/packed.md#packed-stax)
```
¿ß☺o↕αg╠╩╬ò▼í¬«¥↕▄í■♣▓î►
```
[Run and debug it](https://staxlang.xyz/#p=a8e1016f12e067cccace951fa1aaae9d12dca1fe05b28c10&i=1%0A3&a=1&m=2)
It's pretty slow for n=3, and gets worse from there.
[Answer]
# [Python 2](https://docs.python.org/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!](https://tio.run/##PYxBDoIwEEX3nGKWLRkTqOKChJMgiyqtltBOMwwLT18lJu5@Xt77@S0vSqb44VZWG@@zhdRvThTb9HTq2tRJ69MBos1q2yNmpnl/yLHV@LMaNG294KI9MSwQErRo8DzhaDrsmkkju@ysDN8vXXmmCEEcC9G6QYiZWOpytOHf4qWvIHNIAl4FXT4 "Python 2 – Try It Online")
---
# [Python 3](https://docs.python.org/3/), ~~126~~ ~~125~~ 122 bytes
```
lambda n:{*range(60*n)}-{*map(sum,product(sum([[i,i*2,i*3]for i in range(21)],[25,50]),repeat=n))} 
from itertools import*
```
[Try it online!](https://tio.run/##PYzLCoMwEADvfsUek7AFjbUHwS@xHtKatAvmwRoPRfz2tKXQw8BcZtIrP2NoixuuZTH@NhsI/a7YhIcVl1oFeZx25U0S6@YxcZy3e/66GEdCUvpDO7nIQEABfp1u5ISj7rCrJ4lskzV5CFIeUDmOHihbzjEuK5BPkbMq/0GDGls89xUkppCFEyRleQM "Python 3 – Try It Online")
-3 bytes, thanks to Rod
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), ~~21~~ ~~20~~ 18 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
20Ý25ª3Lδ*˜¨ãOZÝsK
```
-3 bytes thanks to *@Grimy*.
Times out pretty quickly the higher the input goes due to the cartesian product builtin `ã`.
[Try it online](https://tio.run/##yy9OTMpM/f/fyODwXCPTQ6uMfc5t0To959CKw4v9ow7PLfYGSgEA) or [verify a few more test cases](https://tio.run/##ATEAzv9vc2FiaWX/M0VOPyIg4oaSICI//zIww50yNcKqM0zOtCrLnMKoTsOjT1rDnXNL/yz/).
**Explanation:**
```
20Ý                 # Push a list in the range [0, 20]
   25ª              # Append 25 to this list
      3L            # Push a list [1,2,3]
        δ*          # Multiply the top two lists double-vectorized:
                    #  [[0,0,0],[1,2,3],[2,4,6],[3,6,9],...,[20,40,60],[25,50,75]]
          ˜         # Flatten this list: [0,0,0,1,2,...,40,60,25,50,75]
           ¨        # Remove the last value (the 75)
            ã       # Create all possible combinations of the (implicit) input size,
                    # by using the cartesian power
             O      # Sum each inner list of input amount of values together
              Z     # Get the maximum (without popping the list), which is 60*input
               Ý    # Create a list in the range [0, 60*input]
                s   # Swap so the initially created list is at the top of the stack again
                 K  # And remove them all from the [0, 60*input] ranged list
                    # (then output the result implicitly)
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 28 bytes
```
21Ḷ×þ3R¤;25;50FœċµS€³×60¤R¤ḟ
```
[Try it online!](https://tio.run/##ATcAyP9qZWxsef//MjHhuLbDl8O@M1LCpDsyNTs1MEbFk8SLwrVT4oKswrPDlzYwwqRSwqThuJ////8z "Jelly – Try It Online")
[Answer]
# [MathGolf](https://github.com/maxbergmark/mathgolf), 26 bytes
```
╟*rJrN▐3╒*mÅ~*╡ak.ε*mÉa─Σ-
```
[Try it online!](https://tio.run/##y00syUjPz0n7///R1PlaRV5Ffo@mTTB@NHWSVu7h1jqtR1MXJmbrndsK5HUmPprScG6x7v//hlxGXMb/AQ "MathGolf – Try It Online")
-2 bytes thanks to Kevin Cruijssen
## Explanation
```
╟*r                          push [0, ..., 60*input-1]
   Jr                        push [0, ..., 20]
     N▐                      append 25 to the end of the list
       3╒                    push [1, 2, 3]
         *                   cartesian product
          mÅ                 explicit map
            ~                evaluate string, dump array, negate integer
             *               pop a, b : push(a*b)
              ╡              discard from right of string/array
               a             wrap in array
                k            push input to TOS
                 .           pop a, b : push(b*a) (repeats inner array input times)
                  ε*          reduce list with multiplication (cartesian power)
                    mÉ       explicit map with 3 operators
                      a      wrap in array (needed to handle n=1)
                       ─     flatten array
                        Σ    sum(list), digit sum(int)
                         -   remove possible scores from [0, 60*input-1]
```
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), 69 bytes
```
Complement[Range[60#],Tr/@{Array[1##&,{4,21},0,##&],25,50}~Tuples~#]&
```
[Try it online!](https://tio.run/##y00syUjNTSzJTE78n2b73zk/tyAnNTc1ryQ6KDEvPTXazEA5ViekSN@h2rGoKLEy2lBZWU2n2kTHyLBWx0AHyInVMTLVMTWorQspBeosrlOOVfsfUJSZV@KQFm0c@x8A "Wolfram Language (Mathematica) – Try It Online")
Based off of [lirtosiast's answer](https://codegolf.stackexchange.com/a/187137/81203).
`Array`'s third argument specifies the offset (default 1), and its fourth argument specifies the head to use instead of `List`. `##&` is equivalent to [`Sequence`](https://reference.wolfram.com/language/ref/Sequence), so `Array[1##&,{4,21},0,##&]` returns a (flattened) `Sequence` containing members of the outer product of `0..3` and `0..20`.
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 36 bytes
```
Ｉ⁺Ｅ…wvtsqpmjgkhea_[YS⎇⊖θ⁹¦¹⁷℅ι×⁶⁰⁻θ²
```
[Try it online!](https://tio.run/##FY09C8IwFAD/Suj0AhGsg@Ic12LBLuIgj/RhokmaLyv99bG96W46pTGpCW2tfTK@gMRcoLffDB0GkIuyJPUUoPnNJcfg3q@PJnw@7rdGsIGSx7TAhVQiR77QCJELdhasPfFVrmk0Hi2YLQbjKMNxL1hn/DqIgh34Rq1t3c32Dw "Charcoal – 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.
[Answer]
# [C# (Visual C# Interactive Compiler)](http://www.mono-project.com/docs/about-mono/releases/5.0.0/#csc), 305 bytes
```
(a,b)=>(int)Math.Pow(a,b);f=n=>{var l=new List<int>(new int[21].SelectMany((_,x)=>new[]{x,x*2,x*3})){25,50};int a=l.Count,b,c,d,e=P(a,n),f;var r=new int[e];for(b=e;b>0;b--)for(c=0;c<n;c++){d=b;while(d>P(a,c+1))d-=P(a,c+1);f=(d/P(a,c))-1;r[b-1]+=l[f>0?f:0];}return Enumerable.Range(0,l.Max()*n).Except(r);}
```
Well, there doesn't seem to be an easy way of calculating all the possible combinations in C#, so this disaster of a code is all I could come up with.
Plus it takes about 30s to complete...
Would love to see a better solution. 
```
P=(a,b)=>(int)Math.Pow(a,b);
F=n=>
{
    var l=new List<int>(new int[21].SelectMany((_,x)=>new[]{x,x*2,x*3})){25,50};
    int a=l.Count,b,c,d,e=P(a,n),f;
    var r=new int[e];
    for(b=e;b>0;b--)
        for(c=0;c<n;c++)
        {
            d=b;
            while(d>P(a,c+1))
                d-=P(a,c+1);
            f=(d/P(a,c))-1;
            r[b-1]+=l[f>0?f:0];
        }
    return Enumerable.Range(0,l.Max()*n).Except(r);
}
```
[Try it online!](https://tio.run/##RVBBasMwELznFSInbSy7dkIvVaQeSgotCYT20EMwRZLlRODKRZYbF@O3u3Jo2sPAzC47s7uqiVVjxsfWqrWxnjxtbPuhnZCVnjTnqKSzv@4vONojNmJBJDCOQwF2wp@SfX2@1GjJLOP9l3CoYlaf0dY0/uKGJxXIYZnlyauutPI7Yb8xfiddsArdQ953pFssA1YDQL@8JbfpQMMMEqxKHuo2rCCJIgXRbB/iLJCSTlGOXc11TsvaYck0lTylMo5h0oqlVK0tVVEEfcEkPZ9MpXHBJxsVZQBFzK483ICLm4sCiDPqDjLO8ohVh5Kn9@VdmtPBad86i/4/lrwIe9Q4JVWyEx2GhYVk0yn96bEDOox09uaM11tjNW68M/aYPNfG4jmZE1TiFQDQ8Qc "C# (Visual C# Interactive Compiler) – Try It Online")
[Answer]
# [Kotlin](https://kotlinlang.org), 118 bytes
```
{n:Int->val i=if(n<2)listOf(23,24,31,25,37,41,44,47)
else
List(0){0}
i+List(9){n*60-listOf(17,14,11,8,7,5,4,2,1)[it]}}
```
[Try it online!](https://tio.run/##fVbRbts4EHz3V2z6UvlOlS3HiRMjCdDrtUCAHlr0ChRF0QdaomwiEqmSVB0j8LfnZknJTq5Ag0CWqeVydmZ25Tvja6UfJxO61W3n3ZK08Rul1@QN2U5TKSvR1Z4K4aQjY0cIFZqU9nItLa2k30qpKcdiSbNpNuKAN1YKL0uqjCVkc1SYUtLa1BUVG1HXUq/lkgM33rduOZnwc36cOS@KO3mPKIRkhWkmPyb5xSKfnnH4bdMa59SqllQK6x25wljpwpm3tBVY6GxrlcPZwI9SqFLAFTAIdyfLAL8GvHKXYtl06w0@pJXEEbRm4PSjk84roznY6P6oYiOLOxMo@jssNFLi@qZHHjB8NZ09VsgpgaIQddHV4IO2G1VsBswMBMcyxkNRW@U39FK/7I9cydpsGR4HN@JeNV0TtwdmD4EZvc3WWVjT16cpR2PTYcchfdwKVPnFlJyhnek4dmu6uiQrfWc1fcvPT1PKz8/5conLYsYXXluchdT5gp8tLvhy@T3U/Q4nC1pxPSuj4RPb8XFd0wi7W4aQj89AuABWkIPTejGZjRjKf1NKGuXcePiev5pNU5qdpXQ2HdZK03FC9phVLd9VIS4k@QQE7pgPvtI4pXziRMYIzdu23g1RIISaznny4k4e4bXCikZ6GSlXwRfbDRT9iaWt2PE@SzUs2wnIDvnN1oWGiKQGralWzk@EtYgHUARRpxWsNjDyG7WjcQqh2S2rfkcZ7RKy9zb4yviRX9RQF32gPedzkn6KGp6GGwdvFEY7U8tsqNzYErUAF5Cg3R27BPDQbxbM@QONG3xHc0QalabVDl8BRMcmfNfpgjsnQpP3LUgA0Fo0q1LETVjhSLR2IzVAjypMmdaaQjqX6CXmkB8v6T3IusLtDT2MRkTY8IUzGl2DPd07JjYuu65hlmKRMdpDHiaMdBAJnKGz0cIl@34ttbTckCIGszJcO/I1KcjGPHt@ECZLjHStLFSlZJnRBz59i1GTPsmnSTat3x3TZrgFLlClvMLn9SjwSKqiRNMVzcb9AoXwD1UyQ6vN5imd5tHvp4uU5rifY22@GMJl7eRhJ5OVTMf0gLbZ93R9iu3MWg9nhzLbunNhtS86RmtjGzhyB80DT4IbS3fNSlrY6oukzv3ClqkqxxOwsqZ5Nm@CDr0MT8cfxq2TB2Ve@ieqME39AOrR/hmKuuSi9B/n01c9OznYyOdpX3oOXjCHsAaiwA@PqvE35b@Dhj2f3/sqePMfAb9Wg0GBrK3RKvH1NIzs6MYGkYmwa4z619yvV/9iwOj1zfhgxvfR0PH9Jp/uj3K3QWgelvlF7JHHB72En1/dBDdcqyrRV7PxUXNIDsUhOPSG3FCbxQ4y9/I@TPcjNdDy8D9SwAnIuEgX6Vk6T2dppGG/fwwoPtsdM13ye/03L@8IuRCd6wPxIpZtoAv/GMdor4w@9pwe@6wRete/skrlmNawHxMOrwAXYobUv8ruge0h6MnMaLoOSN8rLZPxyUnmDVhLou1j05xAxjzLZtOhF/zGYnDeQoG1qF/bdceD5e0APTm0CdGLv0SJ6vFD5@RF3B2GZK2TNtHjcS/uhyeFpzyoUBHOZI56P4UpHWKf/Tzicva49RjWibTW2CV9ZnDcTuO@yuHEIxaKfPep3ACNzZWwWFztfCj2OWBeCUZHcHQ8e/fxPw "Kotlin – Try It Online")
[Answer]
# [Perl 5](https://www.perl.org/) `-n`, ~~96~~ ~~93~~ 91 bytes
```
$"=',';@b=map{$_,$_*2,$_*3,25,50}0..20;map$r[eval]=1,glob"+{@b}"x$_;map$r[$_]||say,0..$_*60
```
[Try it online!](https://tio.run/##K0gtyjH9/19FyVZdR93aIck2N7GgWiVeRyVeywhEGOsYmeqYGtQa6OkZGVgDJVWKolPLEnNibQ110nPyk5S0qx2SapUqVOKhkirxsTU1xYmVOkAdQP1mBv//G//LLyjJzM8r/q/ra6pnYGjwXzcPAA "Perl 5 – 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.
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), 81 bytes
```
Complement[Range[60#-1],Total/@Tuples[Flatten[{Array[Times,{3,20}],0,25,50}],#]]&
```
[Try it online!](https://tio.run/##y00syUjNTSzJTE78n2b73zk/tyAnNTc1ryQ6KDEvPTXazEBZ1zBWJyS/JDFH3yGkFChbHO2Wk1hSkpoXXe1YVJRYGR2SmZtarFNtrGNkUBurY6BjZKpjCmIpx8aq/Q8oyswrcUiLNo79DwA "Wolfram Language (Mathematica) – Try It Online")
Mathematica has a few related builtins including `FrobeniusSolve` and the restricted form of `IntegerPartitions`, but none of them are shorter than brute force.
]