Daha önce sorduğumda bulamadığım için şaşırdım, ama dart ödemeleriyle ilgili harika bir soru var: Dart Codegolf ile tanışıyor

Buradaki zorluk, hangi puanların 'n' dart 'n' dart ile belirlenemeyeceğini hesaplamaktır. Örneğin, n = 3 için, mümkün olan maksimum puan 180'dir, bu nedenle geri dönersiniz [163,166,169,172,173,175,176,178,179]

Çıplak kemik kuralı özeti için:

Tek bir dart için olası puanlar şunlardır:

• 0 (bayan)
• 1-20, 25, 50
• 1-20 çift veya üçlü

Kurallar:

• standart kod golf kuralları geçerlidir
• Diliniz ne şekilde olursa olsun tek bir 'n' parametresi almalı ve n dart ile alınamayan maksimum puanın altındaki tüm benzersiz puanların bir listesini / dizisini vermelisiniz. Bu değerleri konsola da yazdırabilirsiniz.
• sonuç sırası önemsiz
• bayt cinsinden en kısa kod kazanır

Python 3 , 80 79 59 57 bayt

^{Arnauld
-20 bayt sayesinde -1 bayt ArBo
sayesinde -2 bayt Negatif yedi sayesinde -2 bayt}

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

Çevrimiçi deneyin!

Perl 6 , 42 bayt

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

Çevrimiçi deneyin!

Tüm olası dart değerlerini belirleyen kaba kuvvet çözümü.

JavaScript (ES6),  55  54 bayt

@Shaggy sayesinde 1 bayt kaydedildi

Rod tarafından kullanılan desene göre .

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

Çevrimiçi deneyin!

Perl 6 , 39 bayt (37 karakter)

Bu kesinlikle büyük bir balyoz kullanıyor, ama işe yarıyor. (Sadece kaba kuvvet değil, acımasızca kaba kuvvet verir)

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

Çevrimiçi deneyin!

İşte bunun bir açıklaması:

{                                   } 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Çapraz çarpan yinelenen değerlerin bir sürü oluşturur (orada 20+ katılan sıfırlar ve bu en olacak önce çapraz ek yapabilme), ama biz seti farkını kullanmak beri herhangi bir sorun nedeni değil ∖benzersiz değerler ile çalışır.

Bu şu anda başarısız oluyor $n == 1(boş bir küme döndürmesi gerekiyor), ancak dosyalanan bir sorun var ve gelecekteki sürümlerde büyük olasılıkla çalışacak. JoKing'in versiyonu ufacık bir parça daha uzun, ancak $n == 1şu anki Rakudo'da çalışıyor.

Jöle , 19 bayt

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

Çevrimiçi deneyin!

MATL , 25 23 bayt

Sayesinde @Giuseppe bir hata sabit ve 2 bayt golfed!

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

Çevrimiçi deneyin!

açıklama

Kaba kuvvet yaklaşımı.

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 bayt

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

Çevrimiçi deneyin!

FrownyFrog sayesinde -3 bayt

Kaba bir güç çözümü denedi, ancak Rod'un fikrinin bu çevirisini yenemedi.

R , 64 bayt

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

Çevrimiçi deneyin!

Rod tarafından bulunan şaşırtıcı cevabı barındırır .

R , 85 73 68 bayt

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

Çevrimiçi deneyin!

Kaba kuvvet, tüm olası puanları ndart ile oluşturur , ardından uygun ayar farkını alır.

Kredi OrangeCherries' Octave çözümü bana hatırlatan için combn.

Robin Ryder'ın kullanım önerisi sayesinde 5 bayt daha %o%.

Octave , 91 bayt 73 bayt 71 Bayt

Başka bir kaba kuvvet yöntemi.

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

Aşağı için 73 bayt Giuseppe sayesinde
combnk ile nchoosek değiştirerek 71 Bayt Down

Çevrimiçi deneyin!

Pyth , 22 bayt

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

Çevrimiçi deneyin!

3'ten büyük girişler için TIO'da zaman aşımına uğradı.

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

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

Koş ve hata ayıkla

N = 3 için oldukça yavaş ve oradan daha da kötüleşiyor.

Python 2,121 bayt

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*

Çevrimiçi deneyin!

Python 3 , 126 125 122 bayt

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*

Çevrimiçi deneyin!

_{Rod sayesinde -3 bayt}

05AB1E , 21 20 18 bayt

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

@Grimy sayesinde -3 bayt .

Zaman aşımına uğrarsa, girilen kartezyen ürün nedeniyle girdiler artar ã.

Çevrimiçi deneyin ya da birkaç test vakası daha doğrulayın .

Açıklama:

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)

Jöle , 28 bayt

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

Çevrimiçi deneyin!

MathGolf , 26 bayt

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

Çevrimiçi deneyin!

Kevin Cruijssen sayesinde -2 bayt

açıklama

╟*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 Dili (Mathematica) , 69 bayt

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

Çevrimiçi deneyin!

Lirtosiast'in cevabına dayanarak .

Array'nin üçüncü argümanı ofseti (varsayılan 1), dördüncü argümanı ise yerine kullanılacak başlığı belirtir List. ##&eşdeğerdir Sequence, yani Array[1##&,{4,21},0,##&]bir (düzleştirilmiş) döndürür Sequencedış ürününün üye ihtiva eden 0..3ve 0..20.

Kömür , 36 bayt

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

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı bir versiyonudur. @ Rod'un algoritmasını kullanır; kaba kuvvet 60 bayt alırdı. Girdi 1'den büyükse, dizeyi 9 karaktere bölerek çalışır, sonra karakterlerin sıralamasını alır ve 60'ın uygun katını ekler.

C # (Visual C # Etkileşimli Derleyici) , 305 bayt

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

Pekala, C # 'da olası tüm kombinasyonları hesaplamanın kolay bir yolu yok gibi görünüyor, bu yüzden bir kodun bu felaketi bulabildiğim kadarıyla.

Ayrıca tamamlanması yaklaşık 30s sürüyor ...

Daha iyi bir çözüm görmeyi çok isterim.

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

Çevrimiçi deneyin!

Kotlin , 118 bayt

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

Çevrimiçi deneyin!

Perl 5 -n , 96 93 91 bayt

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

Çevrimiçi deneyin!

Çalışma süresi yerine kod uzunluğu için optimize edilmiş, bu yüzden yavaş. Arama karması için çok fazla gereksiz giriş oluşturur. @bDiziyi çalıştırmak uniqçok hızlandırır, ancak 5 bayta mal olur, bu yüzden yapmadım.

Wolfram Dili (Mathematica) , 81 bayt

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

Çevrimiçi deneyin!

Mathematica'da bunlarla FrobeniusSolvesınırlı ve sınırlı bir şekli var IntegerPartitions. Bunların hiçbiri kaba kuvvetten daha kısa değil.