Split число на равные по размеру группы

Question

Используя этот пример:

var amount = x; 
var maxPerGroup = y; 
var amountGroups = Ceiling(amount/maxPerGroup); 

Может кто-то помочь мне, как разделить сумму на AmountGroups с максимальным количеством в группе maxAmount? Эти группы должны быть почти одного размера.

Например: количество = 45; maxPerGroup = 15; количествоGroups = 3;

Результат: 15 15 15

Я использую C# в качестве языка.

Заранее благодарен!

Answer 1

Примечание не точна с # просто чтобы дать вам идею.

Я думаю, что вы ищете способ грамматически разделить число в разных группах. Не зная, насколько велики группы и случайное количество групп.

, так скажем x = 30 y = 15. 30/15 = 3 группы из 15 и, допустим, x = 43, поэтому число должно быть таким? 14 14 15

groups (since you already have this calculated correctly)(should be a double) 
// maxPerGroup = y 
membersPerGroup = floor(amount/groups) 



List a = new List 
//Is the leftover value of the modulus 
leftover = amount%groups; 
//Loops for each group 
for(int i=0;i<groups;i++){ 


//If there is a left over value 
if(leftover>0){ 
    a.Add(membersPerGroup +1); 
    leftover--; 
}else{ 
    a.Add(membersPerGroup); 
} 

} 

Я мог бы написать в исправном C#, но кажется, что вы нашли правильный код для его

Answer 2

number of groups := ceiling(total/max group size) 
number per group := floor(total/number of groups) 
rem = total % number per group 

Вы будете иметь rem группы с number per group + 1 и number of groups - rem групп с number per group.

РЕДАКТИРОВАТЬ: Пример:

total := 50 
max group size := 15 
number of groups := ceiling(50/15) // 4 
number per group := floor(50/4) // 12 
rem := 50 % 12 // 2 

2 группы с 13 и 2 с 12.

Answer 3

простой неоптимизированная раствор:

int i = amount; 
int j = 0; 
int [] groups = new int[amountGroups]; 
while(i > 0) { 
    groups[j] += 1; 
    i--; 
    j = (j+1)%amountGroups; 
} 

Answer 4

int amount = x; 
int maxPerGroup = y; 
int amountGroups = new int[Ceiling(amount/maxPerGroup)]; 
for(int i=0; i<maxPerGroup; i++) 
{ 
    if(x>maxPerGroup) 
    { 
     amountGroups[i]= maxPerGroup; 
     x = x-maxPerGroup; 
    } 
    else 
    { 
     amountGroups[i] = x; 
     x =0; 
    } 
} 

Answer 5

Есть много способов расщепления количество между группами. Все зависит от того, является ли единственным фактором количество групп или есть другие факторы. См:

static void Main(string[] args) 
    { 
     List<int> list1 = Split1(48, 15); // result is: 15, 15, 15, 3 
     List<int> list2 = Split2(48, 15); // result is 12, 12, 12, 12 
    } 

    public static List<int> Split1 (int amount, int maxPerGroup) 
    { 
     int amountGroups = amount/maxPerGroup; 

     if (amountGroups * maxPerGroup < amount) 
     { 
      amountGroups++; 
     } 

     List<int> result = new List<int>(); 
     for (int i = 0; i < amountGroups; i++) 
     { 
      result.Add(Math.Min(maxPerGroup, amount)); 
      amount -= Math.Min(maxPerGroup, amount); 
     } 
     return result; 
    } 

    public static List<int> Split2 (int amount, int maxPerGroup) 
    { 
     int amountGroups = amount/maxPerGroup; 

     if (amountGroups * maxPerGroup < amount) 
     { 
      amountGroups++; 
     } 

     int groupsLeft = amountGroups; 
     List<int> result = new List<int>(); 
     while (amount > 0) 
     { 
      int nextGroupValue = amount/groupsLeft; 
      if (nextGroupValue * groupsLeft < amount) 
      { 
       nextGroupValue++; 
      } 
      result.Add(nextGroupValue); 
      groupsLeft--; 
      amount -= nextGroupValue; 
     } 
     return result; 
    } 

Answer 6

// For separating a collection into ranges 
    static List<List<T>> Split<T>(List<T> source, int size) 
    { 
     // TODO: Prepopulate with the right capacity 
     List<List<T>> ret = new List<List<T>>(); 
     for (int i = 0; i < source.Count; i += size) 
     { 
      ret.Add(source.GetRange(i, Math.Min(size, source.Count - i))); 
     } 
     return ret; 
    } 

    // For separating an int into a Tuple range 
    static List<Tuple<int, int>> Split(int source, int size) 
    { 
     var ret = new List<Tuple<int, int>>(); 
     for (int i = 0; i < source; i += size) 
     { 
      ret.Add(new Tuple<int, int>(i, (i + Math.Min(size, source - i)))); 
     } 
     return ret; 
    }