P _k (n) significa a quantidade de partições nexatamente em kpartes. Dado ne k, calcule P _k (n).

Dica: P _k (n) = P _k (n-k) + P _k-1 (n-1), com valores iniciais p ₀ (0) = 1 ep _k (n) = 0 se n ≤ 0 ou k ≤ 0. ^[Wiki]

Exemplos

n    k    Ans
1    1    1
2    2    1
4    2    2
6    2    3
10   3    8

Regras

• Aplicam-se as regras gerais de código-golfe .

Pitão , 9 7 6 bytes

^{-1 byte graças a Erik, o Outgolfer !}

/lM./E

Experimente online!

As entradas para o programa são revertidas (ie k, n).

Rápido , 76 73 bytes

func P(_ n:Int,_ k:Int)->Int{return n*k>0 ?P(n-k,k)+P(n-1,k-1):n==k ?1:0}

Experimente online!

Explicação

Como o código funciona estruturalmente?

Antes de tudo, definimos nossa função P , com dois parâmetros inteiros ne k, e dar-lhe um tipo de retorno Int, com este pedaço de código: func P(_ n:Int,_ k:Int)->Int{...}. O truque legal aqui é que dizemos ao compilador para ignorar os nomes dos parâmetros, _seguido por um espaço, o que nos salva dois bytes quando chamamos a função. returné obviamente usado para retornar o resultado do nosso ternário aninhado descrito abaixo.

Outro truque que usei foi o de n*k>0poupar alguns bytes n>0&&k>0. Se a condição for verdadeira (ambos os números inteiros ainda são maiores que 0), então recursivamente chamamos nossa função com ndecrementada de kcomo nova ne kpermanece a mesma, e adicionamos o resultado deP() com ne kdecrementada por 1. Se a condição não for verdadeira , retornamos um 1ou 0dependendo se né igual a k.

Como o algoritmo recursivo funciona?

Sabemos que o primeiro elemento da sequência é p ₀ (0) e, portanto, verificamos se os dois números inteiros são positivos ( n*k>0). Se não forem maiores que 0, verificamos se são iguais ( n==l ?1:0), sendo dois casos:

• Existe exatamente 1 partição possível e, portanto, retornamos 1, se os números inteiros forem iguais.

• Não há partições se uma delas já for 0 e a outra não.

No entanto, se ambos forem positivos, chamamos recursivamente Pduas vezes, adicionando os resultados de P(n-k,k)e P(n-1,k-1). E rodamos novamente atén atingir 0.

_{* Nota: Os espaços não podem ser removidos.}

Gelatina , 6 bytes

œċS€ċ⁸

Experimente online!

Python 2 , 61 55 51 50 bytes

-10 bytes graças a Erik, o Outgolfer. -1 byte graças ao Sr. Xcoder.

Eu direi que copiei a dica do OP e a traduzi para Python. : P

P=lambda n,k:n*k>0and P(n-k,k)+P(n-1,k-1)or+(n==k)

Experimente online!

Mathematica, 33 bytes

Length@IntegerPartitions[#,{#2}]&

aqui está a tabela nxk

 \k->
 n1  0  0   0   0   0   0   0   0   0  
 |1  1  0   0   0   0   0   0   0   0  
 v1  1  1   0   0   0   0   0   0   0  
  1  2  1   1   0   0   0   0   0   0  
  1  2  2   1   1   0   0   0   0   0  
  1  3  3   2   1   1   0   0   0   0  
  1  3  4   3   2   1   1   0   0   0  
  1  4  5   5   3   2   1   1   0   0  
  1  4  7   6   5   3   2   1   1   0  
  1  5  8   9   7   5   3   2   1   1  

JavaScript (ES6), 42 40 39 bytes

Eu acho que isso funciona.

f=(x,y)=>x*y>0?f(x-y,y)+f(--x,--y):x==y

Tente

k.value=(
f=(x,y)=>x*y>0?f(x-y,y)+f(--x,--y):x==y
)(i.value=10,j.value=3)
onchange=_=>k.value=f(+i.value,+j.value)

*{font-family:sans-serif}input{margin:0 5px 0 0;width:100px;}#j,#k{width:50px;}

<label for=i>n: </label><input id=i type=number><label for=j>k: </label><input id=j type=number><label for=k>P<sub>k</sub>(n): </label><input id=k readonly>

MATL , 14 bytes

y:Z^!S!Xu!Xs=s

Experimente online!

Explicação

Considere entradas 6, 2.

y     % Implicitly take the two inputs. Duplicate from below
      % STACK: 6, 2, 6
:     % Range
      % STACK: 6, 2, [1 2 3 4 5 6]
Z^    % Cartesian power
      % STACK: 6, [1 1; 1 2; ... 1 5; 1 6; 2 1; 2 2; ...; 6 6]
!S!   % Sort each row
      % STACK: 6, [1 1; 1 2; ... 1 5; 1 6; 1 2; 2 2; ...; 6 6]
Xu    % Unique rows
      % STACK: 6, [1 1; 1 2; ... 1 5; 1 6; 2 2; ...; 6 6]
!Xs   % Sum of each row, as a row vector
      % STACK: 6, [2 3 ... 6 7 4 ... 12]
=     % Equals, element-wise
      % STACK: [0 0 ... 1  0 0 ... 0]
s     % Sum. Implicitly display
      % STACK: 3

Haskell, 41 bytes

0#0=1
n#k|n*k>0=(n-k)#k+(n-1)#(k-1)
_#_=0

Experimente online!

Haskell , 41 bytes

n&0=0^n
n&k=sum$map(&(k-1))[n-1,n-k-1..0]

Experimente online!

Uma recorrência alternativa.

Pari / GP , 35 bytes

O Pari / GP possui um built-in para iterar sobre partições inteiras.

n->k->i=0;forpart(x=n,i++,,[k,k]);i

Experimente online!

Gelatina , 13 bytes

Eu tenho um sentimento sabe esta abordagem básica não vai ser o golfiest!

RŒṖL€€Ṣ€QṀ€=S

Experimente online!

05AB1E , 9 bytes

L²ã€{ÙO¹¢

Experimente online!

CJam , 18 bytes

{_,:)@m*:$_&::+e=}

Experimente online!

Espera entradas ao contrário, ou seja, em k nvez de n k.

Scala , 73 bytes

Bem, este é um uso fácil e não resolvido da dica do OP.

ke nsão os parâmetros da minha função recursiva f. Vejo link do TIO para o contexto.

Como isso é recursivo, devo incluir a função def na contagem de bytes?

(k,n)match{case(0,0)=>1
case _ if k<1|n<1=>0
case _=>f(n-k,k)+f(n-1,k-1)}

Experimente online!

C (gcc) , 41 bytes

f(n,k){n=n*k>0?f(n-k,k)+f(--n,--k):n==k;}

Experimente online!

R (+ pryr), 49 bytes

f=pryr::f(`if`(k<1|n<1,!n+k,f(n-k,k)+f(n-1,k-1)))

Que avalia a função recursiva

function (k, n) 
if (k < 1 | n < 1) !n + k else f(n - k, k) + f(n - 1, k - 1)

(k < 1 | n < 1)verifica se algum dos estados iniciais é atendido. !n + kavalia como TRUE (1) se ambos ne ksão 0 e FALSE (0) caso contrário. f(n - k, k) + f(n - 1, k - 1)lida com a recursão.