Thử thách

Trong tác vụ này, bạn đã tính toán số cách chúng ta có thể phân phối các quả bóng A vào các ô B với mỗi ô có ít nhất một quả bóng.

Các đầu vào A và B được đưa ra trong một dòng được phân tách bằng khoảng trống, các đầu vào được kết thúc bằng EOF.

Bạn có thể muốn kiểm tra các giải pháp của bạn ở đây .

Đầu vào

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

Đầu ra

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

Những ràng buộc

• Mọi A và B có thể được phân biệt.
• 0 <= A, B <= 20
• Bạn có thể sử dụng bất kỳ ngôn ngữ nào bạn chọn
• Giải pháp ngắn nhất sẽ thắng!

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/

Rõ ràng, bất kỳ ngôn ngữ dựa trên toán học nào như APL sẽ đánh bại tôi vì tính dài dòng cú pháp và thiếu các cấu trúc toán học tích hợp :)

Chỉnh sửa Ngoài ra, tôi không có bất kỳ chức năng nào liên quan đến đầu vào ngoại trừ các tham số được truyền vào chức năng, không chắc chắn cách sử dụng đầu vào tiêu chuẩn với JavaScript ...

Chỉnh sửa: Di chuyển i--vào m=m*biểu thức; di chuyển n*=-1vào for; bắt đầu r=1kết hợp các bài tập và loại bỏ một bài tập không liên quan. (lưu 3 ký tự)

Golfscript - 56 50 49 48 41 40 38 37 ký tự

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

Lưu ý: việc này xử lý nhiều dòng đầu vào, nhanh (1/8 giây để thực hiện các trường hợp kiểm tra) và không phá vỡ bất kỳ đầu vào hợp pháp nào.

(Phiên bản đầu tiên cũng là chương trình Golfscript đầu tiên của tôi; cảm ơn eBusiness đã chỉ ra một số thủ thuật mà tôi đã bỏ lỡ).

Để làm cho bài viết này trở thành một bài viết giáo dục hữu ích, đây là một lời giải thích về cách thức hoạt động của nó. Chúng tôi bắt đầu với sự tái phát f(n, k) = k * (f(n-1, k) + f(n-1, k-1)). Điều này có thể được hiểu một cách kết hợp khi nói rằng để đặt ncác quả bóng có thể phân biệt vào kcác thùng có thể phân biệt sao cho mỗi thùng chứa ít nhất một quả bóng, bạn chọn một trong các kthùng cho quả bóng đầu tiên ( k *) và sau đó nó sẽ chứa ít nhất một quả bóng nữa ( f(n-1, k)) hoặc nó sẽ không ( f(n-1, k-1)).

Các giá trị kết quả từ dạng này là một lưới; lấy nlàm chỉ mục hàng và klàm chỉ mục cột và lập chỉ mục từ 0, nó bắt đầu

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

Vì vậy, chuyển sang chương trình,

n%{~ <<STUFF>> }/

chia đầu vào thành các dòng và sau đó cho mỗi dòng đánh giá nó, đặt nvà ktrên ngăn xếp, sau đó gọi <<STUFF>>, như sau:

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

Điều này tính toán các k+1mục đầu tiên của n+1hàng thứ của lưới đó. Ban đầu ngăn xếp là n k.
),đưa ra ngăn xếp n [0 1 2 ... k]
{!}%cho ngăn xếp của n [1 0 0 ... 0]nơi có k0s.
\{ <<MORE STUFF>> }*đưa nlên đỉnh và làm cho nó số lần chúng ta thực hiện <<MORE STUFF>>.
Ngăn xếp của chúng tôi hiện là một hàng của bảng: [f(i,0) f(i,1) ... f(i,k)]
0.@đặt một vài số 0 trước mảng đó. Cái đầu tiên sẽ là jvà cái thứ hai sẽ là f(i,j-1).
{ <<FINAL LOOP>> }/các vòng lặp thông qua các phần tử của mảng; đối với mỗi cái, nó đặt nó lên trên cùng của ngăn xếp và sau đó thực thi thân vòng lặp.
.@+2$*@)@là thao tác ngăn xếp nhàm chán để lấy ... j f(i,j-1) f(i,j)và sản ... j*(f(i,j-1)+f(i,j)) j+1 f(i,j)
;;]xuất bật ra khỏi phần còn lạik+1 f(i,k)và tập hợp mọi thứ thành một mảng, sẵn sàng cho vòng tiếp theo.
Cuối cùng, khi chúng ta tạo nhàng thứ ba của bảng,
)p;lấy phần tử cuối cùng, in nó và loại bỏ phần còn lại của hàng.

Đối với hậu thế, ba giải pháp 38-char theo nguyên tắc này:
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 

Ví dụ

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

<1 giây cho tất cả các trường hợp thử nghiệm.

Chỉnh sửa

• (52 → 47) Giảm bằng -/thay vì xen kẽ (1 _1)*(ý tưởng của JB)
• (47 → 53) Yêu cầu đầu vào đa dòng được chú ý: - /
• (53 → 48) Khai thác tính đối xứng của nhị thức.
• (48 → 48) Hãy ngầm!
• (48 → 41)
• (41 → 40) Bóp tăng + chuyển đổi thành1x+

Lisp thường gặp (83)

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

Có vẻ như nên có một cách ngắn hơn để kiểm tra các trường hợp cơ bản, nhưng không có gì xảy ra với tôi.

J, 38 đến 42

Tùy thuộc vào sở thích nghiêm ngặt của bạn về ngôn ngữ tương tác và bản trình bày đầu ra, hãy chọn lựa từ giải pháp J:

• 38 tương tác ngắn nhất: 4 :'|-/(!&y*^&x)i.1x+y'/&".;._2(1!:1)3
  Khởi chạy jconsole, nhập nó, sau đó dán đầu vào (kết thúc bằng Cd). Bạn sẽ nhận thấy đầu ra được phân tách bằng dấu cách (J là ngôn ngữ vectơ, nó thực hiện tính toán trên toàn bộ đầu vào và trả về dưới dạng vectơ 1D, có phần trình bày mặc định nằm trên một dòng). Tôi cho rằng ok, tinh thần của vấn đề này là tính toán, không phải trình bày. Nhưng nếu bạn khăng khăng muốn có dòng mới thay thế:
• 39 tương tác dài hơn: 4 :'|-/(!&y*^&x)i.1x+y'/&.".;._2(1!:1)3
  Thay thế Compose ( &) bằng Under ( &.) trả về một vectơ của chuỗi, phần trình bày kết thúc trên các dòng riêng biệt.
• Chế độ hàng loạt 42 : 4 :'echo|-/(!&y*^&x)i.1x+y'/&".;._2(1!:1)3
  Chạy từ dòng lệnh như$ jconsole balls.ijs < balls.in

Nếu bạn đã bỏ phiếu này, bạn cũng có thể muốn cung cấp cho giải pháp của Eelvex một số tín dụng.

GolfScript - 45 38 36 ký tự

Quan hệ tái phát thực hiện bẩn trung bình ( 38 36 ký tự):

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

Mối quan hệ tái phát tôi đã đánh cắp từ giải pháp Peter Taylors, nó diễn ra như sau:

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

Với các trường hợp đặc biệt nếu một trong hai biến là 0.

Việc triển khai của tôi không sử dụng lại các kết quả trước đó, vì vậy mỗi hàm gọi nhánh đến hai cuộc gọi mới, trừ khi đã đạt được một trong các trường hợp không. Điều này đưa ra một trường hợp xấu nhất là 2 ^ 21-1 chức năng gọi mất 30 giây trên máy của tôi.

Giải pháp loạt lực nhẹ (45 ký tự):

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

J, 55 ký tự

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

• Vượt qua các trường hợp thử nghiệm hiện tại. Tôi nghĩ rằng tôi hiểu toán học ...
• j602, chỉ bàn điều khiển ( wd). Đầu vào trên stdin, đầu ra trên thiết bị xuất chuẩn.

Kịch bản kiểm tra Bash:

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

Golfscript - 26 ký tự

Cảnh báo: Trường hợp 12 4 cần rất nhiều bộ nhớ (mặc dù không nhiều như câu trả lời dưới đây) và mất khá nhiều thời gian để chạy

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

Rõ ràng câu trả lời này có một số vấn đề, nhưng tôi sẽ để nó ở đây vì các ý kiến ​​đề cập đến nó và câu trả lời của mellamokb dựa trên nó.

Golfscript - 24 ký tự

Cảnh báo: Trường hợp 12 4 cần nhiều bộ nhớ và mất nhiều thời gian để chạy

~: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 ký tự

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

Than ôi, dc dường như không được ideone hỗ trợ. Có thể có một hoặc hai nhân vật vẫn vắt kiệt sức, nhưng đó là giờ đi ngủ.

Lưu ý: điều này hỗ trợ nhiều dòng đầu vào, có độ chính xác đủ để cung cấp đầu ra chính xác ngay cả đối với 20 19(nguyền rủa bạn, Perl, trong thời gian tôi lãng phí gỡ lỗi giải pháp của mình!) Và đưa ra đầu ra chính xác cho 0 0.

Gợi ý từ Nabb cho phép rút ngắn ít nhất là

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

với chi phí để lại rác trong ngăn xếp đăng ký (và do đó hết bộ nhớ nếu chúng ta tính toán hàng tỷ câu trả lời).

Golf (28 31 37 )

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

Sửa đổi gnibblergiải pháp GolfScript. Tôi nghĩ rằng đây là một giải pháp hiệu quả - được thử nghiệm với [3,2], [4.2], [6,3] và [9,2] với câu trả lời đúng. (Tôi đã sử dụng $và @cho các biến để thắt chặt không gian xung quanh basetừ khóa).

Có hai vấn đề với gnibblergiải pháp hiện tại.

1. Kiểm tra độ dài sau khi xóa [0] không đảm bảo giải pháp, vì [1,1,1,1] sẽ hợp lệ cho đầu vào [4.2], mặc dù cả 4 quả bóng đều nằm trong cùng một ô (1). Vì vậy, tôi đã sửa đổi để kiểm tra xem tất cả các chữ số được sử dụng, tức là mảng chứa 1-2, vì vậy mỗi ô chứa ít nhất một quả bóng.
2. Trong trường hợp đầu vào [4.2], định dạng cơ sở 3 của các số 0-27 nhỏ hơn 4 chữ số và không bao gồm hầu hết các số 0 bên trái. Điều đó có nghĩa là [1,1] được bao gồm như một giải pháp hợp lệ, mặc dù về mặt kỹ thuật thực sự là [0,0,1,1], có nghĩa là hai quả bóng đầu tiên không được đặt ở bất cứ đâu. Tôi khắc phục bằng cách thêm 3 ^ 3 vào mỗi mục nhập (nói chung là k ^ n-1 vào mảng các mục nhập k ^ n) để các mục nhập đầu tiên được chuyển lên trên để có ít nhất n chữ số ở định dạng cơ sở-k và cuối cùng các mục sẽ tự động không hợp lệ và sẽ không ảnh hưởng đến giải pháp (vì chữ số thứ hai sẽ luôn là 0).

Biên tập

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

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

Giải pháp tốt hơn chưa! Không cần tăng, chỉ cần thêm vào tất cả các số để chúng bắt đầu bằng [1] và sẽ không có chữ số nào bị mất (kể cả phần đệm bên trái là 0) sau khi bạn giải mã chữ số đầu tiên đó. Giải pháp này sẽ hoạt động và đã được thử nghiệm với các mục tương tự ở trên. Nó cũng nhanh hơn rất nhiều vì chúng tôi không tăng trước khi lấy số mũ để tạo mảng (nhưng vẫn gặp vấn đề về hiệu năng / bộ nhớ cho đầu vào lớn hơn).

Chỉnh sửa : Sử dụng gnibblerý tưởng di chuyển bổ sung $bên trong bộ lọc thay vì thêm một bước. (lưu 3 ký tự).

05AB1E , 19 byte

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

LƯU Ý: Nó cực kỳ chậm và đã hết thời gian 12 4. Nó đang làm việc như dự định, mặc dù. Sẽ xem liệu tôi có thể đưa ra một phương pháp thay thế phù hợp cho tất cả các trường hợp thử nghiệm trong một thời gian hợp lý không. Xem bên dưới để biết phiên bản nhanh hơn nhiều, chạy tất cả các trường hợp thử nghiệm trong chưa đầy một giây.

Hãy thử trực tuyến hoặc xác minh thêm một vài trường hợp thử nghiệm (nhỏ hơn) .

Giải trình:

#               # 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 byte

Đây là phiên bản nhanh hơn nhiều, hoạt động cho tất cả các trường hợp thử nghiệm trong khoảng 0,5 giây trên TIO:

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

Câu trả lời JavaScript của @mellamokb , vì vậy hãy đảm bảo nâng cao anh ấy!

Hãy thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình:

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

LƯU Ý: Hoạt động cho trường hợp cạnh 0 0trong trường hợp này (không giống như câu trả lời JavaScript tôi đã chuyển phương thức này từ), bởi vì Lnội dung sẽ tạo một danh sách [0,1].