도전

이 작업에서는 적어도 하나의 공을 갖는 모든 셀과 함께 A 공을 B 셀에 분배 할 수있는 방법의 수를 계산했습니다.

입력 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

제약

• 모든 A와 B를 구별 할 수 있습니다.
• 0 <= A, B <= 20
• 원하는 언어를 사용할 수 있습니다
• 최단 솔루션이 승리합니다!

자바 스크립트 (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 문자 절약)

골프 스크립트 -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)). 이것은 배치하는 것을 말 combinatorically 이해 될 수 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+1번째 행의 첫 번째 항목 이 계산 됩니다. 처음에 스택은 n k입니다.
),스택 은 0 n [0 1 2 ... k]
{!}%이 n [1 0 0 ... 0]있는 곳에 스택을 제공합니다 k. 를 맨 위로
\{ <<MORE STUFF>> }*가져오고 n실행 횟수를 지정 <<MORE STUFF>>합니다.
우리의 스택은 현재 테이블의 행입니다 [f(i,0) f(i,1) ... f(i,k)]
0.@. 해당 배열 앞에 몇 개의 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)모든 것을 배열로 모아서 다음 순환을 준비합니다.
마지막으로, n테이블 의 세 번째 행을 생성하면
)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는 벡터 언어이며 전체 입력에 대한 전체 계산을 수행하고 기본 프레젠테이션이 한 줄에있는 1D 벡터로 반환 함). 나는이 문제의 정신은 표현이 아니라 계산이라고 생각합니다. 그러나 대신 줄 바꿈을 요구하는 경우 :
• 39 이상 대화 형 : 4 :'|-/(!&y*^&x)i.1x+y'/&.".;._2(1!:1)3
  교체 작성 ( &과) 에서을 ( &.) 그의 프리젠 테이션 별도의 라인에 끝나는 문자열의 벡터를 반환합니다.
• 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}/

Peter Taylors 솔루션에서 훔친 반복 관계는 다음과 같습니다.

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

특별한 경우에는 두 변수 중 하나가 0입니다.

내 구현은 이전 결과를 재사용하지 않으므로 0의 경우 중 하나에 도달하지 않으면 각 함수 호출은 두 개의 새로운 호출로 분기됩니다. 이것은 내 컴퓨터에서 30 초가 걸리는 최악의 2 ^ 21-1 함수 호출을 제공합니다.

경량 시리즈 솔루션 (45 자) :

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

J, 55 자

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

• 현재 테스트 사례를 통과합니다. 나는 수학을 이해하는 것 같아요 ...
• j602, 콘솔 만 ( wd). stdin에 입력하고 stdout에 출력

배쉬 테스트 스크립트 :

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

골프 스크립트-26 자

경고 : 12 4 경우에는 많은 메모리가 필요하지만 (아래 답변 만큼은 아니지만) 실행하는 데 시간이 오래 걸립니다

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

분명히이 답변에는 몇 가지 문제가 있지만 주석은 그것을 참조하고 mellamokb의 답변은 그것을 기반으로하기 때문에 여기에 남겨 두겠습니다.

골프 스크립트-24 자

경고 : 12 4 케이스에는 많은 메모리가 필요하며 실행하는 데 시간이 오래 걸립니다

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

파이썬 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())))

dc, 100 자

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

아아, dc는 ideone에 의해 지원되지 않는 것 같습니다. 짜 내야 할 캐릭터가 여전히있을 수 있지만, 취침 시간입니다.

참고 : 이것은 여러 줄의 입력을 지원하고 (정확한 결과를 제공하기 위해 20 19Perl을 저주 할 때도) 정확한 출력을 제공하기에 충분한 정밀도를 가지며 올바른 출력을 제공합니다 0 0.

Nabb의 제안에 따라 최소한 단축

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

레지스터 스택에 정크를 남기는 비용으로 (따라서 수십억 개의 답변을 계산하면 메모리가 부족합니다).

골프 스크립트 (28 31 37 )

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

gnibbler의 GolfScript 솔루션으로 수정되었습니다 . 나는 이것이 올바른 해결책으로 [3,2], [4,2], [6,3] 및 [9,2]에서 테스트 된 작동 솔루션이라고 생각합니다. ( 키워드 주위의 공간을 강화하기 위해 $및 @변수를 사용했습니다 base).

gnibbler의 현재 솔루션 에는 두 가지 문제가 있습니다.

1. 4 개의 모든 볼이 동일한 셀 (1)에 있더라도 [1,1,1,1]이 입력 [4,2]에 유효하므로 [0]을 제거한 후 길이를 확인해도 솔루션이 보장되지 않습니다. 따라서 모든 숫자가 사용되는지 확인합니다. 즉, 배열에 1-2가 포함되어 있으므로 각 셀에 하나 이상의 공이 포함됩니다.
2. 입력 [4,2]의 경우, 숫자 0-27의 기본 3 형식은 4 자리 미만이며 가장 왼쪽에있는 0은 포함되지 않습니다. 즉, 기술적으로 실제로는 [0,0,1,1]이더라도 [1,1]이 유효한 솔루션으로 포함됨을 의미합니다. 이는 처음 두 개의 공이 어디에도 배치되지 않음을 의미합니다. 모든 항목에 3 ^ 3을 추가하여 (일반적으로 k ^ n-1을 k ^ n 항목 배열에 추가) 수정하여 첫 번째 항목이 기본 k 형식의 최소 n 자리를 갖도록 위로 이동하고 마지막 항목은 입력은 어쨌든 자동으로 유효하지 않으며 솔루션에 영향을 미치지 않습니다 (두 번째 숫자는 항상 0이므로).

편집하다

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

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

아직 더 나은 솔루션! 증분 할 필요없이 모든 숫자에 더하기 만하면 [1]로 시작하며 첫 번째 숫자를 디콘 한 후에는 왼쪽 패딩 (0의 왼쪽 패딩 포함)이 없습니다. 이 솔루션은 작동해야하며 위와 동일한 항목으로 테스트되었습니다. 배열을 생성하기 위해 지수를 취하기 전에 증가하지 않기 때문에 훨씬 빠릅니다 (그러나 더 큰 입력에 대해 동일한 성능 / 메모리 문제가 여전히 발생합니다).

편집 : 추가 단계 대신 필터 내부 gnibbler추가를 이동한다는 아이디어를 사용하십시오 $. (3 자 저장).

05AB1E , 19 바이트

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

참고 : 속도가 너무 느리고 이미 시간이 초과되었습니다 12 4. 그래도 의도 한대로 작동합니다. 합리적인 시간에 모든 테스트 사례에 적합한 대체 방법을 생각해 낼 수 있는지 살펴 보겠습니다. 1 초 이내에 모든 테스트 사례를 실행하는 훨씬 빠른 버전은 아래를 참조하십시오.

온라인으로 시도 하거나 더 작은 테스트 사례를 몇 가지 더 확인하십시오 .

설명:

#               # 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 바이트

다음은 TIO에서 약 0.5 초 안에 모든 테스트 사례에서 작동하는 훨씬 빠른 버전입니다.

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