Tôi đã rất ngạc nhiên khi không tìm thấy câu hỏi này, mặc dù có một câu hỏi rất hay về kiểm tra phi tiêu: Phi tiêu gặp Codegolf

Thử thách của bạn là tính toán điểm số nào là không thể với phi tiêu 'n' dưới điểm tối đa cho phi tiêu 'n'. Ví dụ: với n = 3, số điểm tối đa có thể là 180, do đó bạn sẽ trả về [163,166,169,172,173,175,176,178,179]

Đối với một bản tóm tắt quy tắc xương trần:

Điểm có thể cho một phi tiêu duy nhất là:

• 0 (bỏ lỡ)
• 1-20, 25, 50
• gấp đôi hoặc gấp ba từ 1-20

Quy tắc:

• quy tắc golf tiêu chuẩn áp dụng
• bạn phải lấy một tham số 'n' bằng bất cứ cách nào ngôn ngữ của bạn cho phép và trả về một danh sách / mảng của tất cả các điểm số duy nhất dưới điểm tối đa không thể ghi được bằng n phi tiêu. Bạn cũng có thể in các giá trị này lên bàn điều khiển.
• thứ tự kết quả là không quan trọng
• mã ngắn nhất tính bằng byte

Python 3 , 80 79 59 57 byte

^{-1 byte nhờ Arnauld
-20 byte nhờ ArBo
-2 byte nhờ bảy âm}

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

Hãy thử trực tuyến!

Perl 6 , 42 byte

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

Hãy thử trực tuyến!

Giải pháp lực mạnh mà làm việc ra tất cả các giá trị phi tiêu có thể.

JavaScript (ES6),  55  54 byte

Đã lưu 1 byte nhờ @Shaggy

Dựa trên mô hình được sử dụng bởi Rod .

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

Hãy thử trực tuyến!

Perl 6 , 39 byte (37 ký tự)

Điều này chắc chắn là sử dụng búa tạ lớn nhưng nó hoạt động. (Nó không chỉ vũ phu nó, nó tàn bạo cưỡng bức nó)

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

Hãy thử trực tuyến!

Đây là một lời giải thích về nó:

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

Hệ X* ^4số chéo tạo ra rất nhiều giá trị trùng lặp (sẽ có hơn 20 số không tham gia và đó là trước khi thực hiện bổ sung chéo), nhưng điều đó không gây ra bất kỳ vấn đề nào vì chúng tôi sử dụng sự khác biệt được thiết lập ∖với các giá trị duy nhất.

Điều này hiện không thành công $n == 1(sẽ trả về một tập hợp trống), nhưng có một vấn đề được đệ trình và có khả năng sẽ hoạt động trong các phiên bản trong tương lai. Phiên bản của JoKing dài hơn một chút, nhưng hoạt động $n == 1trong Rakudo hiện tại.

Thạch , 19 byte

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

Hãy thử trực tuyến!

MATL , 25 23 byte

Cảm ơn @Giuseppe , người đã sửa lỗi và đánh gôn 2 byte!

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

Hãy thử trực tuyến!

Giải trình

Phương pháp vũ phu.

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 byte

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

Hãy thử trực tuyến!

-3 byte nhờ FrownyFrog

Đã thử một giải pháp vũ phu, nhưng không thể đánh bại bản dịch ý tưởng này của Rod.

R , 64 byte

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

Hãy thử trực tuyến!

Cổng câu trả lời tuyệt vời được tìm thấy bởi Rod .

R , 85 73 68 byte

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

Hãy thử trực tuyến!

Brute force tạo ra tất cả các điểm có thể bằng nphi tiêu, sau đó lấy chênh lệch thiết lập phù hợp.

Tín dụng cho giải pháp Octave của OrangeCherries để nhắc nhở tôi combn.

5 nhiều byte nhờ Robin Ryder đề nghị sử dụng 's %o%.

Octave , 91 byte 73 byte 71 byte

Một phương pháp vũ phu khác.

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

Giảm xuống 73 Byte nhờ Giuseppe
Giảm xuống 71 Byte bằng cách thay thế nchoosek bằng combnk

Hãy thử trực tuyến!

Bình thường , 22 byte

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

Hãy thử trực tuyến!

Lần ra trong TIO cho đầu vào lớn hơn 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 byte

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

Chạy và gỡ lỗi nó

Nó khá chậm với n = 3 và trở nên tồi tệ hơn từ đó.

Python 2 , 125 byte

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*

Hãy thử trực tuyến!

Python 3 , 126 125 122 byte

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*

Hãy thử trực tuyến!

_{-3 byte, nhờ có Rod}

05AB1E , 21 20 18 byte

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

-3 byte nhờ @Grimy .

Thời gian ra khá nhanh, đầu vào càng cao do tích hợp sản phẩm cartesian ã.

Hãy thử trực tuyến hoặc xác minh một vài trường hợp thử nghiệm .

Giải trình:

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)

Thạch , 28 byte

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

Hãy thử trực tuyến!

MathGolf , 26 byte

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

Hãy thử trực tuyến!

-2 byte nhờ Kevin Cruijssen

Giải trình

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

Ngôn ngữ Wolfram (Mathicala) , 69 byte

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

Hãy thử trực tuyến!

Dựa trên câu trả lời của lirtosiast .

ArrayĐối số thứ ba chỉ định phần bù (mặc định 1) và đối số thứ tư của nó chỉ định phần đầu sẽ sử dụng thay vì List. ##&tương đương với Sequence, do đó Array[1##&,{4,21},0,##&]trả về một (làm phẳng) Sequencecó chứa các thành viên của sản phẩm bên ngoài 0..3và 0..20.

Than , 36 byte

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Sử dụng thuật toán của @ Rod; lực lượng vũ phu sẽ mất 60 byte. Hoạt động bằng cách cắt ngắn chuỗi thành 9 ký tự nếu đầu vào lớn hơn 1, sau đó lấy thứ tự của các ký tự và thêm bội số thích hợp của 60.

C # (Trình biên dịch tương tác Visual C #) , 305 byte

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

Chà, dường như không có cách nào dễ dàng để tính toán tất cả các kết hợp có thể có trong C #, vì vậy thảm họa mã này là tất cả những gì tôi có thể nghĩ ra.

Thêm vào đó, mất khoảng 30 giây để hoàn thành ...

Rất thích nhìn thấy một giải pháp tốt hơn.

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

Hãy thử trực tuyến!

Kotlin , 118 byte

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

Hãy thử trực tuyến!

Perl 5 -n , 96 93 91 byte

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

Hãy thử trực tuyến!

Nó được tối ưu hóa cho độ dài mã thay vì thời gian chạy, vì vậy nó khá chậm. Nó tạo ra rất nhiều mục dư thừa cho hàm băm tra cứu của nó. Chạy @bmảng thông qua tăng uniqtốc đáng kể, nhưng tốn thêm 5 byte, vì vậy tôi đã không làm điều đó.

Ngôn ngữ Wolfram (Mathicala) , 81 byte

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

Hãy thử trực tuyến!

Mathematica có một vài nội dung liên quan bao gồm FrobeniusSolvevà hình thức hạn chế IntegerPartitions, nhưng không có phần nào trong số chúng ngắn hơn lực lượng vũ phu.