Вызов

В этом задании вы вычислили количество способов, которыми мы можем распределить шарики А в ячейки В, причем каждая ячейка имеет хотя бы один шарик.

Входы A и B задаются в одной строке, разделенной пробелом, входы завершаются EOF.

Вы можете проверить свои решения здесь .

вход

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

Выход

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

Ограничения

• Каждые А и В могут быть различимы.
• 0 <= A, B <= 20
• Вы можете использовать любой язык на ваш выбор
• Самое короткое решение побеждает!

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/

Очевидно, что любой математический язык, такой как APL, победит меня из-за многословия синтаксиса и отсутствия встроенных математических конструкций :)

Редактировать Также у меня нет никакой связанной с вводом функциональности, кроме параметров, переданных в функцию, я не уверен, как использовать стандартный ввод с JavaScript ...

Изменить: перейти i--в m=m*выражение; двигаться n*=-1в for; начать r=1комбинировать задания и удалить посторонние по возвращении. (сохранить 3 символа)

Golfscript - 56 50 49 48 41 40 38 37 символов

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

Примечание: это обрабатывает несколько строк ввода, быстро (1/8 секунды, чтобы выполнить тестовые случаи) и не прерывается для любого легального ввода.

(Первая версия была также моей первой в истории программой Golfscript; спасибо eBusiness за указание на несколько уловок, которые я пропустил).

Чтобы сделать этот пост полезным, вот объяснение того, как оно работает. Начнем с повторения f(n, k) = k * (f(n-1, k) + f(n-1, k-1)). Комбинатически это можно понимать как выражение, что для помещения nразличимых шаров в kразличимые ведра так, чтобы в каждом ведре был хотя бы один шарик, вы выбираете одно из kведер для первого шарика ( k *), а затем либо оно будет содержать хотя бы еще один шарик ( f(n-1, k)). или не будет ( f(n-1, k-1)).

Значения, полученные в результате этого, образуют сетку; принимая nв качестве индекса строки и kв качестве индекса столбца и индексации как от 0, он начинается

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

Итак, обращаясь к программе,

n%{~ <<STUFF>> }/

разбивает входные данные на строки, а затем для каждой строки оценивает его, помещает nи помещает kв стек, а затем вызывает <<STUFF>>, что выглядит следующим образом:

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

Это вычисляет первые k+1записи n+1th-й строки этой сетки. Изначально стек есть n k.
),дает стек n [0 1 2 ... k]
{!}%дает стек, n [1 0 0 ... 0]где есть k0.
\{ <<MORE STUFF>> }*приводит nк вершине и делает это количество раз, которое мы выполняем <<MORE STUFF>>.
Наш стек в настоящее время является строкой таблицы: [f(i,0) f(i,1) ... f(i,k)]
0.@помещает пару нулей перед этим массивом. Первый будет, jа второй будет f(i,j-1).
{ <<FINAL LOOP>> }/перебирает элементы массива; для каждого он помещает его на вершину стека и затем выполняет тело цикла.
.@+2$*@)@Скучно манипуляции стека принимать ... j f(i,j-1) f(i,j)и выход ... j*(f(i,j-1)+f(i,j)) j+1 f(i,j)
;;]щелчки от левого надk+1 f(i,k)и собирает все в массив, готовый к следующему обходу цикла.
Наконец, когда мы сгенерировали nth-ю строку таблицы,
)p;берём последний элемент, печатаем его и отбрасываем оставшуюся часть строки.

Для потомков три 38-символьных решения по этому принципу:
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 

Например

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

<1сек для всех тестовых случаев.

Правки

• (52 → 47) Уменьшить с помощью -/вместо чередования (1 _1)*(идея JB)
• (47 → 53) Замечено требование к многострочному вводу: - /
• (53 → 48) Используйте симметрию биномов.
• (48 → 48) Сделай молчание!
• (48 → 41)
• (41 → 40) Сжать приращение + преобразование в1x+

Обыкновенный Лисп (83)

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

Кажется, что должен быть более короткий способ проверки базовых случаев, но ничего не происходит со мной.

J от 38 до 42

В зависимости от ваших строгих предпочтений в отношении интерактивных языков и выходной презентации, выберите из спектра решений J:

• 38 кратчайший интерактив: 4 :'|-/(!&y*^&x)i.1x+y'/&".;._2(1!:1)3
  запустите jconsole, введите его, затем вставьте ввод (в конце нажмите Cd). Вы заметите, что выходные данные разделены пробелами (J является векторным языком, он выполняет вычисления для всего ввода в целом и возвращает его как одномерный вектор, представление которого по умолчанию находится в одной строке). Я считаю, что все в порядке, дух этой проблемы - вычисления, а не представление. Но если вы настаиваете на использовании новых строк:
• 39 более интерактивный: 4 :'|-/(!&y*^&x)i.1x+y'/&.".;._2(1!:1)3
  замена Compose ( &) на Under ( &.) возвращает вектор строк, представление которых заканчивается на отдельных строках.
• 42 пакетный режим: 4 :'echo|-/(!&y*^&x)i.1x+y'/&".;._2(1!:1)3
  запустить из командной строки как$ jconsole balls.ijs < balls.in

Если вы проголосовали за это, вы, возможно, захотите и отдать должное решению Eelvex .

GolfScript - 45 38 36 символов

Отношение рекуррентности грязной реализации средней силы ( 38 36 символов):

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

Отношение рекуррентности, которое я украл из решения Питера Тейлорса, выглядит так:

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

В особых случаях, если любая из переменных равна 0.

Моя реализация не использует предыдущие результаты, поэтому каждая функция вызывает переход к двум новым вызовам, если не был достигнут ни один из нулевых случаев. Это дает наихудший случай вызова функции 2 ^ 21-1, который занимает 30 секунд на моей машине.

Решение серии Light-force (45 символов):

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

J, 55 символов

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

• Проходит текущие тестовые случаи. Я думаю, что понимаю математику ...
• J602, только консоль ( wd). Вход на стандартный вывод, вывод на стандартный вывод.

Скрипт Bash Test:

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

Golfscript - 26 символов

Предупреждение: случай 12 4 требует много памяти (хотя и не так много, как ответ ниже) и требует много времени для запуска

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

Очевидно, у этого ответа есть некоторые проблемы, но я оставлю его здесь, потому что комментарии относятся к нему, а ответ mellamokb основан на нем.

Golfscript - 24 символа

Предупреждение: корпус 12 4 требует много памяти и требует много времени для запуска

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

Python 140 символов

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

постоянный ток, 100 символов

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

Увы, похоже, что dc не поддерживается ideone. Там может быть персонаж или два еще выжать, но это время сна.

Примечание: он поддерживает несколько строк ввода, имеет достаточную точность, чтобы дать правильный вывод даже для 20 19(проклинаю вас, Perl, за то время, которое я потратил на отладку своего решения!), И дает правильный вывод для 0 0.

Предложения от Nabb позволяют сократить хотя бы до

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

ценой оставления мусора в стеках регистра (и, следовательно, нехватки памяти, если мы вычисляем миллиарды ответов).

Golfscript (28 31 37 )

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

Модификация для gnibblerрешения GolfScript. Я думаю, что это рабочее решение - проверено с помощью [3,2], [4,2], [6,3] и [9,2] с правильными ответами. (Я использовал $и @для переменных, чтобы сжать пространство вокруг baseключевого слова).

Есть две проблемы с gnibblerтекущим решением.

1. Проверка длины после удаления [0] не гарантирует решения, потому что [1,1,1,1] будет действительным для входа [4,2], даже если все 4 шара находятся в одной ячейке (1). Поэтому я изменил, чтобы проверить также, что все цифры используются, то есть массив содержит 1-2, поэтому каждая ячейка содержит как минимум один шар.
2. В случае ввода [4,2], числа 0-27 в формате base-3 имеют длину менее 4 цифр, а самые левые 0 не включены. Это означает, что [1,1] включено в качестве допустимого решения, хотя технически оно фактически [0,0,1,1], что означает, что первые два шара нигде не размещены. Я исправляю, добавляя 3 ^ 3 к каждой записи (обычно k ^ n-1 к массиву из k ^ n записей), так что первые записи смещаются вверх, чтобы иметь по крайней мере n цифр в формате base-k, а последние Все равно записи автоматически будут недействительными и не будут влиять на решение (потому что вторая цифра всегда будет 0).

редактировать

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

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

Лучшее решение еще! Не нужно увеличивать, просто добавьте ко всем числам, чтобы они начинались с [1], и никакие цифры не будут отсутствовать (включая добавление слева в 0), когда вы удалите эту первую цифру. Это решение должно работать и было протестировано с такими же записями выше. Это также намного быстрее, потому что мы не увеличиваем значение, прежде чем брать показатель степени для генерации массива (но все же страдает от той же проблемы производительности / памяти для большего ввода).

Редактировать : использовать gnibblerидею перемещения $внутри фильтра вместо дополнительного шага. (сохранить 3 символа).

05AB1E , 19 байтов

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

ПРИМЕЧАНИЕ: это очень медленно, и время уже истекло 12 4. Тем не менее, он работает как задумано. Посмотрим, смогу ли я придумать альтернативный метод, который работает для всех тестовых случаев в разумные сроки. Ниже приведена намного более быстрая версия, которая запускает все тестовые примеры менее чем за секунду.

Попробуйте онлайн или проверьте еще несколько (из меньших) тестовых случаев .

Объяснение:

#               # 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 байт

Вот гораздо более быстрая версия, которая работает для всех тестовых случаев примерно за 0,5 секунды на TIO:

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

Порт @mellamokb ответ JavaScript , так что не забудьте поднять его!

Попробуйте онлайн или проверьте все контрольные примеры .

Объяснение:

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

ПРИМЕЧАНИЕ: 0 0в этом случае работает для крайнего случая (в отличие от ответа JavaScript, из которого я перенес этот метод), потому что Lвстроенная программа создаст список [0,1].