liczba podziału na równe grupy wielkości

Question

Korzystanie z poniższym przykładzie:

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

Czy ktoś może mi pomóc w jaki sposób podzielić kwotę na AmountGroups o maksymalnej kwoty za grupą maxAmount? Te grupy muszą być prawie tego samego rozmiaru. Na przykład: kwota = 45; maxPerGroup = 15; amountGroups = 3;

Wynik: 15 15 15

Używam C# jako języka.

Z góry dzięki!

Answer 1

UWAGA nie dokładny C# tak, aby dać Ci pomysł.

Myślę, że szukasz sposobu, aby gramatycznie podzielić liczbę w różnych grupach. Nie wiedząc, jak duże są grupy i losowa liczba grup.

Załóżmy, że x = 30 y = 15. 30/15 = 3 grupy po 15 i załóżmy, że x = 43, więc liczba powinna być jak? 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); 
} 

} 

mógłbym pisać w C#, ale właściwego Wydaje się, że znalazł właściwego kodu dla niego

Answer 2

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

Trzeba będzie rem grupy z number per group + 1 i number of groups - rem grupach number per group.

Edycja: Przykład:

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 grupy 13 i 2 z 12.

Answer 3

proste nie zoptymalizowanych rozwiązań:

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

Istnieje wiele sposobów rozszczepiania kwota między grupami. Wszystko zależy od tego, czy jedynym czynnikiem jest liczba grup, czy też istnieją inne czynniki. Zobacz:

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; 
    }