số Chia thành các nhóm có kích thước tương đương

Question

Sử dụng ví dụ này:

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

Ai đó có thể giúp tôi làm thế nào để phân chia các Số tiền vào AmountGroups với một số lượng tối đa cho mỗi nhóm maxAmount? Các nhóm này phải có cùng kích thước.

Ví dụ: số tiền = 45; maxPerGroup = 15; amountGroups = 3;

Kết quả: 15 15 15

Tôi đang sử dụng C# làm ngôn ngữ.

Cảm ơn trước!

Answer 1

LƯU Ý không chính xác C# chỉ để cung cấp cho bạn những ý tưởng.

Tôi nghĩ rằng bạn đang tìm kiếm một cách để phân chia theo ngữ pháp một số trong các nhóm khác nhau. Không biết các nhóm lớn và số lượng nhóm ngẫu nhiên như thế nào.

vì vậy giả sử x = 30 y = 15. 30/15 = 3 nhóm 15 và giả sử x = 43 vì vậy số nên giống như thế nào? 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); 
} 

} 

tôi có thể viết trong hợp C# nhưng Dường như bạn tìm thấy mã đúng cho nó

Answer 2

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

Bạn sẽ phải rem nhóm với number per group + 1 và number of groups - rem nhóm với number per group.

EDIT: Ví dụ:

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 nhóm với 13 và 2 với 12.

Answer 3

đơn giản không được tối ưu hóa giải pháp:

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

Có rất nhiều cách để tách số tiền giữa các nhóm. Tất cả phụ thuộc vào việc yếu tố duy nhất là số lượng nhóm hoặc nếu có bất kỳ yếu tố nào khác. Xem:

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