8

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 .

code-golf combinatorics integer-partitions

— anta40
fonte

1

Bem-vindo ao PPCG! Infelizmente, aqui não respondemos a perguntas gerais de programação. No entanto, você poderá obter ajuda no estouro de pilha . Apenas verifique sua central de ajuda antes de perguntar. :)

— Erik the Outgolfer

1

Alguém pode reformular isso em um desafio? Porque isso seria divertido.

— Urna de polvo mágico

1

@Shaggy Ugghhh ... filtrando através dos desafios com a palavra sumem si não foi uma boa idéia para tentar resolver esse inquérito ...

— Magia Octopus Urna

2

Reescrevi sua pergunta um pouco para torná-la melhor no codegolf. Também alterei o resultado da entrada 11de 12para 16. Claro que se sentir livre para corrigir isso, se eu não entendi a sua intenção

— Ton Hospel

2

Isto é oeis.org/A079973

— Ton Hospel

9

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!

— ovs
fonte

Parece que and/orfunciona e salva um byte: f=lambda n:n>0and f(n-2)+f(n-3)+f(n-5)or n==0.

— xnor 16/02

@xnor muito obrigado. Eu apenas tentei o contrário

— ovs 16/02

6

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)

— Emigna
fonte

3

Pitão , 9 bytes

/sM{y*P30

Experimente aqui!

Pitão , 16 bytes

l{s.pMfqT@P30T./

Experimente aqui

Quão?

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

— Mr. Xcoder
fonte

3

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.

— Mr. Xcoder
fonte

Acelerá-lo, substituindo ³com H(em seguida, ele irá expirar em 12 em vez de 6)

— Jonathan Allan

@JonathanAllan Feito, obrigado.

— Sr. Xcoder

2

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

— Ton Hospel
fonte

2

C, 41 bytes

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

Experimente online!

— 0xrgb
fonte

2

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

Mostrar snippet de código

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

Expandir snippet

— Arnauld
fonte

2

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!

— rturnbull
fonte

1

48 bytes

— Giuseppe

@ Giuseppe Melhoria muito boa!

— rturnbull

1

ah, você não precisa do 0(eu não considerei isso antes), pois os unários também o +farão numeric.

— Giuseppe

1

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

— Luis Mendo
fonte

1

05AB1E , 10 bytes

30fIиæÙOI¢

Experimente online!

— Mr. Xcoder
fonte

1

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

— MegaTom
fonte

1

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!

— alefalpha
fonte

0

Gelatina , 21 bytes

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

Experimente online!

Certamente pode ser jogado golfe

— HyperNeutrino
fonte

0

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.

0

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 .

— Mr. Xcoder
fonte

JS polyglot :-)

— Arnauld

0

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

— Não é uma árvore
fonte

0

Haskell , 40 bytes

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

Experimente online!

— ovs
fonte

Soma de combinações com repetição

Python 2 , 46 45 bytes

Oásis , 9 bytes

Pitão , 9 bytes

Pitão , 16 bytes

Quão?

Gelatina , 11 bytes

Como funciona

Perl, 38 bytes

C, 41 bytes

JavaScript (ES6), 32 bytes

Casos de teste

R , 56 49 47 bytes

MATL , 15 bytes

Como funciona

05AB1E , 10 bytes

Ruby , 41 bytes

Pari / GP , 36 bytes

Pari / GP , 37 bytes

Gelatina , 21 bytes

Pitão, 12 bytes

Explicação

Próton , 32 bytes

Wolfram Language (Mathematica) , 43 bytes

Haskell , 40 bytes