Asp Forum - [QUIZ] Probable Iterations (#141

James Gray

9/28/2007 1:22:00 PM

The three rules of Ruby Quiz:

1. Please do not post any solutions or spoiler discussion for this quiz until
48 hours have passed from the time on this message.

2. Support Ruby Quiz by submitting ideas as often as you can:

http://www.rub...

3. Enjoy!

Suggestion: A [QUIZ] in the subject of emails about the problem helps everyone
on Ruby Talk follow the discussion. Please reply to the original quiz message,
if you can.

-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=

by Kenneth Kin Lum

You just did some probability calculations, and don't know if the answers are
correct. So you write a program to verify the results. If you have eight dice,
and throw them all at once, what is the probability that there are AT LEAST
three fives? Try to write a program that find out the "number of desirable
outcomes" / "number of possible outcomes" by iterating through all the possible
outcomes of the dice throw.

It has a verbose mode to see that the program is running correctly (for the case
2 dice, at least 1 five):

C:\rails\depot>ruby dice.rb -v 2 1
1 [1,1]
2 [2,1]
3 [3,1]
4 [4,1]
5 [5,1] <==
6 [6,1]
7 [1,2]
8 [2,2]
9 [3,2]
10 [4,2]
11 [5,2] <==
12 [6,2]
13 [1,3]
14 [2,3]
15 [3,3]
16 [4,3]
17 [5,3] <==
18 [6,3]
19 [1,4]
20 [2,4]
21 [3,4]
22 [4,4]
23 [5,4] <==
24 [6,4]
25 [1,5] <==
26 [2,5] <==
27 [3,5] <==
28 [4,5] <==
29 [5,5] <==
30 [6,5] <==
31 [1,6]
32 [2,6]
33 [3,6]
34 [4,6]
35 [5,6] <==
36 [6,6]

Number of desirable outcomes is 11
Number of possible outcomes is 36

Probability is 0.3055555555555556

C:\rails\depot>ruby dice.rb 8 3

Number of desirable outcomes is 226491
Number of possible outcomes is 1679616

Probability is 0.1348468935756745

It also has a "sample mode" to print out the samples every 50,000 times in the
loop:

C:\rails\depot>ruby dice.rb -s 8 3
1 [1,1,1,1,1,1,1,1]
50001 [3,6,3,4,3,1,2,1]
100001 [5,5,6,1,6,1,3,1]
150001 [1,5,3,5,2,2,4,1]
200001 [3,4,6,2,5,2,5,1]
250001 [5,3,3,6,1,3,6,1]
300001 [1,3,6,3,4,3,1,2]
350001 [3,2,3,1,1,4,2,2]
400001 [5,1,6,4,3,4,3,2]
450001 [1,1,3,2,6,4,4,2]
500001 [3,6,5,5,2,5,5,2] <==
550001 [5,5,2,3,5,5,6,2] <==
600001 [1,5,5,6,1,6,1,3]
650001 [3,4,2,4,4,6,2,3]
700001 [5,3,5,1,1,1,4,3]
750001 [1,3,2,5,3,1,5,3]
800001 [3,2,5,2,6,1,6,3]
850001 [5,1,2,6,2,2,1,4]
900001 [1,1,5,3,5,2,2,4]
950001 [3,6,1,1,2,3,3,4]
1000001 [5,5,4,4,4,3,4,4]
1050001 [1,5,1,2,1,4,5,4]
1100001 [3,4,4,5,3,4,6,4]
1150001 [5,3,1,3,6,4,1,5]
1200001 [1,3,4,6,2,5,2,5]
1250001 [3,2,1,4,5,5,3,5] <==
1300001 [5,1,4,1,2,6,4,5]
1350001 [1,1,1,5,4,6,5,5] <==
1400001 [3,6,3,2,1,1,1,6]
1450001 [5,5,6,5,3,1,2,6] <==
1500001 [1,5,3,3,6,1,3,6]
1550001 [3,4,6,6,2,2,4,6]
1600001 [5,3,3,4,5,2,5,6] <==
1650001 [1,3,6,1,2,3,6,6]

Number of desirable outcomes is 226491
Number of possible outcomes is 1679616

Probability is 0.1348468935756745

16 Answers

Jesús Gabriel y Galán

9/30/2007 1:33:00 PM

> by Kenneth Kin Lum
>
> You just did some probability calculations, and don't know if the answers are
> correct. So you write a program to verify the results. If you have eight dice,
> and throw them all at once, what is the probability that there are AT LEAST
> three fives? Try to write a program that find out the "number of desirable
> outcomes" / "number of possible outcomes" by iterating through all the possible
> outcomes of the dice throw.

Hi,

I wanted to look a little into parsing command line options and
arguments, so I took the opportunity to try Ara's "main" gem (gem
install main). I have a question about the usage of main at the end of
the post, if somebody can help me out, that'd be great.
In addition to the requirements I also added the possibility to pass
another option (--type or -t) with the type of comparison you want to
perform: at_least, exactly, no_more_than, less_than or more_than. It
defaults to at_least. Here it is:

# quiz141.rb
# 29 September 2007
#

require 'main'

$compare_types = {"at_least" => :>=, "exactly" => :==, "no_more_than" => :<=,
"more_than" => :>, "less_than" => :<}

main {
argument('dice') {
cast :int
description "number of dice to throw"
}
argument('num') {
cast :int
description "number of fives to count in each throw"
}
option('verbose', 'v') {
description "verbose mode: will show all combinations"
}
option('samples', 's') {
description "sample mode: will show 1 combination every 50000"
}
option('type', 't') {
argument :required
defaults "at_least"
validate {|type| $compare_types.keys.include?(type)}
description "Type of comparison. Possible values: " +
$compare_types.keys.join(",")
}

def run
verbose = params[:verbose].given?
samples = params[:samples].given?
dice = params[:dice].value
num = params[:num].value
type = params[:type].value
method = $compare_types[type]
puts "Checking #{type} #{num} fives throwing #{dice} dice"
puts "Verbose mode" if verbose
puts "Samples mode" if samples
current = Array.new(dice) {1}
current[0] = 0 # to start the loop incrementing the first element
total_matches = 0
total_iter = 0
begin
total_iter += 1
(0...dice).each do |i|
if (current[i] < 6)
current[i] += 1
break
else
current[i] = 1
end
end
match = current.select {|x| x == 5}.size.send(method, num)
total_matches += 1 if match
if (verbose || (samples && total_iter%50000 == 1))
print total_iter, " ", current.inspect
puts "#{match ?'<==':''}"
end
end while current.any?{|x|x != 6}
puts "Number of desirable outcomes: #{total_matches}"
puts "Number of possible outcomes: #{total_iter}"
puts "Probabilty is #{total_matches.to_f/total_iter.to_f}"
end
}

Here's the output with 2 1 for each type of comparison.

$ ruby -rubygems quiz141.rb --type less_than 2 1
Checking less_than 1 fives throwing 2 dice
Number of desirable outcomes: 25
Number of possible outcomes: 36
Probabilty is 0.694444444444444

$ ruby -rubygems quiz141.rb --type at_least 2 1
Checking at_least 1 fives throwing 2 dice
Number of desirable outcomes: 11
Number of possible outcomes: 36
Probabilty is 0.305555555555556

$ ruby -rubygems quiz141.rb --type exactly 2 1
Checking exactly 1 fives throwing 2 dice
Number of desirable outcomes: 10
Number of possible outcomes: 36
Probabilty is 0.277777777777778

$ ruby -rubygems quiz141.rb --type no_more_than 2 1
Checking no_more_than 1 fives throwing 2 dice
Number of desirable outcomes: 35
Number of possible outcomes: 36
Probabilty is 0.972222222222222

$ ruby -rubygems quiz141.rb --type more_than 2 1
Checking more_than 1 fives throwing 2 dice
Number of desirable outcomes: 1
Number of possible outcomes: 36
Probabilty is 0.0277777777777778

My question about main is the following: if you check my code, I have
a variable ($compare_types) I need to use both in the validate block
for an option and in the run method. Is there a better way to achieve
this than a global variable?

Regards,

Jesus.

Jesse Merriman

9/30/2007 1:48:00 PM

Content-Type: Multipart/Mixed;
boundary="Boundary-00=_ei6/G7Mh/wSUl6w"
My solution isn't very fast, but gets the job done. To generate all possible
rolls, it runs through 0...6**num_dice, gets the string in base-6, and splits
it up.

--
Jesse Merriman
jessemerriman@warpmail.net
http://www.jessemer...

Ilmari Heikkinen

9/30/2007 2:02:00 PM

On 9/28/07, Ruby Quiz <james@grayproductions.net> wrote:

> You just did some probability calculations, and don't know if the answers are
> correct. So you write a program to verify the results. If you have eight dice,
> and throw them all at once, what is the probability that there are AT LEAST
> three fives? Try to write a program that find out the "number of desirable
> outcomes" / "number of possible outcomes" by iterating through all the possible
> outcomes of the dice throw.

Iterates in base-6 and uses String#count for counting fives.

verbose = ARGV.delete("-v")
sample = ARGV.delete("-s")
dice, amt_of_fives = ARGV[0,2].map{|i| i.to_i }

num_outcomes = 6**dice
des_outcomes = 0
idx = 1
(0...num_outcomes).each{|oc|
s = oc.to_s(6)
hits = s.count("4")
hit = hits >= amt_of_fives
des_outcomes += 1 if hit
if verbose or (sample and idx % 50000 == 1)
# HA ha fhgh (justify, add one, reverse and
# make into an array string to match kenneth's output)
puts "#{idx} [#{s.rjust(dice,"0").tr!("012345","123456").reverse!.
split(//).join(",")}]#{hit ? " <==" : nil}"
end
idx += 1
}

puts
puts "Number of desirable outcomes is #{des_outcomes}"
puts "Number of possible outcomes is #{num_outcomes}"
puts
puts "Probability is #{des_outcomes.to_f / num_outcomes}"

--
Ilmari Heikkinen
http://fhtr.bl...

Morton Goldberg

9/30/2007 3:13:00 PM

On Sep 30, 2007, at 9:32 AM, Jesús Gabriel y Galán wrote:

> $compare_types = {"at_least" => :>=, "exactly" => :==,
> "no_more_than" => :<=,
> "more_than" => :>, "less_than" => :<}

<snip>

> My question about main is the following: if you check my code, I have
> a variable ($compare_types) I need to use both in the validate block
> for an option and in the run method. Is there a better way to achieve
> this than a global variable?

I suggest making it a constant.

COMPARE_TYPES = { "at_least" => :>=, "exactly" => :==, "no_more_than"
=> :<=,
"more_than" => :>, "less_than" => :< }

Regards, Morton

Eugene Kalenkovich

9/30/2007 4:44:00 PM

My solution. No match counting, + handles 'ruby dice.rb 1000 1'

>---------------------------------------------------

require 'bigdecimal'
require 'bigdecimal/util'

def f(n) (1..n).inject(1){|a,i|a*=i} end
def perm(m,n) f(m)/(f(n)*f(m-n)) end
def fives(m,n) (0..m-n).inject(0) {|s,i| s+=5**i * perm(m,i)} end

case ARGV[0]
when '-v'
step=1
ARGV.shift
when '-s'
step=50_000
ARGV.shift
end
num=ARGV[0].to_i
min=ARGV[1].to_i

all=6**num
good=fives(num,min)

if (step)
zipper=Array.new(num,1)
0.step(all-1,step) do |i|
s=i.to_s(6).tr('012345','123456').rjust(num,'1').gsub(/(\d)(?=\d)/,'\1,').reverse
flag = (s.count('5')>=min) ? '<==' : ''
puts "%10s [%#{num*2-1}s] %4s" % [i+1,s,flag]
end
end

if all > Float::MAX.to_d
prob=good.to_s.to_d/all
else
prob=good.to_f/all
end

puts
puts "Number of desirable outcomes is #{good}"
puts "Number of possible outcomes is #{all}"
puts
puts "Probability is #{prob}"

Stephen Kyle

9/30/2007 4:45:00 PM

Hi,
I doubt my method of finding the iterations is particularly efficient:

I just have a function, nextLogicalRoll, which returns the next
"logical" set of dice, when you give it a set of dice, so it'll return
[1,2,1], if given [1,1,3]. I give it the first logical set, an array
of as-many-dice-as-we're-using 1s, and then watch for when it returns
as-many-dice-as-we're-using 6s.

The function has a "seek" pointer that points at the end of the array,
and if the number at that index isn't 6, it increases it by one, and
returns that array. Else it changes the 6 to a 1, and the pointer
moves one position towards the start of the array, this is repeated
until a number that isn't 6 is found at the array, this number is
increased by one, and the array is returned.

I quite like the way I do array finding, and although it's no doubt a
computational nightmare, on the order of O(n^10000) or something, it's
quite pretty. It just creates a string representing what we're looking
for; for instance, if we're looking for two fives, it'll be "55", and
then we sort the array representing the dice roll, convert it to a
string, and see if our "desired" string is a subset of the string.

That's all from me, this is my first time, be kind. :P

- Steve

Code:

$desired_count = 0
$possible_count = 0

# argument "parsing" fun, delicate
verbose = true if ARGV[0] == "-v"
sample = true if ARGV[0] == "-s"
if sample or verbose
dice = ARGV[1] if ARGV[1] =~ /\d+/
desired = ARGV[2] if ARGV[2] =~ /\d+/
hunted = ARGV[3] if ARGV[3] =~ /\d+/
else
dice = ARGV[0] if ARGV[0] =~ /\d+/
desired = ARGV[1] if ARGV[1] =~ /\d+/
hunted = ARGV[2] if ARGV[2] =~ /\d+/
end
dice = dice.to_i
desired = desired.to_i

def nextLogicalRoll(array) # find the next "logical" set of dice
seek = (array.length-1)
if array[seek] != 6
array[seek] += 1
else
while array[seek] == 6 do
array[seek] = 1
seek -= 1
end
array[seek] += 1
end
return array
end

def printArray(array) # reinventing the wheel, no doubt.
print "["
values = array * ","
print values
print "]"
end

def check(array,desired,hunted)
match = hunted.to_s * desired
return array.sort.to_s.include?(match)
end

set = Array.new(dice).fill(1)
finale = Array.new(dice).fill(6)
loop do
$possible_count += 1
print "#{$possible_count}. " if verbose or (sample and
$possible_count % 50000 == 1)
printArray(set) if verbose or (sample and $possible_count % 50000 == 1)
if check(set,desired,hunted)
$desired_count += 1
print " <==" if verbose or (sample and $possible_count
% 50000 == 1)
end
puts if verbose or (sample and $possible_count % 50000 == 1)
break unless set != finale
nextLogicalRoll(set)
end

puts
puts "Number of desirable outcomes is #{$desired_count}"
puts "Number of possible outcomes is #{$possible_count}"
puts
probability = $desired_count.to_f / $possible_count.to_f
puts "Probability is #{probability}"

On 28/09/2007, Ruby Quiz <james@grayproductions.net> wrote:
> The three rules of Ruby Quiz:
>
> 1. Please do not post any solutions or spoiler discussion for this quiz until
> 48 hours have passed from the time on this message.
>
> 2. Support Ruby Quiz by submitting ideas as often as you can:
>
> http://www.rub...
>
> 3. Enjoy!
>
> Suggestion: A [QUIZ] in the subject of emails about the problem helps everyone
> on Ruby Talk follow the discussion. Please reply to the original quiz message,
> if you can.
>
> -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
>
> by Kenneth Kin Lum
>
> You just did some probability calculations, and don't know if the answers are
> correct. So you write a program to verify the results. If you have eight dice,
> and throw them all at once, what is the probability that there are AT LEAST
> three fives? Try to write a program that find out the "number of desirable
> outcomes" / "number of possible outcomes" by iterating through all the possible
> outcomes of the dice throw.
>
> It has a verbose mode to see that the program is running correctly (for the case
> 2 dice, at least 1 five):
>
> C:\rails\depot>ruby dice.rb -v 2 1
> 1 [1,1]
> 2 [2,1]
> 3 [3,1]
> 4 [4,1]
> 5 [5,1] <==
> 6 [6,1]
> 7 [1,2]
> 8 [2,2]
> 9 [3,2]
> 10 [4,2]
> 11 [5,2] <==
> 12 [6,2]
> 13 [1,3]
> 14 [2,3]
> 15 [3,3]
> 16 [4,3]
> 17 [5,3] <==
> 18 [6,3]
> 19 [1,4]
> 20 [2,4]
> 21 [3,4]
> 22 [4,4]
> 23 [5,4] <==
> 24 [6,4]
> 25 [1,5] <==
> 26 [2,5] <==
> 27 [3,5] <==
> 28 [4,5] <==
> 29 [5,5] <==
> 30 [6,5] <==
> 31 [1,6]
> 32 [2,6]
> 33 [3,6]
> 34 [4,6]
> 35 [5,6] <==
> 36 [6,6]
>
> Number of desirable outcomes is 11
> Number of possible outcomes is 36
>
> Probability is 0.3055555555555556
>
> C:\rails\depot>ruby dice.rb 8 3
>
> Number of desirable outcomes is 226491
> Number of possible outcomes is 1679616
>
> Probability is 0.1348468935756745
>
> It also has a "sample mode" to print out the samples every 50,000 times in the
> loop:
>
> C:\rails\depot>ruby dice.rb -s 8 3
> 1 [1,1,1,1,1,1,1,1]
> 50001 [3,6,3,4,3,1,2,1]
> 100001 [5,5,6,1,6,1,3,1]
> 150001 [1,5,3,5,2,2,4,1]
> 200001 [3,4,6,2,5,2,5,1]
> 250001 [5,3,3,6,1,3,6,1]
> 300001 [1,3,6,3,4,3,1,2]
> 350001 [3,2,3,1,1,4,2,2]
> 400001 [5,1,6,4,3,4,3,2]
> 450001 [1,1,3,2,6,4,4,2]
> 500001 [3,6,5,5,2,5,5,2] <==
> 550001 [5,5,2,3,5,5,6,2] <==
> 600001 [1,5,5,6,1,6,1,3]
> 650001 [3,4,2,4,4,6,2,3]
> 700001 [5,3,5,1,1,1,4,3]
> 750001 [1,3,2,5,3,1,5,3]
> 800001 [3,2,5,2,6,1,6,3]
> 850001 [5,1,2,6,2,2,1,4]
> 900001 [1,1,5,3,5,2,2,4]
> 950001 [3,6,1,1,2,3,3,4]
> 1000001 [5,5,4,4,4,3,4,4]
> 1050001 [1,5,1,2,1,4,5,4]
> 1100001 [3,4,4,5,3,4,6,4]
> 1150001 [5,3,1,3,6,4,1,5]
> 1200001 [1,3,4,6,2,5,2,5]
> 1250001 [3,2,1,4,5,5,3,5] <==
> 1300001 [5,1,4,1,2,6,4,5]
> 1350001 [1,1,1,5,4,6,5,5] <==
> 1400001 [3,6,3,2,1,1,1,6]
> 1450001 [5,5,6,5,3,1,2,6] <==
> 1500001 [1,5,3,3,6,1,3,6]
> 1550001 [3,4,6,6,2,2,4,6]
> 1600001 [5,3,3,4,5,2,5,6] <==
> 1650001 [1,3,6,1,2,3,6,6]
>
> Number of desirable outcomes is 226491
> Number of possible outcomes is 1679616
>
> Probability is 0.1348468935756745
>
>

Jesús Gabriel y Galán

9/30/2007 5:29:00 PM

On 9/30/07, Morton Goldberg <m_goldberg@ameritech.net> wrote:
> On Sep 30, 2007, at 9:32 AM, Jesús Gabriel y Galán wrote:
>
> > $compare_types = {"at_least" => :>=, "exactly" => :==,
> > "no_more_than" => :<=,
> > "more_than" => :>, "less_than" => :<}
>
> <snip>
>
> > My question about main is the following: if you check my code, I have
> > a variable ($compare_types) I need to use both in the validate block
> > for an option and in the run method. Is there a better way to achieve
> > this than a global variable?
>
> I suggest making it a constant.
>
> COMPARE_TYPES = { "at_least" => :>=, "exactly" => :==, "no_more_than"
> => :<=,
> "more_than" => :>, "less_than" => :< }
>
> Regards, Morton

Thanks for the tip. Didn't realize the scope of constants :-)
This looks much better to me.

Jesus.

Carl Porth

9/30/2007 8:04:00 PM

Nothing too shocking:

http://pastie.caboo...

Carl

On Sep 28, 6:21 am, Ruby Quiz <ja...@grayproductions.net> wrote:
> The three rules of Ruby Quiz:
>
> 1. Please do not post any solutions or spoiler discussion for this quiz until
> 48 hours have passed from the time on this message.
>
> 2. Support Ruby Quiz by submitting ideas as often as you can:
>
> http://www.rub...
>
> 3. Enjoy!
>
> Suggestion: A [QUIZ] in the subject of emails about the problem helps everyone
> on Ruby Talk follow the discussion. Please reply to the original quiz message,
> if you can.
>
> -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- =-=-=
>
> by Kenneth Kin Lum
>
> You just did some probability calculations, and don't know if the answers are
> correct. So you write a program to verify the results. If you have eight dice,
> and throw them all at once, what is the probability that there are AT LEAST
> three fives? Try to write a program that find out the "number of desirable
> outcomes" / "number of possible outcomes" by iterating through all the possible
> outcomes of the dice throw.
>
> It has a verbose mode to see that the program is running correctly (for the case
> 2 dice, at least 1 five):
>
> C:\rails\depot>ruby dice.rb -v 2 1
> 1 [1,1]
> 2 [2,1]
> 3 [3,1]
> 4 [4,1]
> 5 [5,1] <==
> 6 [6,1]
> 7 [1,2]
> 8 [2,2]
> 9 [3,2]
> 10 [4,2]
> 11 [5,2] <==
> 12 [6,2]
> 13 [1,3]
> 14 [2,3]
> 15 [3,3]
> 16 [4,3]
> 17 [5,3] <==
> 18 [6,3]
> 19 [1,4]
> 20 [2,4]
> 21 [3,4]
> 22 [4,4]
> 23 [5,4] <==
> 24 [6,4]
> 25 [1,5] <==
> 26 [2,5] <==
> 27 [3,5] <==
> 28 [4,5] <==
> 29 [5,5] <==
> 30 [6,5] <==
> 31 [1,6]
> 32 [2,6]
> 33 [3,6]
> 34 [4,6]
> 35 [5,6] <==
> 36 [6,6]
>
> Number of desirable outcomes is 11
> Number of possible outcomes is 36
>
> Probability is 0.3055555555555556
>
> C:\rails\depot>ruby dice.rb 8 3
>
> Number of desirable outcomes is 226491
> Number of possible outcomes is 1679616
>
> Probability is 0.1348468935756745
>
> It also has a "sample mode" to print out the samples every 50,000 times in the
> loop:
>
> C:\rails\depot>ruby dice.rb -s 8 3
> 1 [1,1,1,1,1,1,1,1]
> 50001 [3,6,3,4,3,1,2,1]
> 100001 [5,5,6,1,6,1,3,1]
> 150001 [1,5,3,5,2,2,4,1]
> 200001 [3,4,6,2,5,2,5,1]
> 250001 [5,3,3,6,1,3,6,1]
> 300001 [1,3,6,3,4,3,1,2]
> 350001 [3,2,3,1,1,4,2,2]
> 400001 [5,1,6,4,3,4,3,2]
> 450001 [1,1,3,2,6,4,4,2]
> 500001 [3,6,5,5,2,5,5,2] <==
> 550001 [5,5,2,3,5,5,6,2] <==
> 600001 [1,5,5,6,1,6,1,3]
> 650001 [3,4,2,4,4,6,2,3]
> 700001 [5,3,5,1,1,1,4,3]
> 750001 [1,3,2,5,3,1,5,3]
> 800001 [3,2,5,2,6,1,6,3]
> 850001 [5,1,2,6,2,2,1,4]
> 900001 [1,1,5,3,5,2,2,4]
> 950001 [3,6,1,1,2,3,3,4]
> 1000001 [5,5,4,4,4,3,4,4]
> 1050001 [1,5,1,2,1,4,5,4]
> 1100001 [3,4,4,5,3,4,6,4]
> 1150001 [5,3,1,3,6,4,1,5]
> 1200001 [1,3,4,6,2,5,2,5]
> 1250001 [3,2,1,4,5,5,3,5] <==
> 1300001 [5,1,4,1,2,6,4,5]
> 1350001 [1,1,1,5,4,6,5,5] <==
> 1400001 [3,6,3,2,1,1,1,6]
> 1450001 [5,5,6,5,3,1,2,6] <==
> 1500001 [1,5,3,3,6,1,3,6]
> 1550001 [3,4,6,6,2,2,4,6]
> 1600001 [5,3,3,4,5,2,5,6] <==
> 1650001 [1,3,6,1,2,3,6,6]
>
> Number of desirable outcomes is 226491
> Number of possible outcomes is 1679616
>
> Probability is 0.1348468935756745

come

10/1/2007 12:28:00 PM

Hi,

Here is my quick solution :

dice.rb :

dice, n = ARGV.grep(/\d+/)
verbose = true if ARGV.include?("-v")
sample = true if ARGV.include?("-s")

max=("5"*dice.to_i).to_i(6)
n=n.to_i
resultat= (0..max).inject(0) do |sum,i|
output = verbose || (sample && i % 50_000 == 0)
print i+1,"\t",("%#{dice}s" % i.to_s(6)).split(//).map{|e| e.to_i
+1}.inspect if output
if i.to_s(6).scan(/4/).size > n-1
puts "<=" if output
sum+1
else
puts "" if output
sum
end
end

puts "Number of desirable outcomes is #{resultat}"
puts "Number of possible outcomes is #{max+1}"
puts Float(resultat) / Float(max+1)

Eric DUMINIL

10/2/2007 7:00:00 AM

Hi,

my solution came a bit too late and had nothing to offer in comparison
to the previous answers, so here is my slightly modified cheating
solution (I do not check anything, I actually use counting
calculations....)

##################################################################
n=8 #Dice number
d=3 #At least d fives
f=50000 #Display step (0: never, 1:always, f:every f lines)

class Fixnum
def fact
return 1 if self<2
self*(self-1).fact
end

def cnp(p)
self.fact/(p.fact*(self-p).fact)
end
end

@desirable=(d..n).inject(0){|mem,p| mem+n.cnp(p)*5**(n-p)}

N=6**n
(0...N).step(f){|outcome_id|
outcome=outcome_id.to_s(6).rjust(n,'0').split('').collect{|dice| dice.to_i+1}
print "\n#{(outcome_id+1).to_s.rjust(n)} : #{outcome.inspect}"
print " <==" unless outcome.select{|dice| dice==5}.size<d
} unless f==0

puts "\nNumber of desirable outcomes is #{@desirable}"
puts "Number of possible outcomes is #{N}"
puts "Probability is #{@desirable.to_f/N}"
##################################################################

time ruby dice.rb

1 : [1, 1, 1, 1, 1, 1, 1, 1]
50001 : [1, 2, 1, 3, 4, 3, 6, 3]
100001 : [1, 3, 1, 6, 1, 6, 5, 5]
150001 : [1, 4, 2, 2, 5, 3, 5, 1]
200001 : [1, 5, 2, 5, 2, 6, 4, 3]
250001 : [1, 6, 3, 1, 6, 3, 3, 5]
300001 : [2, 1, 3, 4, 3, 6, 3, 1]
350001 : [2, 2, 4, 1, 1, 3, 2, 3]
400001 : [2, 3, 4, 3, 4, 6, 1, 5]
450001 : [2, 4, 4, 6, 2, 3, 1, 1]
500001 : [2, 5, 5, 2, 5, 5, 6, 3] <==
550001 : [2, 6, 5, 5, 3, 2, 5, 5] <==
600001 : [3, 1, 6, 1, 6, 5, 5, 1]
650001 : [3, 2, 6, 4, 4, 2, 4, 3]
700001 : [3, 4, 1, 1, 1, 5, 3, 5]
750001 : [3, 5, 1, 3, 5, 2, 3, 1]
800001 : [3, 6, 1, 6, 2, 5, 2, 3]
850001 : [4, 1, 2, 2, 6, 2, 1, 5]
900001 : [4, 2, 2, 5, 3, 5, 1, 1]
950001 : [4, 3, 3, 2, 1, 1, 6, 3]
1000001 : [4, 4, 3, 4, 4, 4, 5, 5]
1050001 : [4, 5, 4, 1, 2, 1, 5, 1]
1100001 : [4, 6, 4, 3, 5, 4, 4, 3]
1150001 : [5, 1, 4, 6, 3, 1, 3, 5]
1200001 : [5, 2, 5, 2, 6, 4, 3, 1]
1250001 : [5, 3, 5, 5, 4, 1, 2, 3] <==
1300001 : [5, 4, 6, 2, 1, 4, 1, 5]
1350001 : [5, 5, 6, 4, 5, 1, 1, 1] <==
1400001 : [6, 1, 1, 1, 2, 3, 6, 3]
1450001 : [6, 2, 1, 3, 5, 6, 5, 5] <==
1500001 : [6, 3, 1, 6, 3, 3, 5, 1]
1550001 : [6, 4, 2, 2, 6, 6, 4, 3]
1600001 : [6, 5, 2, 5, 4, 3, 3, 5] <==
1650001 : [6, 6, 3, 2, 1, 6, 3, 1]
Number of desirable outcomes is 226491
Number of possible outcomes is 1679616
Probability is 0.134846893575674

real 0m0.010s
user 0m0.000s
sys 0m0.008s

Thanks for the quiz!

On 01/10/2007, come <come.news@free.fr> wrote:
> Hi,
>
> Here is my quick solution :
>
> dice.rb :
>
> dice, n = ARGV.grep(/\d+/)
> verbose = true if ARGV.include?("-v")
> sample = true if ARGV.include?("-s")
>
> max=("5"*dice.to_i).to_i(6)
> n=n.to_i
> resultat= (0..max).inject(0) do |sum,i|
> output = verbose || (sample && i % 50_000 == 0)
> print i+1,"\t",("%#{dice}s" % i.to_s(6)).split(//).map{|e| e.to_i
> +1}.inspect if output
> if i.to_s(6).scan(/4/).size > n-1
> puts "<=" if output
> sum+1
> else
> puts "" if output
> sum
> end
> end
>
> puts "Number of desirable outcomes is #{resultat}"
> puts "Number of possible outcomes is #{max+1}"
> puts Float(resultat) / Float(max+1)
>
>
>
>
>
>
>

comp.lang.ruby

[QUIZ] Probable Iterations (#141

James Gray

Jesús Gabriel y Galán

Jesse Merriman

Ilmari Heikkinen

Morton Goldberg

Eugene Kalenkovich

Stephen Kyle

Jesús Gabriel y Galán

Carl Porth

come

Eric DUMINIL

x Login to ForumsZone