Generate dynamic group person - dart

Question

I want make simple application named "Person Group Generator", It will generate group depending on List of person and total group you want create. Example you have 20 list person and want create 10 group from that list, application automatic will generate 10 group and each of group have 2 person. This is how i implement it.
class Person {
final int id;
final String name;
Person({this.id, this.name});
}
List<Person> listPerson = [
Person(id: 1, name: 'Ani'),
Person(id: 2, name: 'Budi'),
Person(id: 3, name: 'Citra'),
Person(id: 4, name: 'Doni'),
Person(id: 5, name: 'Emilia'),
Person(id: 6, name: 'Frasisco'),
Person(id: 7, name: 'Goyu'),
Person(id: 8, name: 'Hani'),
Person(id: 9, name: 'Intan'),
Person(id: 10, name: 'Jeri'),
Person(id: 11, name: 'Karina'),
Person(id: 12, name: 'Lemi'),
Person(id: 13, name: 'Momo'),
Person(id: 14, name: 'Nini'),
Person(id: 15, name: 'Opi'),
Person(id: 16, name: 'Parto'),
Person(id: 17, name: 'Queen'),
Person(id: 18, name: 'Risa'),
Person(id: 19, name: 'Sisca'),
Person(id: 20, name: 'Toni'),
// Person(id: 21, name: 'Ucok'),
// Person(id: 22, name: 'Vani'),
// Person(id: 23, name: 'Wahyu'),
// Person(id: 24, name: 'Xixi'),
];
Map<String, List<Person>> generateGroup(
List<Person> values, {
int generateTotalGroup = 1,
}) {
var tempMap = <String, List<Person>>{};
var tempPersonList = <Person>[];
var totalPersonEveryGroup = 0.0;
final totalPerson = values.length;
values.shuffle();
if (totalPerson % generateTotalGroup == 0) {
totalPersonEveryGroup = values.length / generateTotalGroup;
for (int i = 1; i <= generateTotalGroup; i++) {
var nameGroup = "Group $i";
var selectedPerson = values
.getRange(tempPersonList.length,
tempPersonList.length + totalPersonEveryGroup.toInt())
.toList();
tempMap[nameGroup] = selectedPerson;
tempPersonList = [...tempPersonList, ...selectedPerson];
}
} else {
/// Question to StackOverflow
}
return tempMap;
}
void main() {
final result = generateGroup(listPerson, generateTotalGroup: 10);
result.forEach((key,listPerson){
listPerson.forEach((person){
print('key $key || person ${person.name}');
});
});
}
Output
key Group 1 || person Emilia
key Group 1 || person Nini
key Group 2 || person Citra
key Group 2 || person Hani
key Group 3 || person Frasisco
key Group 3 || person Queen
key Group 4 || person Goyu
key Group 4 || person Risa
key Group 5 || person Karina
key Group 5 || person Intan
key Group 6 || person Lemi
key Group 6 || person Ani
key Group 7 || person Parto
key Group 7 || person Doni
key Group 8 || person Budi
key Group 8 || person Toni
key Group 9 || person Momo
key Group 9 || person Jeri
key Group 10 || person Sisca
key Group 10 || person Opi
If total person can be divided by total group needed is fine (20 person / 10 group = 2 person every group) , application result is what i expected.But the problem is when is can't be divided, i don't know how to handle it.
Example total person = 24 and total group needed = 10, If i divided it will result 2.4. What i expected if result can't be divided is like this :
Expectation
key Group 1 || person Ani
key Group 1 || person Budi
key Group 1 || person Citra
key Group 2 || person Doni
key Group 2 || person Emilia
key Group 2 || person Frasisco
key Group 3 || person Goyu
key Group 3 || person Hani
key Group 3 || person Intan
key Group 4 || person Jeri
key Group 4 || person Karina
key Group 4 || person Lemi
key Group 5 || person Momo
key Group 5 || person Nini
key Group 6 || person Opi
key Group 6 || person Parto
key Group 7 || person Queen
key Group 7 || person Risa
key Group 8 || person Sisca
key Group 8 || person Toni
key Group 9 || person Ucok
key Group 9 || person Vani
key Group 10 || person Wahyu
key Group 10 || person Xixi
How can i make like above if total person can't be divided by total group neeeded ?
Thank's

Answer 1

Try something like that:
class Person {
final int id;
final String name;
Person({this.id, this.name});
}
List<Person> listPerson = [
Person(id: 1, name: 'Ani'),
Person(id: 2, name: 'Budi'),
Person(id: 3, name: 'Citra'),
Person(id: 4, name: 'Doni'),
Person(id: 5, name: 'Emilia'),
Person(id: 6, name: 'Frasisco'),
Person(id: 7, name: 'Goyu'),
Person(id: 8, name: 'Hani'),
Person(id: 9, name: 'Intan'),
Person(id: 10, name: 'Jeri'),
Person(id: 11, name: 'Karina'),
Person(id: 12, name: 'Lemi'),
Person(id: 13, name: 'Momo'),
Person(id: 14, name: 'Nini'),
Person(id: 15, name: 'Opi'),
Person(id: 16, name: 'Parto'),
Person(id: 17, name: 'Queen'),
Person(id: 18, name: 'Risa'),
Person(id: 19, name: 'Sisca'),
Person(id: 20, name: 'Toni'),
Person(id: 21, name: 'Ucok'),
Person(id: 22, name: 'Vani'),
Person(id: 23, name: 'Wahyu'),
Person(id: 24, name: 'Xixi'),
];
Map<String, List<Person>> generateGroup(
List<Person> values, {
int generateTotalGroup = 1,
}) {
var tempMap = <String, List<Person>>{};
var tempPersonList = <Person>[];
var totalPersonEveryGroup = 0;
final totalPerson = values.length;
values.shuffle();
var extra = totalPerson % generateTotalGroup;
totalPersonEveryGroup = values.length ~/ generateTotalGroup;
for (int i = 1; i <= generateTotalGroup; i++) {
var end = totalPersonEveryGroup;
if (extra > 0) {
extra--;
end++;
}
var nameGroup = "Group $i";
var selectedPerson = values
.getRange(tempPersonList.length,
tempPersonList.length + end)
.toList();
tempMap[nameGroup] = selectedPerson;
tempPersonList = [...tempPersonList, ...selectedPerson];
}
return tempMap;
}
void main() {
final result = generateGroup(listPerson, generateTotalGroup: 10);
result.forEach((key,listPerson){
listPerson.forEach((person){
print('key $key || person ${person.name}');
});
});
}

Answer 2

The easiest way to distribute n elements into k buckets is round-robin.
List<List<T>> distribute<T>(List<T> elements, int buckets) {
var result = [for (var i = 0; i < buckets; i++) <T>[]];
for (var i = 0, b = 0; i < elements.length; i++) {
result[b].add(elements[i]);
b = b + 1;
if (b == buckets) b = 0;
}
return result;
}
That will not give you the results you ask for, where the first elements are kept together. Instead it will spread the first bucket-count elements into each their own bucket, then add the next bucket-count elements to the same buckets, etc.
If you want to keep the elements together, I'd do something slightly more complicated:
List<List<T>> split<T>(List<T> elements, int buckets) {
var n = elements.length;
var min = n ~/ buckets;
var remainder = n.remainder(buckets); // Number of buckets with one more element.
var i = 0;
return [
for (var b = 0; b < buckets; b++) [
for (var j = 0; j < min; j++) elements[i++],
if (--remainder >= 0) elements[i++]
]
];
}