2012-07-02 32 views
5

Uso este ejemplo:número dividen en grupos de igual tamaño

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

¿Puede alguien ayudarme cómo dividir la cantidad en AmountGroups con una cantidad máxima por grupo de MaxAmount? Estos grupos tienen que ser casi del mismo tamaño.

Por ejemplo: cantidad = 45; maxPerGroup = 15; cantidadGrupos = 3;

Resultado: 15 15 15

estoy usando C# como lenguaje.

¡Gracias de antemano!

+0

¿Usted está buscando el operador de división aritmética? –

+0

es esta tarea? –

+0

No, no es tarea. Estoy buscando esto todo el día. –

Respuesta

1

NOTA no exacta C# sólo para darle la idea.

Creo que está buscando una forma de dividir gramaticalmente un número en diferentes grupos. Sin saber qué tan grandes son los grupos y una cantidad aleatoria de grupos.

digamos x = 30 y = 15. 30/15 = 3 grupos de 15 y digamos x = 43, entonces el número debería ser así? 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); 
} 

} 

podría escribir en C# adecuada pero parece que ha encontrado el código adecuado para ello

+1

Como traté de insinuar en mi comentario (pregunta): el número de grupos no se calcula correctamente, dividir un número entero por un entero dará como resultado un entero (C#). Por ejemplo, 31 dividido por 15 devuelve 2 y el techo que no te llevará a ningún lado ... –

+0

Debería ser un doble. Tal vez me lo perdí al escribir el código C# no tan real. Pero debería haber sido un doble y supongo que eso es lo que dice – Liquid

+0

Y al releer, he encontrado otros errores – Liquid

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

Tendrá rem grupos con number per group + 1 y number of groups - rem grupos con number per group.

EDIT: Ejemplo:

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 grupos con 13 y 2 con 12.

+1

Debería quedar claro a partir de mi código que las barras representan la división adecuada, no la división entera (de lo contrario, las operaciones de piso y techo no tendrían sentido). Más allá de eso, el uso de cualquier tipo de datos en particular es un detalle de implementación. –

1

sencilla solución no optimizado:

int i = amount; 
int j = 0; 
int [] groups = new int[amountGroups]; 
while(i > 0) { 
    groups[j] += 1; 
    i--; 
    j = (j+1)%amountGroups; 
} 
-2
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; 
    } 
} 
+0

¿No le daría esto 15 15 1 en el caso de 31? – Liquid

0

Hay muchas maneras de dividir la cantidad entre grupos. Todo depende de si el único factor es la cantidad de grupos o si hay otros factores. Ver:

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; 
    } 
0
// 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; 
    } 
Cuestiones relacionadas