다트 체크 아웃에 대한 큰 질문이 있지만이 질문을 이미 찾지 못한 것에 놀랐습니다. 다트가 Codegolf를 만났습니다.

당신의 도전은 'n'다트에 대한 최대 점수 아래의 'n'다트로 불가능한 점수를 계산하는 것입니다. 예를 들어 n = 3 인 경우 가능한 최대 점수는 180이므로 [163,166,169,172,173,175,176,178,179]를 반환합니다.

베어 본 규칙 요약의 경우 :

단일 다트에 가능한 점수는 다음과 같습니다.

• 0 (미스)
• 1-20, 25, 50
• 1-20의 이중 또는 삼중

규칙 :

• 표준 코드 골프 규칙 적용
• 언어가 허용하는 방식에 상관없이 단일 매개 변수 'n'을 가져 와서 n 개의 다트로 점수를 매길 수없는 최대 점수 미만의 모든 고유 점수 목록 / 배열을 반환해야합니다. 이 값을 콘솔에 인쇄 할 수도 있습니다.
• 결과의 순서는 중요하지 않습니다
• 바이트 단위의 최단 코드 승리

파이썬 3 , 80 79 59 57 바이트

^{Arnauld 덕분에 -1 바이트
-ArBo 덕분에 -20 바이트
-음수 7 덕분에 -2 바이트}

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

온라인으로 사용해보십시오!

펄 6 , 42 바이트

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

온라인으로 사용해보십시오!

가능한 모든 다트 값을 해결하는 무차별 대입 솔루션.

자바 스크립트 (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 + 관여 0과 1이의 될 것입니다 전에 십자가 추가하고), 그러나 우리는 차이 집합 사용하기 때문에 그 어떤 문제가 발생하지 않습니다 ∖고유 값으로 작동합니다.

현재 $n == 1(빈 세트를 반환해야 함) 실패 하지만 문제가 제기 되어 향후 버전에서 작동 할 것입니다. JoKing의 버전 은 조금 더 길지만 $n == 1현재 Rakudo에서 작동합니다 .

젤리 , 19 바이트

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

온라인으로 사용해보십시오!

MATL , 25 23 바이트

실수를 수정하고 2 바이트 를 골프 로 한 @Giuseppe 에게 감사 합니다!

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

온라인으로 사용해보십시오!

FrownyFrog 덕분에 -3 바이트

무차별 대입 솔루션을 시도했지만이로드의 아이디어를 이길 수 없었습니다.

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

niusosek를 combnk로 교체 하여 Giuseppe 덕분에 최저 73 바이트

온라인으로 사용해보십시오!

Pyth , 22 바이트

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

온라인으로 사용해보십시오!

3보다 큰 입력의 경우 TIO에서 시간 초과됩니다.

-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의 경우 속도가 느리고 거기에서 더 나빠집니다.

파이썬 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*

온라인으로 사용해보십시오!

파이썬 (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*

온라인으로 사용해보십시오!

_{Rod 덕분에 -3 바이트}

05AB1E , 21 20 18 바이트

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

@Grimy 덕분에 -3 바이트 .

직교 제품 내장으로 인해 입력이 높아질수록 시간이 매우 빨리 초과 ã됩니다.

온라인으로 시도 하거나 몇 가지 테스트 사례를 확인하십시오 .

설명:

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─Σ-

온라인으로 사용해보십시오!

Kevin Cruijssen 덕분에 -2 바이트

설명

╟*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 Language (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..30..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]}}

온라인으로 사용해보십시오!

펄 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 Language (Mathematica) , 81 바이트

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

온라인으로 사용해보십시오!

Mathematica는을 포함하여 몇 가지 관련 내장을 가지고 FrobeniusSolve있으며의 형태는 제한되어 IntegerPartitions있지만 그 중 어느 것도 무차별 대치보다 짧지 않습니다.