Saya mencari-cari di web dan menemukan Puzzle Jam Google Code ini. Saya sangat menyukainya jadi saya memutuskan untuk mempostingnya di sini.

Game Lotere Baru

Lotere berubah! Lotre dulu memiliki mesin untuk menghasilkan nomor pemenang acak. Tetapi karena masalah kecurangan, Lotere telah memutuskan untuk menambahkan mesin lain. Angka yang menang baru akan menjadi hasil dari operasi bitwise-AND antara dua angka acak yang dihasilkan oleh kedua mesin.

Untuk menemukan bitwise-AND dari X dan Y , tuliskan keduanya dalam biner; maka sedikit dalam hasil dalam biner memiliki 1 jika bit yang sesuai dari X dan Y keduanya 1, dan 0 sebaliknya. Dalam sebagian besar bahasa pemrograman, bitwise-AND dari X dan Y ditulis X&Y .

Sebagai contoh: Mesin lama menghasilkan angka 7 = 0111 . Mesin baru menghasilkan angka 11 = 1011 . Angka yang menang adalah (7 DAN 11) = (0111 DAN 1011) = 0011 = 3 .

Dengan ukuran ini, Lotere berharap dapat mengurangi kasus klaim penipuan, tetapi sayangnya seorang karyawan dari perusahaan Lotere telah membocorkan informasi berikut: mesin lama akan selalu menghasilkan bilangan bulat non-negatif kurang dari A dan yang baru akan selalu menghasilkan bilangan bulat non-negatif kurang dari B .

Catalina ingin menang lotre ini dan untuk mencobanya dia memutuskan untuk membeli semua bilangan bulat non-negatif kurang dari K .

Mengingat A , B dan K , Catalina ingin tahu dalam berapa banyak cara berbeda mesin dapat menghasilkan sepasang angka yang akan membuatnya menjadi pemenang.

Bisakah kamu membantunya?

Memasukkan

Baris pertama input memberikan jumlah kasus uji, baris T. T mengikuti, setiap baris dengan tiga angka AB K.

Keluaran

Untuk setiap test case, output satu baris yang berisi "Case #x: y", di mana x adalah nomor case test (mulai dari 1) dan y adalah jumlah pasangan yang memungkinkan yang dapat dihasilkan mesin untuk membuat Catalina menjadi pemenang.

Batas

1 ≤ T ≤ 100. Kumpulan data kecil

1 ≤ A ≤ 1000. 1 ≤ B ≤ 1000. 1 ≤ K ≤ 1000. Kumpulan data besar

1 ≤ A ≤ 109. 1 ≤ B ≤ 109. 1 ≤ K ≤ 109. Sampel

Input                 Output
5                     Case #1: 10
3 4 2                 Case #2: 16
4 5 2                 Case #3: 52
7 8 5                 Case #4: 2411
45 56 35              Case #5: 14377
103 143 88

Dalam test case pertama, ini adalah 10 pasangan yang mungkin dihasilkan oleh mesin lama dan baru yang akan membuatnya menjadi pemenang: <0,0>, <0,1>, <0,2>, <0,3> , <1,0>, <1,1>, <1,2>, <1,3>, <2,0> dan <2,1>. Perhatikan bahwa <0,1> tidak sama dengan <1,0>. Juga, meskipun pasangan <2, 2> dapat dihasilkan oleh mesin, itu tidak akan membuat Catalina menang sejak (2 DAN 2) = 2 dan dia hanya membeli angka 0 dan 1.

Inilah tautan untuk masalah aktual: https://code.google.com/codejam/contest/2994486/dashboard#s=p1

Ini kode-golf, jadi kode terpendek menang. Semoga berhasil

Ruby, 107

Saya berharap ini akan menjadi program yang jauh lebih pendek.

gets
loop{a,b,k=gets.split.map &:to_i
puts"Case ##{$.-1}: #{[*0...a].product([*0...b]).count{|x,y|x&y<k}}"}

Penjelasan

• Baris input pertama dapat diabaikan.
• $. adalah nomor baris yang terakhir dibaca.
• [*0...x]adalah cara cepat untuk mengubah Rangemenjadi Array. Ini menggunakan operator percikan ( *). Perhatikan bahwa Rangeini adalah eksklusif ( ...bukan ..).
• Array#countmembutuhkan satu blok. Ini hanya akan menghitung elemen yang bloknya mengembalikan nilai kebenaran.

APL (63)

Ini adalah I / O yang harganya sangat mahal.

↑{a b k←¯1+⍳¨⎕⋄'Case #',(⍕⍵),': ',⍕+/∊k∊⍨a∘.{2⊥∧/⍺⍵⊤⍨10/2}b}¨⍳⎕

Penjelasan:

• {... }¨⍳⎕: baca angka N dari keyboard, dan jalankan fungsi berikut untuk setiap angka dari 1 hingga N.
• a b k←¯1+⍳¨⎕: Membaca tiga angka dari keyboard, menghasilkan daftar dari 0..N-1 untuk masing-masing, dan menyimpan ini dalam a, bdan k.
• a∘.{... }b: untuk setiap kombinasi nilai dari adan b:
  • ⍺⍵⊤⍨10/2: dapatkan representasi biner 10-bit untuk kedua nilai (ini cukup mengingat batasnya)
  • ∧/: dan bersama - sama semua pasangan bit
  • 2⊤: hidupkan kembali menjadi angka
• k∊⍨: untuk masing-masing nilai ini, uji apakah ada di k
• +/: jumlah hasilnya
• 'Case #',(⍕⍵),': ',⍕: menghasilkan string keluaran untuk kasus ini
• ↑: ubah hasilnya menjadi matriks, sehingga setiap string berakhir pada baris terpisah.

Uji:

      ↑{a b k←¯1+⍳¨⎕⋄'Case #',(⍕⍵),': ',⍕+/∊k∊⍨a∘.{2⊥∧/⍺⍵⊤⍨10/2}b}¨⍳⎕
⎕:
      5
⎕:
      3 4 2
⎕:
      4 5 2
⎕:
      7 8 5
⎕:
      45 56 35
⎕:
      103 143 88
Case #1: 10   
Case #2: 16   
Case #3: 52   
Case #4: 2411 
Case #5: 14377

Golfscript - 74 64

Ini solusi Golfscript saya (mungkin bisa ditingkatkan):

n/(;0:m;{[~0:w.{{.2$&3$<w+:w;)}4$*;)0}5$*];'Case #'m):m': 'w n}%

Inilah pseudocode yang saya gunakan untuk ini:

Split string at newlines
Get rid of first element (this is not needed, as I am looping through each element anyway)
Let m=0 (case #)
For each group of 3 numbers A, B, and K:
  Let w=0 (number of winning combinations)
  For(C,0,A-1)
    For(D,0,B-1)
      If (A&B)<K
        Let w=w+1 (one more winning combination)
      End
    End
  End
  Let m=m+1 (case # incremented)
  Output("Case #",m,": ",w,"/n")
End

Mengasumsikan input yang valid.

CJam - 62

Mungkin bisa ditingkatkan; ini hanya port jawaban Golfscript saya.

qN/(;{[~0_{{_2$&3$<V+:V;)}4$*;)0}5$*];"Case #"T):T": "V0:V;N}%

Ruby - 145

Saya masih belajar Ruby, jadi mungkin ada cara yang lebih singkat untuk melakukan ini.

(1..gets.to_i).each{|_|a,b,k=gets.split.map{|x|x.to_i};x=0;(0...k).each{|i|(0...a).each{|j|(0...b).each{|k|x+=1 if j&k==i}}};p"Case ##{_}: #{x}"}

Tidak Disatukan :

( 1 .. gets.to_i ).each{ | _ |
    a, b, k = gets.split.map{ | x | x.to_i }
    x = 0

    ( 0 ... k ).each{ | i |
        ( 0 ... a ).each{ | j |
            ( 0 ... b ).each{ | k |
                x += 1 if j & k == i
            }
        }
    }

    p "Case ##{_}: #{x}"
}

J, 90 (70)

I / O to stdin / stdout, berfungsi sebagai skrip ( 90 ).

,&LF@('Test #'&,)"1@(":@#,{:)\@:}.@:(': '&,"1)@(+/@,@(>`(17 b./&i.)/@|.)&.".;._2)&.stdin''

Input pada stdin, output tersirat dalam REPL (mirip dengan APL, saya percaya) ( 70 ).

'Test #',"1(":@#,{:)\}.': ',"1+/@,@(>`(17 b./&i.)/@|.)&.".;._2 stdin''

Ergh, J tidak pandai persyaratan I / O seperti ini.

Bagi yang penasaran, bagian melakukan pekerjaan berat adalah +/@,@(>`(17 b./&i.)/@|.)&."., yang memecahkan satu baris masalah (mengambil dan mengembalikan string).

CJAM - 57

0li{)"Case #"\':Sl~:K;L\{(2$,{1$&@+\}%~}h;\;{K<},,N4$}\*;

Saya pikir ini bisa bermain golf lebih lanjut.

0                                  acts as a counter for the case #
  li{                              accepts the first line of input as integer/opens block
     )                             iterates counter
      "Case #"\':S                 adds "Case #X: " to stack (though in 4 parts)
       l~:K;L\                     takes next line of input, assign K, add null array
         {
          (2$,                     decrease B and generate list of number <A
           {
            1$&                    Copy the current value of B, do & with current n<A
             @+\                   Add the new possible lottery number to array
           }%~                     loop for each element if the list of numbers <A
         }h                        loop which repeats for all numbers less than B
       ;/;{K<},,                   trim and count the possible numbers less than K
      N4$                          add new line and copy the counter back in place
  }\*                              runs the block T times
;                                  removes the counter so it doesn't print

Keluaran:

Case #1: 10
Case #2: 16
Case #3: 52
Case #4: 2411
Case #5: 14377