Algorithm 如何分组？

我正在用Dart写微服务。 服务通过将命令参数传递给工人来运行工人，如：“app.exe-a=1,2,3,4”。 因此，如果

CurrentlyActivieWorkers

是

4

。然后可以将工作分配给以下几个工人：

第一个：

“app.exe-a=1,2,3,4”

第二个：

“app.exe-a=5,6,7,8”

第三：

“app.exe-a=9,10,11,12”

第四个：

“app.exe-a=13,14,15,16”

我写了下一个原型：

void main() {
  
  int maxWorkers = 16;
  int currentlyActiveWorkers = 2;

  genJobs() {
    int step = 1; 
    int sliceSize = (maxWorkers/currentlyActiveWorkers).round(); 
    var list = [for(var i=step; i<=maxWorkers; i+=1) i];

    for(int i in Iterable<int>.generate(currentlyActiveWorkers))
    {
      print(list.sublist(i * sliceSize, sliceSize * step));
      step++;
    }

  }
  genJobs();
  
}

但如果用户指定例如

3

，则会出现错误。最后一个编号

16

正在丢失。 输出：

---

每个组中的数字元素+-1对我来说都没关系。

您的问题是，您首先为切片选择了一个固定的大小，即使元素的数量不是切片计数的倍数。幸运的是，它是向下舍入的，而不是向上舍入的，否则会出现索引超出范围的错误（请尝试使用包含17个元素和三个组的代码）

首先，你应该计算出你想要的结果。然后你可以试着编写代码

对于22个元素和4个组，您可能需要两组6个元素和两组5个元素，而不是三组6个元素和一组4个元素（因为您说+/-1可以，而不是+/-2）

我会这样做：

///在[groupCount]GRUP中发出从0到[elementCount]-1的整数。
///
///[elementCount]必须大于零。
///[groupCount]必须在范围1..[elementCount]内，
///意味着每个组将至少有一个元素，以及
///每个元素至少在一个组中。
Iterable evenlySpreadGroups（int-elementCount，int-groupCount）同步*{
如果（元素计数<1）{
抛出RangeError.range（elementCount，1，null，“elementCount”）；
}
RangeError.checkValueInInterval（groupCount，1，elementCount，“groupCount”）；
var列表=[]；
var-groupIndex=1；
对于（变量i=0；i=groupIndex*elementCount）{
产量表；
列表=[]；
groupIndex+=1；
}
列表.添加（i）；
}   
产量表；
}

---

（如果允许的组数大于元素数，任何

groupCount

>>=1，则输出中只会出现很少有用的空列表，这也是可以使用的）。

舍入逻辑不明确。此外，您应该以不同的方式处理最后一块数据：

void main() {
  print(genJobs());
}

Map<int, List<int>> genJobs() {
  final activeWorkers = 3;
  final maxJobs = 16;
  final jobs = List<int>.generate(maxJobs, (i) => i + 1);
  final workerCapacity = (jobs.length / activeWorkers).floor();

  var chunks = <int, List<int>>{};
  for (var workerNumber = 0; workerNumber < activeWorkers; workerNumber++) {
    final startIndex = workerNumber * workerCapacity;
    final endIndex = startIndex + workerCapacity;
    final chunk = jobs.sublist(
      startIndex,
      endIndex > jobs.length || workerNumber == activeWorkers - 1
          ? jobs.length
          : endIndex,
    );
    chunks.addAll({workerNumber: chunk});
  }

  return chunks;
}

void main（）{
打印（genJobs（））；
}
映射genJobs（）{
最终活跃工人=3人；
最终maxJobs=16；
最终作业=List.generate（maxJobs，（i）=>i+1）；
最终工作能力=（jobs.length/activeWorkers.floor（）；
var chunks={}；
对于（var workerNumber=0；workerNumberjobs.length | | workerNumber==activeWorkers-1
？作业长度
：endIndex，
);
addAll（{workerNumber:chunk}）；
}
返回块；
}

解决方案越多越好：

import 'package:lists/lists.dart';

void main() {
  final maxPartSize1 = 5;

  final data1 = genData(1, 16);
  print('data: $data1');
  final parts1 = split(data1, maxPartSize1);
  print('parts by $maxPartSize1: $parts1');
  print('=====');

  final maxPartSize2 = 3;

  final data2 = genData(2, 8);
  print('data: $data2');
  final parts2 = split(data2, maxPartSize2);
  print('parts by $maxPartSize2: $parts2');
}

List<int> genData(int start, int length) {
  return List<int>.generate(length, (i) => i + start);
}

Iterable<List<int>> split(List<int> data, int step) sync* {
  final length = data.length;
  for (final i in StepList(0, length - 1, step)) {
    var i2 = i + step;
    if (i2 > length) {
      i2 = length;
    }

    yield data.sublist(i, i2);
  }
}

另一种方式：

void main() {
  final maxWorkers1 = 8;
  final datLen1 = 16;
  final data1 = [1, 2, 5, 6, 9, 10, 11, 12, 13, 14, 15, 16];
  print('data: $data1');
  final parts1 = split(data1, maxWorkers1);
  print('$maxWorkers1 workers: $parts1');
  print('=====');

  final maxWorkers2 = 4;
  final datLen2 = 11;
  final data2 = genData(3, datLen2);
  print('data: $data2');
  final parts2 = split(data2, maxWorkers2);
  print('$maxWorkers2 workers: $parts2');

  print('=====');
  final maxWorkers3 = 8;
  final data3 = [7, 8, 3, 4];
  print('data: $data3');
  final parts3 = split(data3, maxWorkers3);
  print('$maxWorkers3 workers: $parts3');
}

List<int> genData(int start, int length) {
  return List<int>.generate(length, (i) => i + start);
}

Iterable<List<int>> split(List<int> data, int divider) sync* {
  if (divider <= 0) {
    throw RangeError.value(divider, 'divider', 'Must be greater than 0');
  }

  if (data.isEmpty) {
    // Nothing to do
    return;
  }

  final length = data.length;
  divider = divider > length ? length : divider;
  var partSize = length ~/ divider;
  if (length != partSize * divider) {
    partSize++;
  }

  for (var i = 0; i < divider; i++) {
    final start = i * partSize;
    if (start >= length) {
      break;
    }

    var end = start + partSize;
    if (end > length) {
      end = length;
    }

    yield data.sublist(start, end);
  }
}

---

你试过调试了吗？你的发现是什么？经过长时间的测试，我决定回到你的答案上来。它只在如下范围内存在问题：

final jobs=[1,3,4,5,6,7,10,14,17,18,19]。它生成的最后一个数组非常大：
{0:[1,3,4]，1:[5,6,7]，2:[10,14,17,18,19]}
如果您有
activeWorkers=3
，那么它是
作业长度为11时唯一正确的结果，因为11%3=2。这意味着在最后一个区块中比其他区块多2个元素。我在代码错误中发现了错误：
RangeError（RangeError（start）：无效值：不在包含范围0..12:14）
如果
workerCapacity
取决于
jobs
的长度，您应该在从
jobs
中删除项目后计算它。记住检查边界条件是否满足，这不是那么容易。应该有更多的逻辑，而不仅仅是涵盖共同的边界。看看你的要点。我在代码中添加了解释。我已经检查了您的代码，并将其粉碎。它的运行方式如下：
RangeError（RangeError（start）：无效值：不在包含范围0..12:14）
@DmitryBubennkov谢谢（抱歉）。现在它工作了（经过一些修正）。我是说第二种选择。你可以再试一次。
import 'package:lists/lists.dart';

void main() {
  final maxPartSize1 = 5;

  final data1 = genData(1, 16);
  print('data: $data1');
  final parts1 = split(data1, maxPartSize1);
  print('parts by $maxPartSize1: $parts1');
  print('=====');

  final maxPartSize2 = 3;

  final data2 = genData(2, 8);
  print('data: $data2');
  final parts2 = split(data2, maxPartSize2);
  print('parts by $maxPartSize2: $parts2');
}

List<int> genData(int start, int length) {
  return List<int>.generate(length, (i) => i + start);
}

Iterable<List<int>> split(List<int> data, int step) sync* {
  final length = data.length;
  for (final i in StepList(0, length - 1, step)) {
    var i2 = i + step;
    if (i2 > length) {
      i2 = length;
    }

    yield data.sublist(i, i2);
  }
}

data: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]
parts by 5: ([1, 2, 3, 4, 5], [6, 7, 8, 9, 10], [11, 12, 13, 14, 15], [16])
=====
data: [2, 3, 4, 5, 6, 7, 8, 9]
parts by 3: ([2, 3, 4], [5, 6, 7], [8, 9])

void main() {
  final maxWorkers1 = 8;
  final datLen1 = 16;
  final data1 = [1, 2, 5, 6, 9, 10, 11, 12, 13, 14, 15, 16];
  print('data: $data1');
  final parts1 = split(data1, maxWorkers1);
  print('$maxWorkers1 workers: $parts1');
  print('=====');

  final maxWorkers2 = 4;
  final datLen2 = 11;
  final data2 = genData(3, datLen2);
  print('data: $data2');
  final parts2 = split(data2, maxWorkers2);
  print('$maxWorkers2 workers: $parts2');

  print('=====');
  final maxWorkers3 = 8;
  final data3 = [7, 8, 3, 4];
  print('data: $data3');
  final parts3 = split(data3, maxWorkers3);
  print('$maxWorkers3 workers: $parts3');
}

List<int> genData(int start, int length) {
  return List<int>.generate(length, (i) => i + start);
}

Iterable<List<int>> split(List<int> data, int divider) sync* {
  if (divider <= 0) {
    throw RangeError.value(divider, 'divider', 'Must be greater than 0');
  }

  if (data.isEmpty) {
    // Nothing to do
    return;
  }

  final length = data.length;
  divider = divider > length ? length : divider;
  var partSize = length ~/ divider;
  if (length != partSize * divider) {
    partSize++;
  }

  for (var i = 0; i < divider; i++) {
    final start = i * partSize;
    if (start >= length) {
      break;
    }

    var end = start + partSize;
    if (end > length) {
      end = length;
    }

    yield data.sublist(start, end);
  }
}

data: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]
3 workers: ([1, 2, 3, 4, 5, 6], [7, 8, 9, 10, 11, 12], [13, 14, 15, 16])
=====
data: [3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]
4 workers: ([3, 4, 5], [6, 7, 8], [9, 10, 11], [12, 13])
=====
data: [7, 8, 3, 4]
8 workers: ([7], [8], [3], [4])