Ruby Split число на единицу или половинки

Ruby предоставляет все, что вам нужно, не нужно писать никакого алгоритмического кода. Array#repeated_combination здесь ваш друг:

[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: можно избежать необходимости тасовать дважды (как массив сгенерированных массивов, так и полученный массив), используя Array#repeated_permutation, но это резко увеличит загрузку памяти и время выполнения.

Мне нравится ответ Кэри Свовеланд, но на самом деле это можно сделать, не создавая множество решений.

Давайте рассмотрим несколько примеров.

Учитывая размер = 6 и счет = 3, без тасования, это возможные выходные данные (пронумерованы слева по причинам, которые станут очевидными):

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

Данный размер = 6 и оценка = 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

Данный размер = 11 и оценка = 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

Данный размер = 12 и оценка = 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

Можете ли вы увидеть шаблоны? После небольшого почесывания подбородка мы обнаруживаем следующие факты:

1. Количество возможных выходных данных 𝑛 для заданных размера и показателя определяется как:

   𝑛 ＝ мин. (⌊ оценка ⌋, размер - ⌈ оценка ⌉) + 1

2. С ростом the число единиц уменьшается. Количество единиц определяется как:

   count (1) ＝ ⌊ счет ⌋ - 𝑖

3. С увеличением, количество половинок (½) увеличивается. Количество половин определяется как:

   count (½) ＝ 2 (𝑖 + mod ( оценка , 1))

   Другими словами, это 2𝑖 + 1, если счет имеет дробную часть, или 2𝑖 в противном случае.

4. При увеличении decreases число нулей уменьшается, определяемое как:

   count (0) ＝ размер - ⌈ оценка ⌉ - 𝑖

Имея в виду эти четыре факта, мы можем сгенерировать любой из outputs возможных выходных данных случайным образом, выбрав случайный 𝑖, где 0 ≤ 𝑖 <𝑛:

random = случайный ([0..𝑛))

Эти факты легко перевести на код Ruby:

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

Теперь нам просто нужно немного его почистить и поместить в функцию, которая принимает size и score в качестве аргументов, поворачивает num_ones, num_halves и {{X4} } в массив 0 с, 0.5 с и 1 с, и перемешивает результат:

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]

Вы можете увидеть результат в действии на repl.it: https://repl.it/@jrunning/UnpleasantDimpledLegacysystem (Обратите внимание, что когда вы запускаете его на repl.it, вывод выводится очень медленно. Это только потому, что repl.it выполняет код Ruby на сервере и передает результат обратно в браузер.)