Me sorprendió no encontrar esto ya preguntado, aunque hay una gran pregunta sobre los pagos de dardos: Darts y Codegolf

Su desafío es calcular qué puntajes no son posibles con 'n' dardos por debajo del puntaje máximo para 'n' dardos. Por ejemplo, para n = 3, el puntaje máximo posible es 180, por lo que devolvería [163,166,169,172,173,175,176,178,179]

Para un resumen de la regla básica:

Los puntajes posibles para un solo dardo son:

• 0 (señorita)
• 1-20, 25, 50
• doble o triple de 1-20

Reglas:

• se aplican reglas de golf de código estándar
• debe tomar un solo parámetro 'n' de la manera que su idioma lo permita y devolver una lista / conjunto de todos los puntajes únicos por debajo del puntaje máximo que no se puede calificar con n dardos. También puede imprimir estos valores en la consola.
• el orden de los resultados no es importante
• el código más corto en bytes gana

Python 3 , 80 79 59 57 bytes

^{-1 byte gracias a Arnauld
-20 bytes gracias a ArBo
-2 bytes gracias a siete negativos}

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

Pruébalo en línea!

Perl 6 , 42 bytes

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

Pruébalo en línea!

Solución de fuerza bruta que resuelve todos los posibles valores de dardos.

JavaScript (ES6),  55  54 bytes

Guardado 1 byte gracias a @Shaggy

Basado en el patrón utilizado por Rod .

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

Pruébalo en línea!

Perl 6 , 39 bytes (37 caracteres)

Definitivamente está usando un mazo masivo pero funciona. (No solo lo fuerza por fuerza bruta, lo fuerza brutalmente por fuerza bruta)

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

Pruébalo en línea!

Aquí hay una explicació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

El X* ^4multiplicador cruzado genera muchos valores duplicados (habrá más de 20 ceros involucrados y eso es antes de hacer la suma cruzada), pero eso no causa ningún problema ya que usamos la diferencia establecida ∖que funciona con los valores únicos.

Esto falla actualmente $n == 1(lo que debería devolver un conjunto vacío), pero hay un problema archivado y probablemente funcionará en futuras versiones. La versión de JoKing es un poco más larga, pero funciona $n == 1en Rakudo actual.

Jalea , 19 bytes

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

Pruébalo en línea!

MATL , 25 23 bytes

¡Gracias a @Giuseppe , que corrigió un error y jugó 2 bytes!

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

Pruébalo en línea!

Explicación

Enfoque de fuerza bruta.

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 bytes

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

Pruébalo en línea!

-3 bytes gracias a FrownyFrog

Intenté una solución de fuerza bruta, pero no pude superar esta traducción de la idea de Rod.

R , 64 bytes

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

Pruébalo en línea!

Ports la increíble respuesta encontrada por Rod .

R , 85 73 68 bytes

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

Pruébalo en línea!

La fuerza bruta genera todos los puntajes posibles con los ndardos, luego toma la diferencia de conjunto adecuada.

Crédito para la solución de octava OrangeCherries' por recordarme combn.

5 bytes más gracias a la sugerencia de Robin Ryder de usar %o%.

Octava , 91 bytes 73 bytes 71 Bytes

Otro método de fuerza bruta.

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

Bajar a 73 Bytes gracias a Giuseppe
Bajar a 71 Bytes reemplazando nchoosek por combnk

Pruébalo en línea!

Pyth , 22 bytes

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

Pruébalo en línea!

Se agota el tiempo de espera en TIO para entradas mayores de 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 bytes

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

Ejecutar y depurarlo

Es bastante lento para n = 3, y empeora a partir de ahí.

Python 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*

Pruébalo en línea!

Python 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*

Pruébalo en línea!

_{-3 bytes, gracias a Rod}

05AB1E , 21 20 18 bytes

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

-3 bytes gracias a @Grimy .

El tiempo de espera se agota rápidamente cuanto mayor sea la entrada debido al producto cartesiano incorporado ã.

Pruébalo en línea o verifique algunos casos de prueba más .

Explicación:

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)

Jalea , 28 bytes

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

Pruébalo en línea!

MathGolf , 26 bytes

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

Pruébalo en línea!

-2 bytes gracias a Kevin Cruijssen

Explicación

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

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

Pruébalo en línea!

Basado en la respuesta de lirtosiast .

ArrayEl tercer argumento especifica el desplazamiento (por defecto 1), y su cuarto argumento especifica la cabeza a usar en lugar de List.##&es equivalente a Sequence, por lo que Array[1##&,{4,21},0,##&]devuelve un (aplanado) que Sequencecontiene miembros del producto externo de 0..3y 0..20.

Carbón , 36 bytes

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

Pruébalo en línea!El enlace es a la versión detallada del código. Utiliza el algoritmo de @ Rod; la fuerza bruta habría tomado 60 bytes. Funciona truncando la cadena a 9 caracteres si la entrada es mayor que 1, luego toma los ordinales de los caracteres y agrega el múltiplo apropiado de 60.

C # (compilador interactivo de Visual C #) , 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);}

Bueno, no parece haber una manera fácil de calcular todas las combinaciones posibles en C #, por lo que este desastre de código es todo lo que se me ocurrió.

Además, tarda unos 30 segundos en completarse ...

Me encantaría ver una mejor solució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);
}

Pruébalo en línea!

Kotlin , 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]}}

Pruébalo en línea!

Perl 5 -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

Pruébalo en línea!

Fue optimizado para la longitud del código en lugar del tiempo de ejecución, por lo que es un poco lento. Genera muchas entradas redundantes para su hash de búsqueda. Ejecutar la @bmatriz a través de uniqél lo acelera enormemente, pero cuesta 5 bytes más, por lo que no lo hice.

Wolfram Language (Mathematica) , 81 bytes

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

Pruébalo en línea!

Mathematica tiene algunos componentes internos relacionados, incluida FrobeniusSolvela forma restringida IntegerPartitions, pero ninguno de ellos es más corto que la fuerza bruta.