我很惊讶地没有发现这个问题，尽管在飞镖结帐时有一个很大的问题：飞镖遇到Codegolf

您面临的挑战是计算在'n'飞镖的最高得分以下的情况下，'n'飞镖无法获得哪些得分。例如，对于n = 3，最大可能分数是180，所以您将返回[163,166,169,172,173,175,176,178,179]

有关裸露规则的摘要：

单支飞镖的可能得分为：

• 0（未命中）
• 1-20、25、50
• 1-20的两倍或三倍

规则：

• 适用标准代码高尔夫规则
• 您必须以您的语言允许的任何方式使用单个参数'n'，并返回低于最大得分（不能用n飞镖得分）的所有唯一得分的列表/数组。您也可以将这些值打印到控制台。
• 结果顺序不重要
• 以字节为单位的最短代码获胜

Python 3中，80个 79 59 57字节

^{-1个字节感谢Arnauld
-20个字节感谢ArBould
-2个字节感谢负7}

lambda x:[-i-~x*60for i in(x<2)*b'a[YUSOLI'+b'MJGDCA@>=']

在线尝试！

Perl 6，42个字节

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

在线尝试！

蛮力解算出所有可能的飞镖值。

JavaScript（ES6）， 55  54字节

@Shaggy节省了1个字节

基于Rod使用的模式。

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

在线尝试！

Perl 6，39个字节（37个字符）

这肯定是在使用大型大锤，但确实有效。（它不仅是蛮力的，而且是蛮力的）

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

在线尝试！

这是它的解释：

{                                   } 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

该X* ^4交叉乘数产生大量重复值（将有涉及20多个零，这就是前做交叉加成），但由于我们使用了一套差异不会引起任何问题，∖它具有独特的价值观的作品。

目前，此操作失败$n == 1（应该返回一个空集），但是存在一个问题，很可能在以后的版本中起作用。 JoKing的版本稍长一些，但适用$n == 1于当前的Rakudo。

果冻，19字节

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

在线尝试！

MATL，25 23字节

感谢@Giuseppe，他纠正了一个错误，并打了2个字节！

25tE3:!21:q*vZ^!stP:wX-

在线尝试！

说明

蛮力法。

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

J，⁴⁸ 45字节

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

在线尝试！

-3字节归功于FrownyFrog

尝试了蛮力解决方案，但未能击败Rod的想法。

R，64字节

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

在线尝试！

移植了Rod发现的惊人答案。

R，85 73 68字节

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

在线尝试！

蛮力用n飞镖产生所有可能的分数，然后采取适当的设定差。

感谢OrangeCherries'八度的解决方案提醒我的combn。

由于Robin Ryder的建议使用了5个字节%o%。

八度，91字节 73字节 71字节

另一种蛮力方法。

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

下到73个字节由于朱塞佩
用combnk更换nchoosek下降到71个字节

在线尝试！

Pyth，22个字节

-S*60Q+M^+yB25*M*U4U21

在线尝试！

在TIO中超时，输入大于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

Stax，24 个字节

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

运行并调试

对于n = 3来说，它相当慢，并且从那里变得更糟。

Python 2，125个字节

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*

在线尝试！

Python 3中，126个 125 122字节

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*

在线尝试！

_{-3个字节，感谢Rod}

05AB1E，21 20 18 字节

20Ý25ª3Lδ*˜¨ãOZÝsK

-3个字节，感谢@Grimy。

由于内置了笛卡尔积，输入越高，输入超时就越快ã。

在线尝试或验证更多测试用例。

说明：

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)

果冻，28个字节

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

在线尝试！

MathGolf，26个字节

╟*rJrN▐3╒*mÅ~*╡ak.ε*mÉa─Σ-

在线尝试！

-2个字节，感谢Kevin Cruijssen

说明

╟*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]

Wolfram语言（Mathematica），69个字节

Complement[Range[60#],Tr/@{Array[1##&,{4,21},0,##&],25,50}~Tuples~#]&

在线尝试！

根据lirtosiast的回答。

Array的第三个参数指定偏移量（默认为1），其第四个参数指定要使用的头，而不是List。##&相当于Sequence，所以Array[1##&,{4,21},0,##&]返回（扁平）Sequence含有的外积的成员0..3和0..20。

木炭，36字节

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

在线尝试！链接是详细版本的代码。使用@Rod算法；蛮力将占用60个字节。如果输入大于1，则将字符串截断为9个字符，然后采用字符的序数并加上60的适当倍数来工作。

C＃（Visual C＃交互式编译器），305个字节

(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);}

好吧，似乎没有一种简单的方法来计算C＃中所有可能的组合，所以我能想到的就是这种代码灾难。

另外，大约需要30秒钟才能完成...

希望看到更好的解决方案。

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);
}

在线尝试！

科特林，118字节

{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]}}

在线尝试！

Perl 5中 -n，96个 93 91字节

$"=',';@b=map{$_,$_*2,$_*3,25,50}0..20;map$r[eval]=1,glob"+{@b}"x$_;map$r[$_]||say,0..$_*60

在线尝试！

它针对代码长度而不是运行时间进行了优化，因此速度很慢。它为其查找哈希生成大量冗余条目。@b通过运行数组uniq可以大大提高速度，但是要多花5个字节，所以我没有这么做。

Wolfram语言（Mathematica），81个字节

Complement[Range[60#-1],Total/@Tuples[Flatten[{Array[Times,{3,20}],0,25,50}],#]]&

在线尝试！

Mathematica具有一些相关的内建函数，包括FrobeniusSolve和的受限制形式IntegerPartitions，但它们都不比蛮力短。