Ruby Split number in ones or halves - ruby

Question

I like to split up a score in an array of n positions.
Lets say my score is 11 and the array is of size 12.
Then I like to have some array that is filled with for example 11 ones or 10 ones and 2 halves (0.5). In the end it should sum to 11.
Then the possible scores are:
size = 12
possible_scores = (0..size).step(0.5).to_a
I can create an array of 12 positions:
scores = Array.new(size) {0}
I could pick a random value from the following possible values:
[0, 0.5, 1].sample
I'm looking for an efficient way to retrieve a random array without having lots of state variables if possible. I already tried to do this in a while loop:
while score < 0
and reduce the value of score with the random value and keep track of the array positions that are set. But it became quite a messy piece of code.
Any ideas how to solve this? Thanks!
Edit:
For this example I want an array that sums up to 11. So any one of
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0]
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0.5, 0.5]
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1]
Or whatever combination that sums up to 11.

Answer 1

Parameters and variables
Given:
tot, the desired total, an integer or an odd multiple of 0.5; and
size, the total number of 0's, 0.5's and 1's that total tot, with the requirement that size >= tot.
we define three variables:
n0 equals the number of zeroes;
n0pt5_pairs equals the number of pairs of 0.5's; and
n1 equals the number of ones.
Case 1: tot is an integer
We require:
0 <= n0pt5_pairs <= [tot, size-tot].min
Note that because n1 = tot - n0pt5_pairs, 2 * n0pt5_pairs + n1 = n0pt5_pairs + tot > size if n0pt5_pairs > size-tot. That is, the total number of 0.5's and ones exceeds size if the number of 0.5 pairs exceeds size-tot.
Given a value for n0pt5_pairs that satisfies the above requirement, n0 and n1 are determined:
n1 = tot - n0pt5_pairs
n0 = size - 2*n0pt5_pairs - n1
= size - tot - n0pt5_pairs
We can therefore randomly select a random triple [n0, 2*n0pt5_pairs, n1] as follows:
def random_combo(size, tot)
n0pt5_pairs = rand(1+[tot, size-tot].min)
[size-tot-n0pt5_pairs, 2*n0pt5_pairs, tot-n0pt5_pairs]
end
For example:
arr = random_combo(17, 11)
#=> [3, 6, 8]
This is used to generate the array
arr1 = [*[0]*arr[0], *[0.5]*arr[1], *[1]*arr[2]]
#=> [0, 0, 0, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 1, 1, 1, 1, 1, 1, 1, 1]
which we shuffle:
arr1.shuffle
#=> [1, 0, 0.5, 1, 0.5, 0, 1, 1, 0, 1, 1, 1, 0.5, 0.5, 1, 0.5, 0.5]
Note arr1.size #=> 17 and arr.sum #=> 11.
Case 2: tot is a multiple of 0.5
If
tot = n + 0.5
where n is an integer, every combination of 0's, 0.5's and 1's will have at least one 0.5. We therefore can compute the number of 0's and 1's, together with the number of 0.5's in excess of one. To do that we simply reduce tot by 0.5 (making it equal to an integer) and size by one, use generate_for_integer to solve that problem, then for each three-element array returned by that method increase the number of 0.5's by one.
def generate(size, tot)
return nil if size.zero?
is_int = (tot == tot.floor)
tot = tot.floor
size -= 1 unless is_int
n0pt5_pairs = rand(1+[tot, size-tot].min)
[*[0]*(size-tot-n0pt5_pairs), *[0.5]*(2*n0pt5_pairs + (is_int ? 0 : 1)),
*[1]*(tot-n0pt5_pairs)].
shuffle
end
ge = generate(17, 10)
#=> [0, 1, 0, 1, 0.5, 0.5, 0, 0.5, 0.5, 1, 1, 1, 1, 0.5, 0.5, 0.5, 0.5]
ge.size #=> 17
ge.sum #=> 10.0
go = generate(17, 10.5)
#=> [0.5, 0.5, 0.5, 1, 0, 0.5, 0.5, 1, 1, 0.5, 1, 1, 0.5, 1, 0.5, 0.5, 0]
go.size #=> 17
go.sum #=> 10.5

Answer 2

Ruby provides all you require here, no need to write any algorithmic code. Array#repeated_combination is your friend here:
[0, 0.5, 1].
repeated_combination(12). # 91 unique variant
to_a. # unfortunately it cannot be lazy
shuffle. # to randomize array outcome
detect { |a| a.sum == 11 }.
shuffle # to randomize numbers inside array
#⇒ [0.5, 0.5, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
Sidenote: one might avoid the necessity to shuffle twice (both array of generated arrays and the resulting array) by using Array#repeated_permutation, but this would drastically increase memory load and execution time.

Answer 3

I like Cary Swoveland's answer, but in fact this can be done without generating an array of solutions.
Let's consider a few examples.
Given size = 6 and score = 3, without shuffling, these are the possible outputs (numbered on the left for reasons that will become apparent):
i ones halves zeroes
0│ 1 1 1 0 0 0 3 0 3
1│ 1 1 ½ ½ 0 0 2 2 2
2│ 1 ½ ½ ½ ½ 0 1 4 1
3│ ½ ½ ½ ½ ½ ½ 0 6 0
Given size = 6 and score = 3.5:
i ones halves zeroes
0│ 1 1 1 ½ 0 0 3 1 2
1│ 1 1 ½ ½ ½ 0 2 3 1
2│ 1 ½ ½ ½ ½ ½ 1 5 0
Given size = 11 and score = 4.5:
i ones halves zeroes
0│ 1 1 1 1 ½ 0 0 0 0 0 0 4 1 6
1│ 1 1 1 ½ ½ ½ 0 0 0 0 0 3 3 5
2│ 1 1 ½ ½ ½ ½ ½ 0 0 0 0 2 5 4
3│ 1 ½ ½ ½ ½ ½ ½ ½ 0 0 0 1 7 3
4│ ½ ½ ½ ½ ½ ½ ½ ½ ½ 0 0 0 9 2
Given size = 12 and score = 11:
i ones halves zeroes
0│ 1 1 1 1 1 1 1 1 1 1 1 0 11 0 1
1│ 1 1 1 1 1 1 1 1 1 1 ½ ½ 10 2 0
Can you see the patterns? After a bit of chin-scratching we discover the following facts:
The number of possible outputs 𝑛 for a given size and score is given by:
𝑛 ＝ min(⌊score⌋, size − ⌈score⌉) + 1
As 𝑖 increases, the number of ones decreases. The number of ones is given by:
count(1) ＝ ⌊score⌋ − 𝑖
As 𝑖 increases, the number of halves (½) increases. The number of halves is given by:
count(½) ＝ 2(𝑖 + mod(score, 1))
In other words, it's 2𝑖 + 1 if score has a fractional part, or 2𝑖 otherwise.
As 𝑖 increases, the number of zeroes decreases, given by:
count(0) ＝ size − ⌈score⌉ − 𝑖
With these four facts in mind we can generate any of the 𝑛 possible outputs at random by picking a random 𝑖 where 0 ≤ 𝑖 < 𝑛:
𝑖 = random( [0..𝑛) )
These facts are easy to translate into Ruby code:
n = [score.floor, size - score.ceil].min + 1
i = rand(n)
num_ones = score.floor - i
num_halves = 2 * (i + score % 1)
num_zeroes = (size - score.floor) - i
Now we just need to clean it up a bit and put it in a function that takes size and score as arguments, turns num_ones, num_halves, and num_zeroes into an array of 0s, 0.5s, and 1s, and shuffles the result:
def generate(size, score)
init_ones = score.floor
init_zeroes = size - score.ceil
i = rand([init_ones, init_zeroes].min + 1)
num_ones = init_ones - i
num_halves = 2 * (i + score % 1)
num_zeroes = init_zeroes - i
[ *[1]*num_ones, *[0.5]*num_halves, *[0]*num_zeroes ].shuffle
end
generate(6, 3.5)
# => [0.5, 1, 0, 0.5, 0.5, 1]
You can see the result in action on repl.it: https://repl.it/#jrunning/UnpleasantDimpledLegacysystem (Note that when you run it on repl.it the output appears very slowly. This is only because repl.it executes Ruby code on the server and streams the result back to the browser.)

Answer 4

If I get the point, one possible option could be (brute force)
size = 12
sum = 11
tmp = Array.new(12){1}
loop do
raise 'not possible' if tmp.sum < sum
tmp[tmp.index(1)] = 0.5 if tmp.index(1)
unless tmp.index(1)
tmp[tmp.index(0.5)] = 0
end
break if tmp.sum == sum
end
tmp #=> [0.5, 0.5, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
tmp.sum #=> 11.0