Google Code Jam - New Lottery Game I was looking around on the web and I found this Google Code Jam Puzzle. I really liked it so I decided to post it here.


  New Lottery Game
  
  The Lottery is changing! The Lottery used to have a machine to
  generate a random winning number. But due to cheating problems, the
  Lottery has decided to add another machine. The new winning number
  will be the result of the bitwise-AND operation between the two random
  numbers generated by the two machines.
  
  To find the bitwise-AND of X and Y, write them both in binary; then a
  bit in the result in binary has a 1 if the corresponding bits of X and
  Y were both 1, and a 0 otherwise. In most programming languages, the
  bitwise-AND of X and Y is written X&amp;Y.
  
  For example:    The old machine generates the number 7 = 0111.    The
  new machine generates the number 11 = 1011.    The winning number will
  be (7 AND 11) = (0111 AND 1011) = 0011 = 3.
  
  With this measure, the Lottery expects to reduce the cases of
  fraudulent claims, but unfortunately an employee from the Lottery
  company has leaked the following information: the old machine will
  always generate a non-negative integer less than A and the new one
  will always generate a non-negative integer less than B. 
  
  Catalina wants to win this lottery and to give it a try she decided to
  buy all non-negative integers less than K. 
  
  Given A, B and K, Catalina would like to know in how many different
  ways the machines can generate a pair of numbers that will make her a
  winner. 
  
  Could you help her?
  
  Input
  
  The first line of the input gives the number of test cases, T. T lines
  follow, each line with three numbers A B K.
  
  Output
  
  For each test case, output one line containing "Case #x: y", where x
  is the test case number (starting from 1) and y is the number of
  possible pairs that the machines can generate to make Catalina a
  winner.
  
  Limits
  
  1 ≤ T ≤ 100. Small dataset
  
  1 ≤ A ≤ 1000. 1 ≤ B ≤ 1000. 1 ≤ K ≤ 1000. Large dataset
  
  1 ≤ A ≤ 109. 1 ≤ B ≤ 109. 1 ≤ K ≤ 109. Sample

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

  
  In the first test case, these are the 10 possible pairs generated by
  the old and new machine respectively that will make her a winner:
  &lt;0,0>, &lt;0,1>, &lt;0,2>, &lt;0,3>, &lt;1,0>, &lt;1,1>, &lt;1,2>, &lt;1,3>, &lt;2,0> and
  &lt;2,1>. Notice that &lt;0,1> is not the same as &lt;1,0>. Also, although the
  pair &lt;2, 2> could be generated by the machines it wouldn't make
  Catalina win since (2 AND 2) = 2 and she only bought the numbers 0 and
  1.


Here's the link for actual problem: https://code.google.com/codejam/contest/2994486/dashboard#s=p1

This is code-golf, so shortest code wins.
Good Luck
Ruby, 107

I expected this would be a much shorter program.

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


Explanation


The first line of input can be ignored.
$. is the last read line number.
[*0...x] is a quick way to turn the Range into an Array. It uses the splat operator (*). Note that the Range is an exclusive one (... instead of ..).
Array#count takes a block. It will only count the elements for which the block returns a truthy value.