Tantangan

Dalam tugas ini Anda telah menghitung jumlah cara kami dapat mendistribusikan bola A ke dalam sel B dengan setiap sel memiliki setidaknya satu bola.

Input A dan B diberikan dalam satu baris yang dipisahkan oleh blank, input diakhiri oleh EOF.

Anda mungkin ingin memeriksa solusi Anda di sini .

Memasukkan

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

Keluaran

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

Kendala

• Setiap A dan B dapat dibedakan.
• 0 <= A, B <= 20
• Anda dapat menggunakan bahasa pilihan Anda
• Solusi terpendek menang!

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/

Jelas, bahasa berbasis matematika seperti APL akan mengalahkan saya karena sintaks verbositas dan kurangnya konstruk matematika bawaan :)

Sunting Juga, saya tidak memiliki fungsionalitas yang berhubungan dengan input kecuali parameter dilewatkan ke fungsi, tidak yakin bagaimana menggunakan input standar dengan JavaScript ...

Sunting: Bergerak i--ke m=m*ekspresi; pindah n*=-1ke for; mulai r=1untuk menggabungkan tugas dan menghapus yang asing sebagai balasannya. (simpan 3 karakter)

Golfscript - 56 50 49 48 41 40 38 37 karakter

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

Catatan: ini menangani banyak jalur input, cepat (1/8 detik untuk mengerjakan kasus uji), dan tidak merusak input hukum apa pun.

(Versi pertama juga merupakan program Golfscript pertama saya; terima kasih kepada eBusiness karena menunjukkan beberapa trik yang saya lewatkan).

Untuk menjadikan ini sebagai pos pendidikan yang bermanfaat juga, berikut ini penjelasan cara kerjanya. Kita mulai dengan pengulangan f(n, k) = k * (f(n-1, k) + f(n-1, k-1)). Hal ini dapat dipahami secara kombinatoris dengan mengatakan bahwa untuk menempatkan nbola yang dapat dibedakan dalam kember yang dapat dibedakan sedemikian rupa sehingga setiap ember berisi setidaknya satu bola, Anda memilih salah satu kember untuk bola pertama ( k *) dan kemudian ia akan mengandung setidaknya satu bola lagi ( f(n-1, k)) atau itu tidak akan ( f(n-1, k-1)).

Nilai yang dihasilkan dari formulir ini berupa kisi; mengambil nsebagai indeks baris dan ksebagai indeks kolom dan pengindeksan dari 0 dimulai

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

Jadi beralih ke program,

n%{~ <<STUFF>> }/

Membagi input menjadi garis dan kemudian untuk setiap baris mengevaluasinya, meletakkan ndan kdi stack, dan kemudian memanggil <<STUFF>>, yaitu sebagai berikut:

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

Ini menghitung k+1entri pertama dari n+1baris ke-k dari kisi itu. Awalnya tumpukan itu n k.
),memberi tumpukan n [0 1 2 ... k]
{!}%memberi tumpukan di n [1 0 0 ... 0]mana ada k0s.
\{ <<MORE STUFF>> }*membawa nke atas dan membuatnya menjadi berapa kali kita mengeksekusi <<MORE STUFF>>.
Tumpukan kami saat ini adalah deretan tabel: [f(i,0) f(i,1) ... f(i,k)]
0.@menempatkan beberapa 0 sebelum array itu. Yang pertama akan menjadi jdan yang kedua akan f(i,j-1).
{ <<FINAL LOOP>> }/loop melalui elemen array; untuk masing-masing menempatkannya di atas tumpukan dan kemudian menjalankan loop body.
.@+2$*@)@adalah manipulasi stack membosankan untuk mengambil ... j f(i,j-1) f(i,j)dan menghasilkan ... j*(f(i,j-1)+f(i,j)) j+1 f(i,j)
;;]muncul dari sisak+1 f(i,k)dan mengumpulkan semuanya menjadi sebuah array, siap untuk putaran berikutnya loop.
Akhirnya, ketika kita telah membuat nbaris ke-5 dari tabel,
)p;ambil elemen terakhir, cetak, dan buang sisa baris.

Untuk anak cucu, tiga solusi 38-char pada prinsip ini:
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 

Misalnya

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

<1detik untuk semua kasus uji.

Suntingan

• (52 → 47) Kurangi dengan -/alih - alih bergantian (1 _1)*(ide JB)
• (47 → 53) Pemberitahuan kebutuhan input multiline: - /
• (53 → 48) Memanfaatkan simetri binomial.
• (48 → 48) Buatlah diam-diam!
• (48 → 41)
• (41 → 40) Tekan pertambahan + konversi menjadi1x+

Gangguan Umum (83)

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

Sepertinya harus ada cara yang lebih pendek untuk menguji kasus dasar, tetapi tidak ada yang terjadi pada saya begitu saja.

J, 38 hingga 42

Bergantung pada preferensi ketat Anda tentang bahasa interaktif dan presentasi keluaran, pilihlah dari spektrum solusi:

• 38 interaktif terpendek: 4 :'|-/(!&y*^&x)i.1x+y'/&".;._2(1!:1)3
  Luncurkan jconsole, masukkan, lalu tempel input (akhiri dengan Cd). Anda akan melihat output dipisahkan oleh ruang (J adalah bahasa vektor, ia melakukan perhitungan pada seluruh input secara keseluruhan dan mengembalikannya sebagai vektor 1D, yang presentasi defaultnya adalah pada satu baris). Saya anggap oke, semangat masalah ini adalah perhitungan, bukan presentasi. Tetapi jika Anda bersikeras memiliki baris baru sebagai gantinya:
• 39 lebih lama interaktif: 4 :'|-/(!&y*^&x)i.1x+y'/&.".;._2(1!:1)3
  Mengganti Tulisan ( &) dengan Bawah ( &.) mengembalikan vektor string, yang presentasinya berakhir pada baris terpisah.
• 42 mode batch: 4 :'echo|-/(!&y*^&x)i.1x+y'/&".;._2(1!:1)3
  Jalankan dari baris perintah sebagai$ jconsole balls.ijs < balls.in

Jika Anda memilih ini, Anda mungkin ingin memberikan solusi Eelvex juga.

GolfScript - 45 38 36 karakter

Relasi rekurensi implementasi kotor-kekuatan sedang ( 38 36 karakter):

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

Relasi perulangan yang saya curi dari solusi Peter Taylors, seperti ini:

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

Dengan kasus khusus jika salah satu variabel adalah 0.

Implementasi saya tidak menggunakan kembali hasil sebelumnya, sehingga setiap fungsi memanggil cabang ke dua panggilan baru, kecuali salah satu dari nol kasus telah tercapai. Ini memberikan kasus terburuk 2 ^ 21-1 panggilan fungsi yang memakan waktu 30 detik pada mesin saya.

Solusi seri gaya ringan (45 karakter):

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

J, 55 karakter

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

• Lulus uji kasus saat ini. Saya rasa saya mengerti matematika ...
• j602, hanya konsol ( wd). Input pada stdin, output pada stdout.

Skrip uji bash:

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

Golfscript - 26 karakter

Peringatan: Kasing 12 4 membutuhkan banyak memori (walaupun tidak sebanyak jawaban di bawah) dan membutuhkan waktu yang cukup lama untuk dijalankan

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

Jelas jawaban ini memiliki beberapa masalah, tetapi saya akan meninggalkannya di sini karena komentar merujuk padanya dan jawaban mellamokb didasarkan padanya.

Golfscript - 24 karakter

Peringatan: Kasing 12 4 membutuhkan banyak memori dan perlu waktu cukup lama untuk dijalankan

~: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 karakter

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

Sayangnya, dc sepertinya tidak didukung oleh ideone. Mungkin ada satu atau dua karakter yang masih harus dimatikan, tetapi ini adalah waktu tidur.

Catatan: ini mendukung beberapa jalur input, memiliki presisi yang cukup untuk memberikan output yang benar bahkan untuk 20 19(mengutuk Anda, Perl, untuk waktu saya membuang debugging solusi saya!), Dan memberikan output yang benar untuk 0 0.

Saran dari Nabb memungkinkan pemendekan setidaknya sejauh

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

dengan biaya meninggalkan sampah di tumpukan register (dan dengan demikian kehabisan memori jika kita menghitung miliaran jawaban).

Golfscript (28 31 37 )

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

Modifikasi ke gnibblersolusi GolfScript. Saya pikir ini adalah solusi yang berfungsi - diuji dengan [3,2], [4,2], [6,3], dan [9,2] dengan jawaban yang benar. (Saya menggunakan $dan @untuk variabel untuk memperketat ruang di sekitar basekata kunci).

Ada dua masalah dengan gnibblersolusi saat ini.

1. Memeriksa panjang setelah melepas [0] tidak menjamin solusi, karena [1,1,1,1] akan valid untuk input [4,2], meskipun semua 4 bola berada di sel yang sama (1). Jadi saya telah dimodifikasi untuk memeriksa juga bahwa semua digit digunakan, yaitu array berisi 1-2, sehingga setiap sel mengandung setidaknya satu bola.
2. Dalam hal input [4,2], format basis-3 angka 0-27 kurang dari 4 digit, dan paling kiri 0 tidak termasuk. Itu berarti [1,1] dimasukkan sebagai solusi yang valid, meskipun secara teknis sebenarnya [0,0,1,1], yang berarti dua bola pertama tidak ditempatkan di mana pun. Saya perbaiki dengan menambahkan 3 ^ 3 ke setiap entri (umumnya k ^ n-1 ke array entri k ^ n) sehingga entri pertama digeser ke atas untuk memiliki setidaknya n-digit dalam format basis-k, dan yang terakhir entri secara otomatis akan menjadi tidak valid dan tidak akan mempengaruhi solusi (karena digit kedua akan selalu 0).

Edit

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

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

Solusi yang lebih baik! Tidak perlu naik, tambahkan saja semua angka sehingga mereka mulai dengan [1], dan tidak ada digit yang akan hilang (termasuk padding kiri 0's) setelah Anda menentukan digit pertama itu. Solusi ini harus berfungsi dan telah diuji dengan entri yang sama di atas. Ini juga jauh lebih cepat karena kita tidak menambah sebelum mengambil eksponen untuk menghasilkan array (tetapi masih menderita masalah kinerja / memori yang sama untuk input yang lebih besar).

Sunting : Gunakan gnibblergagasan untuk memindahkan penambahan bagian $dalam filter alih-alih sebagai langkah tambahan. (simpan 3 karakter).

05AB1E , 19 byte

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

CATATAN: Ini sangat lambat, dan sudah waktunya habis 12 4. Ini berfungsi sebagaimana dimaksud, meskipun. Akan melihat apakah saya dapat menemukan metode alternatif yang berfungsi untuk semua kasus uji dalam waktu yang wajar. Lihat di bawah untuk versi yang jauh lebih cepat yang menjalankan semua kasus uji dalam waktu kurang dari satu detik.

Cobalah secara online atau verifikasi beberapa kasus uji (yang lebih kecil) .

Penjelasan:

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

Berikut versi yang jauh lebih cepat yang berfungsi untuk semua kasus uji dalam waktu sekitar 0,5 detik pada TIO:

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

Port dari jawaban JavaScript @mellamokb , jadi pastikan untuk menghapusnya!

Cobalah secara online atau verifikasi semua kasus uji .

Penjelasan:

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

CATATAN: Berfungsi untuk kasus tepi 0 0dalam kasus ini (tidak seperti jawaban JavaScript yang saya gunakan untuk porting metode ini), karena Lbuiltin akan membuat daftar [0,1].