Работа с элементами «остатка»

Question

Учитывая массив names (длина неизвестна), создайте рабочие группы по 4, никакая рабочая группа не может быть меньше 3! КРОМЕ массив имеет только один или два названия, содержащиеся с в.

КОД

def groups(source) 
    Hash[ source.each_slice(4).map.with_index { |key, value| [ "Group: #{value+1}", key] } ] 
end 

Примеры

names10 = ["Aname", "Bname", "Cname", "Dname", "Ename", "Fname", "Gnames", "Hnames", 
      "Inames", "Jnames"] 

puts groups(names10) 
#=> {"Group: 1"=>["Aname", "Bname", "Cname", "Dname"], "Group: 2"=>["Ename", "Fname", 
# "Gnames", "Hnames"], "Group: 3"=>["Inames", "Jnames"]} 

Как видно из приведенного выше примера, мой код, созданный группа 3 с двумя именами. Желаемый доход будет принимать имена в группе 3 и распределить их в 1-й группе и группе 2.

Ожидаемое возвращение

puts groups(names10) 
#=> {"Group: 1"=>["Aname", "Bname", "Cname", "Dname", "Jnames",], "Group: 2"=>["Ename", 
# "Fname", "Gnames", "Hnames", "Jnames"]} 

Если массив содержал 26 имен, мой код будет возвращать 6 групп 4 и 1 группа из 2, я хотел бы иметь возможность взять два имени в группе 7 и распределить их между группами 5 и 6.

Надеюсь, это прояснит мой вопрос. и да, мой код раньше был сломан! извините

Answer 1

Я не уверен, что понимаю вас вопрос, но я предложу ответ на следующий:

«Дан массив a и минимальный размер подмассив m, 1 < m <= a.size, возвращает массив b = [b1, b2,.., bf] что разделяет элементы a на подмассивы bi, i=1..f, так что подмассивы имеют размер s, где s >= m и s является как можно меньше. "

..и затем я вернусь возвращаемый массив в хэш, который вы запросили.

Код

def equal_partition(arr,min_sub_size) 
    as = arr.size 
    sz = (min_sub_size..as).find { |sub_size| (as % sub_size).zero? } 
    arr.each_slice(sz).map.with_index(1) { |a,i| ["Group: #{i}:", a] }.to_h 
end 

Примеры

names10 = ["Aname", "Bname", "Cname", "Dname", "Ename", 
      "Fname", "Gnames", "Hnames", "Inames", "Jnames"] 

equal_partition(names10, 3) 
    #=> {"Group: 1:"=>["Aname", "Bname", "Cname", "Dname", "Ename"], 
    # "Group: 2:"=>["Fname", "Gnames", "Hnames", "Inames", "Jnames"]} 
equal_partition(names10, 2) 
    #=> {"Group: 1:"=>["Aname", "Bname"], "Group: 2:"=>["Cname", "Dname"], 
    # "Group: 3:"=>["Ename", "Fname"], "Group: 4:"=>["Gnames", "Hnames"], 
    # "Group: 5:"=>["Inames", "Jnames"]} 
equal_partition(names10, 6) 
    #=> {"Group: 1:"=>["Aname", "Bname", "Cname", "Dname", "Ename", 
    #     "Fname", "Gnames", "Hnames", "Inames", "Jnames"]} 
equal_partition(names10, 1) 
    #=> {"Group: 1:"=>["Aname"], "Group: 2:"=> ["Bname"], 
    # "Group: 3:"=>["Cname"], "Group: 4:"=> ["Dname"], 
    # "Group: 5:"=>["Ename"], "Group: 6:"=> ["Fname"], 
    # "Group: 7:"=>["Gnames"], "Group: 8:"=> ["Hnames"], 
    # "Group: 9:"=>["Inames"], "Group: 10:"=>["Jnames"]} 

.

names12 = ["Aname", "Bname", "Cname", "Dname", "Ename", "Fname", 
      "Gnames", "Hnames", "Inames", "Jnames", "Kname", "Lname"] 

equal_partition(names12, 3) 
    #=> {"Group: 1:"=>["Aname", "Bname", "Cname"], 
    # "Group: 2:"=>["Dname", "Ename", "Fname"], 
    # "Group: 3:"=>["Gnames", "Hnames", "Inames"], 
    # "Group: 4:"=>["Jnames", "Kname", "Lname"]} 

equal_partition(names12, 4) 
    #=> {"Group: 1:"=>["Aname", "Bname", "Cname", "Dname"], 
    # "Group: 2:"=>["Ename", "Fname", "Gnames", "Hnames"], 
    # "Group: 3:"=>["Inames", "Jnames", "Kname", "Lname"]} 

equal_partition(names12, 5) 
    #=> {"Group: 1:"=>["Aname", "Bname", "Cname", "Dname", "Ename", "Fname"], 
    # "Group: 2:"=>["Gnames", "Hnames", "Inames", "Jnames", "Kname", "Lname"]} 

equal_partition(names12, 6) 
    #=> {"Group: 1:"=>["Aname", "Bname", "Cname", "Dname", "Ename", "Fname"], 
    # "Group: 2:"=>["Gnames", "Hnames", "Inames", "Jnames", "Kname", "Lname"]} 

Объяснение

Предположим, мы хотим вычислить:

equal_partition(names10, 3) 

затем

arr = names10 
min_sub_size = 3 
as = arr.size 

sz = (min_sub_size..as).find { |sub_size| (as % sub_size).zero? } 
    #=> (3..10).find { |sub_size| (10 % sub_size).zero? } 
    #=> 5 

enum1 = arr.each_slice(5) 
    #=> #<Enumerator: ["Aname", "Bname", "Cname", "Dname", "Ename", 
    #   "Fname", "Gnames", "Hnames", "Inames", "Jnames"]:each_slice(5)> 
enum2 = enum1.map 
    #=> #<Enumerator: #<Enumerator: ["Aname", "Bname", "Cname", "Dname", 
    #   "Ename", "Fname", "Gnames", "Hnames", "Inames", 
    #   "Jnames"]:each_slice(5)>:map> 
enum3 = enum2.with_index(1) 
    #=> #<Enumerator: #<Enumerator: #<Enumerator: ["Aname", "Bname", 
    #   "Cname", "Dname", "Ename", "Fname", "Gnames", "Hnames", 
    #   "Inames", "Jnames"]:each_slice(5)>:map>:with_index(1)> 

enum2 и enum3 можно рассматривать как "соединение" счетчиками.Мы можем преобразовать enum3 в массив, чтобы увидеть, что (два) объектов будет проходить в его блок:

enum3.to_a 
    #=> [[["Aname", "Bname", "Cname", "Dname", "Ename"], 1], 
    # [["Fname", "Gnames", "Hnames", "Inames", "Jnames"], 2]] 

a = enum3.each { |a,i| ["Group: #{i}:", a] } 
    #=> [["Group: 1:", ["Aname", "Bname", "Cname", "Dname", "Ename"]], 
    # ["Group: 2:", ["Fname", "Gnames", "Hnames", "Inames", "Jnames"]]] 

a.to_h 
    #=> {"Group: 1:"=>["Aname", "Bname", "Cname", "Dname", "Ename"], 
    # "Group: 2:"=>["Fname", "Gnames", "Hnames", "Inames", "Jnames"]} 

Для версий Ruby, до 2.0, последний шаг должен быть заменен:

Hash[a]