Desafio

Nesta tarefa, você calculou o número de maneiras pelas quais podemos distribuir as bolas A nas células B, com cada célula tendo pelo menos uma bola.

As entradas A e B são fornecidas em uma única linha separada por um espaço em branco, as entradas são terminadas por EOF.

Você pode verificar suas soluções aqui .

Entrada

0 0
1 0
12 4
6 3
18 17
20 19
15 13
18 9
20 20
17 14
9 2
14 13
18 11

Resultado

1
0
14676024
540
54420176498688000
23112569077678080000
28332944640000
38528927611574400
2432902008176640000
21785854970880000
510
566658892800
334942064711654400

Restrições

• Todos os A e B podem ser distinguidos.
• 0 <= A, B <= 20
• Você pode usar qualquer idioma de sua escolha
• A solução mais curta vence!

JavaScript (90 93 )

function f(a,b){n=m=r=1;for(i=b;i>0;n*=-1){r+=n*m*Math.pow(i,a);m=m*i/(b-i--+1)}return--r}

http://jsfiddle.net/RDGUn/2/

Obviamente, qualquer linguagem baseada em matemática, como a APL, me derrotará por causa da verbosidade da sintaxe e da falta de construções matemáticas internas :)

Editar Além disso, não tenho nenhuma funcionalidade relacionada à entrada, exceto os parâmetros passados ​​para a função, não tenho certeza de como usar a entrada padrão com JavaScript ...

Editar: Mover i--para m=m*expressão; mudar n*=-1para for; comece r=1a combinar as tarefas e remova as estranhas no retorno. (economize 3 caracteres)

Golfscript - 56 50 49 48 41 40 38 37 caracteres

n%{~),{!}%\{0.@{.@+2$*@)@}/;;]}*)p;}/

Nota: ele lida com várias linhas de entrada, é rápido (1/8 segundos para executar os casos de teste) e não quebra para nenhuma entrada legal.

(A primeira versão também foi o meu primeiro programa Golfscript; agradeço ao eBusiness por apontar vários truques que perdi).

Para tornar este post educacional útil também, aqui está uma explicação de como ele funciona. Começamos com a recorrência f(n, k) = k * (f(n-1, k) + f(n-1, k-1)). Isso pode ser entendido combinatoricamente como dizer que, para colocar nbolas distinguíveis em kbaldes distinguíveis, de modo que cada balde contenha pelo menos uma bola, você escolhe um dos kbaldes para a primeira bola ( k *) e, em seguida, conterá pelo menos mais uma bola ( f(n-1, k)) ou não vai ( f(n-1, k-1)).

Os valores resultantes disso formam uma grade; tomando ncomo o índice de linha e kcomo o índice da coluna e indexando ambos a partir de 0 começa

1   0   0   0    0    0   0 ...
0   1   0   0    0    0   0 ...
0   1   2   0    0    0   0 ...
0   1   6   6    0    0   0 ...
0   1  14  36   24    0   0 ...
0   1  30 150  240  120   0 ...
0   1  62 540 1560 1800 720 ...
.   .   .   .    .    .   . .
.   .   .   .    .    .   .  .
.   .   .   .    .    .   .   .

Então, voltando-se para o programa,

n%{~ <<STUFF>> }/

divide a entrada em linhas e, em seguida, para cada linha a avalia, colocando ne kna pilha e, em seguida <<STUFF>>, chama , da seguinte maneira:

),{!}%\{0.@{.@+2$*@)@}/;;]}*)p;

Este calcula as primeiras k+1entradas do n+1th linha dessa grade. Inicialmente, a pilha é n k.
),dá pilha de n [0 1 2 ... k]
{!}%dá pilha de n [1 0 0 ... 0]onde há k0s.
\{ <<MORE STUFF>> }*traz a nao topo e faz com que seja o número de vezes que executamos <<MORE STUFF>>.
Nossa pilha atualmente é uma linha da tabela: [f(i,0) f(i,1) ... f(i,k)]
0.@coloca um par de 0s antes dessa matriz. A primeira será je a segunda será f(i,j-1).
{ <<FINAL LOOP>> }/percorre os elementos da matriz; para cada um, coloca-o no topo da pilha e depois executa o corpo do loop.
.@+2$*@)@é chato manipulação pilha para tomar ... j f(i,j-1) f(i,j)e rendimento ... j*(f(i,j-1)+f(i,j)) j+1 f(i,j)
;;]aparece fora a esquerda ao longok+1 f(i,k)e reúne tudo em uma matriz, pronta para a próxima rodada.
Finalmente, quando geramos a nquinta linha da tabela,
)p;pega o último elemento, o imprime e descarta o restante da linha.

Para a posteridade, três soluções de 38 caracteres sobre esse princípio:
n%{~),{!}%\{0.@{.@+@.@*\)@}/;;]}*)p;}/
n%{~),{!}%\{0:x\{x\:x+1$*\)}/;]}*)p;}/
n%{~),{!}%\{0.@{@1$+2$*\@)}/;;]}*)p;}/

J, 40

4 :'|-/x(^~*y!~])i.1x+y'/&.".;._2(1!:1)3 

Por exemplo

4 :'-/((x^~|.@:>:)*y&(!~))i.y'/x:".>{.;:(1!:1)3
15 13
28332944640000

<1 segundo para todos os casos de teste.

Editar% s

• (52 → 47) Reduza com em -/vez de alternar (1 _1)*(ideia de JB)
• (47 → 53) Requisito de entrada multilinha observado: - /
• (53 → 48) Explorar simetria de binômios.
• (48 → 48) Torne tácito!
• (48 → 41)
• (41 → 40) Aperte incremento + conversão em1x+

Lisp comum (83)

(defun b (x y)
  (if (= (* x y) 0)
      (if (= (+ x y) 0) 1 0)
      (* y (+ (b (decf x) y) (b x (1- y)))))))

Parece que deveria haver uma maneira mais curta de testar os casos básicos, mas nada me ocorre de imediato.

J, 38 a 42

Dependendo das suas preferências de rigor sobre idiomas interativos e apresentação de saída, faça a sua escolha no espectro J de soluções:

• 38 menor interativo: 4 :'|-/(!&y*^&x)i.1x+y'/&".;._2(1!:1)3
  Inicie o jconsole, insira-o e cole a entrada (termine com Cd). Você notará que a saída é separada por espaço (J é uma linguagem vetorial, ele executa a computação em toda a entrada como um todo e a retorna como um vetor 1D, cuja apresentação padrão é em uma única linha). Considero que ok, o espírito deste problema é computação, não apresentação. Mas se você insistir em ter novas linhas:
• 39 mais interativo: 4 :'|-/(!&y*^&x)i.1x+y'/&.".;._2(1!:1)3
  Substituir Compose ( &) por Under ( &.) retorna um vetor de strings, cuja apresentação termina em linhas separadas.
• 42 modo em lote: 4 :'echo|-/(!&y*^&x)i.1x+y'/&".;._2(1!:1)3
  execute a partir da linha de comandos como$ jconsole balls.ijs < balls.in

Se você votou isso, você pode querer ir dar solução do Eelvex algum crédito também.

GolfScript - 45 38 36 caracteres

Relação de recorrência de implementação suja de força média ( 38 36 caracteres):

n%{~{.2$*{\(.2$f\2$(f+*}{=}if}:f~p}/

A relação de recorrência que roubei da solução de Peter Taylors, é assim:

f(x, y) = y * ( f(x-1, y) + f(x-1, y-1) )

Com casos especiais, se qualquer variável for 0.

Minha implementação não reutiliza resultados anteriores, portanto, cada chamada de função ramifica para duas novas chamadas, a menos que um dos zero casos tenha sido alcançado. Isso dá o pior caso de chamadas de função 2 ^ 21-1, que levam 30 segundos na minha máquina.

Solução em série de força leve (45 caracteres):

n%{~.),0\{.4$?3$,@[>.,,]{1\{)*}/}//*\-}/p;;}/

J, 55 caracteres

(wd@(4 :'(y^x)--/(!&y*^&x)|.i.y')/@".@,&'x');._2(1!:1)3

• Passa nos casos de teste atuais. Eu acho que entendo a matemática ...
• j602, somente console ( wd). Entrada em stdin, saída em stdout.

Script de teste do Bash:

jconsole disballs.ijs <<END
12 4
6 3
END

Golfscript - 26 caracteres

Aviso: O gabinete do 12 4 precisa de muita memória (embora não tanto quanto a resposta abaixo) e demora um pouco para ser executado

~:)\?:x,{x+)base(;.&,)=},,

Obviamente, esta resposta tem alguns problemas, mas vou deixar aqui porque os comentários se referem a ela e a resposta de mellamokb se baseia nela.

Golfscript - 24 caracteres

Aviso: O gabinete 12 4 precisa de muita memória e demora um pouco para ser executado

~:o)\?,{o)base[0]-,o=},,

Python 140 Chars

import sys
f=lambda n,k:(n and k and n>=k and k*(f(n-1,k-1)+f(n-1,k)))or(n+k==0 and 1)or 0
for l in sys.stdin:print f(*(map(int,l.split())))

dc, 100 caracteres

[0q]s5[1q]s6[l2l3>5l3 0>5l2 0=6l2 1-S2l3dS3 1-S3l1xL3s9l1xL2s9+L3*]s1[?z0=5S3S2l1xL3L2+s9fs9l4x]ds4x

Infelizmente, o dc não parece ser apoiado por ideona. Ainda pode haver um ou dois personagens, mas é hora de dormir.

Nota: isso suporta várias linhas de entrada, tem precisão suficiente para fornecer a saída correta mesmo para 20 19(maldição, Perl, pelo tempo que perdi depurando minha solução!) E fornece a saída correta para 0 0.

As sugestões da Nabb permitem encurtar pelo menos até

[0q]sZ[1q]sI[?z0=ZSkSn[lnlk>Zlk0>Zln0=Iln1-SnlkdSk1-SklFxLks9lFxLns9+Lk*]dsFxfs9l4x]ds4x

ao custo de deixar lixo nas pilhas de registradores (e, assim, ficar sem memória se calcularmos bilhões de respostas).

Golfe (28 31 37 )

~):$\.($\?:@;?,{@+}%{$base$,\-[0]=},,

Modificação na gnibblersolução GolfScript. Eu acho que essa é uma solução funcional - testada com [3,2], [4,2], [6,3] e [9,2] com respostas corretas. (Eu usei $e @para variáveis ​​para aumentar o espaço em torno da basepalavra - chave).

Existem dois problemas com gnibblera solução atual.

1. A verificação do comprimento após a remoção de [0] não garante uma solução, pois [1,1,1,1] seria válido para a entrada [4,2], mesmo que todas as 4 bolas estejam na mesma célula (1). Então, modifiquei para verificar também se todos os dígitos são usados, ou seja, a matriz contém 1-2, para que cada célula contenha pelo menos uma bola.
2. No caso da entrada [4,2], o formato base-3 dos números 0-27 tem menos de 4 dígitos e os 0 mais à esquerda não são incluídos. Isso significa [1,1] é incluído como uma solução válida, mesmo que tecnicamente seja [0,0,1,1], o que significa que as duas primeiras bolas não são colocadas em lugar algum. Corrijo adicionando 3 ^ 3 a cada entrada (genericamente k ^ n-1 à matriz de entradas k ^ n) para que as primeiras entradas sejam deslocadas para cima, tendo pelo menos n dígitos no formato base-k e a última as entradas serão automaticamente inválidas de qualquer maneira e não afetarão a solução (porque o segundo dígito sempre será 0).

Editar

~:@\?:$,{$+}%{@base(;@,\-,0=},,

`~:@\?:$,{$+@base(;@,\-,0=},,`

Melhor solução ainda! Não há necessidade de incrementar, basta adicionar a todos os números para que eles comecem com [1] e nenhum dígito estará faltando (incluindo o preenchimento à esquerda dos zeros) depois que você desconectar o primeiro dígito. Esta solução deve funcionar e foi testada com as mesmas entradas acima. Também é muito mais rápido, porque não estamos incrementando antes de pegar o expoente para gerar a matriz (mas ainda sofre do mesmo problema de desempenho / memória para entradas maiores).

Editar : use gnibblera idéia de mover a adição de $dentro do filtro em vez de uma etapa extra. (economize 3 caracteres).

05AB1E , 19 bytes

#D`ULX.Œʒ€gßĀ}gs_P+

NOTA: É extremamente lento e já atinge o tempo limite 12 4. Está funcionando como pretendido, no entanto. Vou ver se consigo criar um método alternativo que funcione para todos os casos de teste em um tempo razoável. Veja abaixo uma versão muito mais rápida que executa todos os casos de teste em menos de um segundo.

Experimente on-line ou verifique mais alguns casos de teste (menores) .

Explicação:

#               # Split the (implicit) input-string by spaces
 D              # Duplicate it
  `             # Push both values to the stack
   U            # Pop and store the second value in variable `X`
    L           # Create a list in the range [1,n] for the first value
     X.Π       # Create a list of all possible ways to divide this list into `X` partitions
                # (including empty sublists, so we'll have to filter them out:)
        ʒ       # Filter this list of lists of partition-lists by:
         €g     #  Get the length of each partition-list
           ß    #  Get the minimum length
            Ā   #  Truthify; 0 remains 0 (falsey); anything else becomes 1 (truthy)
             }g # After the filter, take the length to get the amount left
 s              # Swap so the duplicated input-list is at the top of the stack again
  _             # Check for each value if they're equal to 0 (1 if truthy; 0 if falsey)
   P            # Take the product of the two to check if both input-values are 0
    +           # And add it to the earlier calculated product (edge case for [0,0] = 1)
                # (After which the result is output implicitly)

05AB1E , 29 bytes

Aqui está uma versão muito mais rápida, que funciona para todos os casos de teste em cerca de 0,5 segundos no TIO:

Î#R`V©LRvyYmX*NÈ·<*+Xy*®y->÷U

Porta da resposta JavaScript de @mellamokb , por isso, certifique-se de que o vota!

Experimente online ou verifique todos os casos de teste .

Explicação:

Î                    # Push (result=) 0 and the input
 #                   # Split the input by spaces
  R`                 # Push the values to the stack reversed
    V                # Pop and store the first value in variable `Y`
     ©               # Store the second value in variable `®` (without popping)
      LRv            # Loop `y` in the range [`®`,1], with index `N` in the range [0,`®`):
         yYm         #  Calculate `y` to the power `Y`
            X*       #  Multiply it by `X`
                     #  (Note: `X` is 1 before setting it to another value initially)
              NÈ     #  Check if index `N` is even (1 if truthy; 0 if falsey)
                ·<   #  Double it; and decrease it by 1 (1 if truthy; -1 if falseY0
                  *  #  Multiply it to the earlier number
                   + #  And add it to the result
         Xy*         #  Push `X` multiplied by `y`
         ®y->        #  Push `®` - `y` + 1
             ÷       #  Integer divide them
              U      #  Pop and store it as new variable `X`
                     # (output the result at the top of the stack implicitly after the loop)

OBSERVAÇÃO: funciona para maiúsculas e minúsculas 0 0nesse caso (diferente da resposta JavaScript da qual portou este método), porque o Lbuilt-in criará uma lista [0,1].