Escreva o código mais curto possível para resolver o seguinte problema:

Entrada:

Um número inteiro X com 2 <= XeX <= 100

Resultado:

Total de combinações de 2, 3 e 5 (a repetição é permitida, a ordem é importante) cuja soma é igual a X.

Exemplos:

Entrada: 8

Saída:, 6porque as combinações válidas são:

3+5
5+3
2+2+2+2
2+3+3
3+2+3
3+3+2

Entrada: 11

Saída:, 16porque as combinações válidas são

5+3+3
5+2+2+2
3+5+3
3+3+5
3+3+3+2
3+3+2+3
3+2+3+3
3+2+2+2+2
2+5+2+2
2+3+3+3
2+3+2+2+2
2+2+5+2
2+2+3+2+2
2+2+2+5
2+2+2+3+2
2+2+2+2+3

Entrada: 100

Saída:, 1127972743581281porque as combinações válidas são ... muitas

A entrada e a saída podem ter qualquer forma razoável. A contagem de bytes mais baixa em cada idioma vence. Aplicam-se as regras padrão de código de golfe .

Python 2 , 46 45 bytes

graças ao xnor por -1 byte

f=lambda n:n>0and f(n-2)+f(n-3)+f(n-5)or n==0

Experimente online!

Oásis , 9 bytes

cd5e++VT1

Experimente online!

Explicação

        1    # a(0) = 1
       T     # a(1) = 0, a(2) = 1
      V      # a(3) = 1, a(4) = 1

             # a(n) = 
c    +       # a(n-2) +
 d  +        # a(n-3) +
  5e         # a(n-5)

Pitão , 9 bytes

/sM{y*P30

Experimente aqui!

Pitão , 16 bytes

l{s.pMfqT@P30T./

Experimente aqui

Quão?

1. Gera os fatores primos de 30 , ou seja, [2, 3, 5] , obtém o conjunto de repetições N vezes, remove elementos duplicados, soma cada lista e conta as ocorrências de N nela .

2. Para cada parição inteira p , verifica se p é igual a p ∩ primefac (30) . Ele mantém apenas aqueles que atendem a essa condição e, para cada partição remanescente k , obtém a lista de permutações de k , nivela a lista resultante em 1 nível, desduplica-a e recupera o comprimento.

Gelatina , 11 bytes

5ÆRẋHŒPQḅ1ċ

Experimente online!

Como funciona

5ÆRẋHŒPQḅ1ċ -> Programa completo. Argumento: N, um número inteiro.
5ÆR -> Empurra todos os números primos entre 2 e 5, inclusive.
   ẋH -> Repita esta lista N / 2 vezes.
     ŒP -> Gere o conjunto de potência.
       Q -> Remover entradas duplicadas.
        ḅ1 -> Converta cada um dos unários (ou seja, soma cada lista)
          Count -> Conte as ocorrências de N nesta lista.

Perl, 38 bytes

Inclui +1parap

perl -pE '$_=1x$_;/^(...?|.{5})+$(?{$\++})\1/}{' <<< 11; echo

Interessante o suficiente para usar \1para forçar o retorno. Normalmente eu uso, ^mas o otimizador de expressões regulares parece muito inteligente para isso e dá resultados muito baixos. Provavelmente terei que começar a fornecer números de versão perl ao usar esse truque, pois o otimizador pode mudar a cada versão. Isso foi testado emperl 5.26.1

Isso 49é eficiente e pode realmente lidar X=100(mas estourar X=1991)

perl -pe '$\=$F[@F]=$F[-2]+$F[-3]+$F[-5]for($F[5]=1)..$_}{' <<< 100;echo

C, 41 bytes

G(x){return x>0?G(x-2)+G(x-3)+G(x-5):!x;}

Experimente online!

JavaScript (ES6), 32 bytes

O mesmo algoritmo da resposta Python dos ovs .

f=n=>n>0?f(n-2)+f(n-3)+f(n-5):!n

Casos de teste

f=n=>n>0?f(n-2)+f(n-3)+f(n-5):!n

console.log(f(8))
console.log(f(11))
console.log(f(13))

R , 56 49 47 bytes

Abordagem recursiva da resposta do ovs . Giuseppe raspou esses dois bytes finais para fazer 47.

f=pryr::f(+`if`(x<5,x!=1,f(x-2)+f(x-3)+f(x-5)))

Experimente online!

MATL , 15 bytes

:"5Zq@Z^!XsG=vs

Muito ineficiente: a memória necessária é exponencial.

Experimente online!

Como funciona

:"       % For each k in [1 2 ... n], where n is implicit input
  5Zq    %   Push primes up to 5, that is, [2 3 5]
  @      %   Push k
  Z^     %   Cartesian power. Gives a matrix where each row is a Cartesian k-tuple
  !Xs    %   Sum of each row
  G=     %   Compare with input, element-wise
  vs     %   Concatenate all stack contents vertically and sum
         % Implicit end. Implicit display

05AB1E , 10 bytes

30fIиæÙOI¢

Experimente online!

Ruby , 41 bytes

f=->n{n<5?n==1?0:1:[n-5,n-2,n-3].sum(&f)}

Experimente online!

Esta é uma solução recursiva, o ser chamada recurcive: [n-5,n-2,n-3].sum(&f).

Pari / GP , 36 bytes

f(n)=if(n>0,f(n-2)+f(n-3)+f(n-5),!n)

Experimente online!

Mais longo, mas mais eficiente:

Pari / GP , 37 bytes

n->Vec(1/(1-x^2-x^3-x^5)+O(x^n++))[n]

Experimente online!

Gelatina , 21 bytes

Œṗe€2,3,5$Ạ$ÐfŒ!Q$€ẎL

Experimente online!

Certamente pode ser jogado golfe

Pitão, 12 bytes

l{fqQsTy*P30

Isso é terrivelmente ineficiente e atinge o limite de memória para entradas acima de 5.

Experimente online

Explicação

l{fqQsTy*P30
         P30   Get the prime factors of 30 [2, 3, 5].
        *   Q  Repeat them (implicit) input times.
       y       Take the power set...
  fqQsT        ... and filter the ones whose sum is the input.
l{             Count unique lists.

Próton , 32 bytes

f=n=>n>0?f(n-2)+f(n-3)+f(n-5):!n

Experimente online!

Mesma abordagem como resposta OVS .

Wolfram Language (Mathematica) , 43 bytes

Tr[Multinomial@@@{2,3,5}~FrobeniusSolve~#]&

Experimente online!

Explicação: FrobeniusSolvecalcula todas as soluções da soma não ordenada 2a + 3b + 5c = ne depois Multinomialdescobre quantas maneiras podemos ordenar essas somas.

Ou podemos simplesmente copiar a solução de todos os outros pela mesma contagem de bytes:

f@1=0;f[0|2|3|4]=1;f@n_:=Tr[f/@(n-{2,3,5})]

Haskell , 40 bytes

f 0=1
f n|n<0=0|1>0=f(n-2)+f(n-3)+f(n-5)

Experimente online!