Say I have two arrays:
Arr1 = ["1a", "1b", "1c"]
Arr2 = ["2a", "2b", "2c"]
Arr1.zip(Arr2).flatten(1)
# => ["1a", "2a", "1b", "2b", "1c", "2c"]
Arr2.zip(Arr1).flatten(1)
# => ["2a", "1a", "2b", "1b", "2c", "1c"]
# Arr1's order is 50% as important as Arr2's order
Arr1_priority = 0.5
results = []
Arr2.each_with_index do element, index
results << element
if (1.to_f  (index.to_f / results.length.to_f)) <= Arr1_priority
# only push Arr1 item if the iterator is 50% done
results << Arr1.shift
end
end
results
# => ["2a", "2b", "1a", "2c", "1b"]
.5
y axis: percentage of added nodes that are Arr1
x axis: percent completion of Arr2 iteration
100% 

75% 

50%  X X X

25% 

0%  X X

0% 25% 50% 75% 100%
y axis: percentage of added nodes that are Arr1
x axis: percent completion of Arr2 iteration
100%  X

75%  X

50%  X

25%  X

0%  X

0% 25% 50% 75% 100%
Here's what I wrote
class Array
# helper method to help with testing
def mean
map(&:to_f).reduce(&:+) / length.to_f
end
# target is another array
# priority is a number between 0 and 1
# if 0, then target will not be merged in at all
# if 1, then the result will be ~50% composed of target
# returns array with the same length as self
# Note that the result will not contain all of self.concat(target)
def priority_merge(priority, target)
# clone the arrays to avoid sideeffects
arr1, arr2 = [self, target].map(&:clone)
# get the original length to determine the results length
arr1_len = arr1.length.to_f
# convert priority to float
priority = priority.to_f
# initialize a results set
results = []
# populate the results set
arr1_len.to_i.times do arr1_idx
# determine the percentage completed through iteration
pct_iterated = arr1_idx.to_f / arr1_len.to_f
# calculate perrun likelihood of favoring target
per_run_priority = pct_iterated * priority
# conclusively determine which array this iteration will pull from
num_true_cases = (100.0 * per_run_priority).to_i
cases = num_true_cases.times.map { true }.concat((100  num_true_cases).times.map { false })
priority_run_result = cases.sample
# push from arr2 if the priority run result is true, otherwise push from arr1
results << (priority_run_result ? arr2 : arr1).shift
end
results
end
end
and testing it
a1 = 50.times.map { 1 }
a2 = 50.times.map { 2 }
puts "MERGE CASE 1"
result = 50.times.map do
result = a1.priority_merge(1.0, a2)
result.select { item item == 2 }.count.to_f / a1.length.to_f
end
puts result.mean
# => is around 50%
puts "MERGE CASE 0.5"
result = 50.times.map do
result = a1.priority_merge(0.5, a2)
result.select { item item == 2 }.count.to_f / a1.length.to_f
end
puts result.mean
# => is around 25%
puts "MERGE CASE 0"
result = 50.times.map do
result = a1.priority_merge(0.0, a2)
result.select { item item == 2 }.count
end
puts result.mean
# => is 0%