numero divisi in gruppi di uguali dimensioni

Question

Utilizzando questo esempio:

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

qualcuno può aiutarmi come dividere l'importo sul AmountGroups con un importo massimo per ogni gruppo di maxAmount? Questi gruppi devono essere quasi della stessa dimensione.

Ad esempio: importo = 45; maxPerGroup = 15; amountGroups = 3;

Risultato: 15 15 15

Sto usando C# come linguaggio.

Grazie in anticipo!

Answer 1

NOTA non esatto C# solo per darvi l'idea.

Penso che tu stia cercando un modo per dividere grammaticamente un numero in diversi gruppi. Senza sapere quanto sono grandi i gruppi e una quantità casuale di gruppi.

quindi diciamo x = 30 y = 15. 30/15 = 3 gruppi di 15 e diciamo x = 43 quindi il numero dovrebbe essere come? 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); 
} 

} 

Potrei scrivere in una corretta C# ma sembra che hai trovato il codice corretto per esso

Answer 2

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

Avrete rem gruppi con number per group + 1 e number of groups - rem gruppi con number per group.

EDIT: Esempio:

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 gruppi con 13 e 2 con 12.

Answer 3

soluzione semplice non ottimizzato:

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

Ci sono molti modi di scissione l'importo tra i gruppi. Tutto dipende dal fatto che l'unico fattore sia il numero di gruppi o se ci siano altri fattori. Vedere:

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