Tôi đang tìm kiếm trên web và tôi đã tìm thấy Google Code Jam Puzzle này. Tôi thực sự thích nó vì vậy tôi quyết định đăng nó ở đây.

Trò chơi xổ số mới

Xổ số đang thay đổi! Xổ số đã từng có một máy để tạo ra một số trúng ngẫu nhiên. Nhưng do vấn đề gian lận, Xổ số đã quyết định thêm một máy khác. Số chiến thắng mới sẽ là kết quả của hoạt động bitwise-AND giữa hai số ngẫu nhiên được tạo bởi hai máy.

Để tìm bitwise-AND của X và Y , hãy viết cả hai ở dạng nhị phân; thì một bit trong kết quả trong nhị phân có 1 nếu các bit tương ứng của X và Y đều là 1 và 0 khác. Trong hầu hết các ngôn ngữ lập trình, các Bitwise-AND của X và Y được viết X & Y .

Ví dụ: Máy cũ tạo số 7 = 0111 . Máy mới tạo số 11 = 1011 . Số trúng sẽ là (7 VÀ 11) = (0111 VÀ 1011) = 0011 = 3 .

Với biện pháp này, Xổ số dự kiến ​​sẽ giảm các trường hợp khiếu nại gian lận, nhưng thật không may, một nhân viên từ công ty Xổ số đã rò rỉ thông tin sau: máy cũ sẽ luôn tạo ra một số nguyên không âm hơn A và máy mới sẽ luôn tạo ra một số nguyên không âm nhỏ hơn B .

Catalina muốn giành chiến thắng xổ số này và để cho nó một thử cô quyết định mua tất cả các số nguyên không âm nhỏ hơn K .

Đưa ra A , B và K , Catalina muốn biết có bao nhiêu cách khác nhau mà máy móc có thể tạo ra một cặp số sẽ giúp cô trở thành người chiến thắng.

Bạn có thể giúp cô ấy?

Đầu vào

Dòng đầu tiên của đầu vào cho số trường hợp kiểm tra, các dòng T. T theo sau, mỗi dòng có ba số AB K.

Đầu ra

Đối với mỗi trường hợp thử nghiệm, hãy xuất một dòng chứa "Trường hợp #x: y", trong đó x là số trường hợp thử nghiệm (bắt đầu từ 1) và y là số cặp có thể mà máy có thể tạo để biến Catalina thành người chiến thắng.

Hạn mức

1 ≤ T 100. Tập dữ liệu nhỏ

1 ≤ A ≤ 1000. 1 B 1000. 1 K 1000. Tập dữ liệu lớn

1 ≤ A ≤ 109. 1 B 109. 1 K 109. Mẫu

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

Trong trường hợp thử nghiệm đầu tiên, đây là 10 cặp có thể được tạo bởi máy cũ và máy mới sẽ giúp cô ấy trở thành người chiến thắng: <0,0>, <0,1>, <0,2>, <0,3> , <1,0>, <1,1>, <1,2>, <1,3>, <2,0> và <2,1>. Lưu ý rằng <0,1> không giống với <1,0>. Ngoài ra, mặc dù cặp <2, 2> có thể được tạo ra bởi các máy nhưng điều đó sẽ không khiến Catalina giành chiến thắng vì (2 VÀ 2) = 2 và cô chỉ mua các số 0 và 1.

Đây là liên kết cho sự cố thực tế: https://code.google.com.vn/codejam/contest/2994486/dashboard#s=p1

Đây là mã golf, vì vậy mã ngắn nhất sẽ thắng. Chúc may mắn

Ruby, 107

Tôi dự kiến ​​đây sẽ là một chương trình ngắn hơn nhiều.

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

Giải trình

• Dòng đầu tiên có thể được bỏ qua.
• $. là số dòng đọc cuối cùng.
• [*0...x]là một cách nhanh chóng để biến Rangethành một Array. Nó sử dụng toán tử splat ( *). Lưu ý rằng đó Rangelà một độc quyền ( ...thay vì ..).
• Array#countmất một khối. Nó sẽ chỉ tính các yếu tố mà khối trả về giá trị trung thực.

APL (63)

Đó là I / O có giá rất cao.

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

Giải trình:

• {... }¨⍳⎕: Đọc một số N từ bàn phím và chạy chức năng sau cho mỗi số từ 1 đến N.
• a b k←¯1+⍳¨⎕: Đọc ba số từ bàn phím, tạo ra một danh sách từ 0..n-1 cho mỗi, và lưu trữ tại các a, bvà k.
• a∘.{... }b: cho mỗi kết hợp các giá trị từ avà b:
  • ⍺⍵⊤⍨10/2: lấy biểu diễn nhị phân 10 bit cho cả hai giá trị (điều này là đủ cho các giới hạn)
  • ∧/: và cùng nhau tất cả các cặp bit
  • 2⊤: biến nó trở lại thành một số
• k∊⍨: cho mỗi giá trị này, kiểm tra xem nó có trong k
• +/: tổng hợp kết quả
• 'Case #',(⍕⍵),': ',⍕: tạo chuỗi đầu ra cho trường hợp này
• ↑: biến kết quả thành một ma trận, vì vậy mỗi chuỗi kết thúc trên một dòng riêng biệt.

Kiểm tra:

      ↑{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

Đây là giải pháp Golfscript của tôi (có thể được cải thiện):

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

Đây là mã giả tôi đã sử dụng cho việc này:

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

Giả sử đầu vào hợp lệ.

Camam - 62

Có lẽ có thể được cải thiện; đây chỉ là một cổng của câu trả lời Golfscript của tôi.

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

Hồng ngọc - 145

Tôi vẫn đang học Ruby, nên có lẽ có một cách ngắn hơn để làm điều này.

(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}"}

Ung dung :

( 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, hoạt động như một kịch bản ( 90 ).

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

Đầu vào trên stdin, đầu ra ẩn trong REPL (gần giống với APL, tôi tin) ( 70 ).

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

Ergh, J không giỏi các yêu cầu I / O như thế này.

Đối với người tò mò, phần thực hiện công việc nặng là +/@,@(>`(17 b./&i.)/@|.)&.".giải quyết một dòng duy nhất của vấn đề (lấy và trả về một chuỗi).

CỨU - 57

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

Tôi nghĩ rằng điều này có thể được chơi golf hơn nữa.

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

Đầu ra:

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