一个数的整数除法

Question

如何将数字分成相等部分或尽可能接近相等的部分。请参见以下示例：

如果我有一个值为61，我希望在两个组之间分配它，那么就是30.5和30.5，但是双倍数（小数）不好，因此最接近的分割是30和31。

同样，42/5=8.4，但是我需要系统返回（8、8、8、9、9），这是最接近整数的拆分。

已解决：

        if(sum % numberOfTeams != 0) {
        al.add(0, sNOT);
    for(int i = 0; i < numberOfTeams - 1;  i++) {
        int remover = sum - sNOT;
        if(remover % (sNOT + 1) == 0) {
            al.add(i+1, sNOT + 1);
        }else {
         al.add(i + 1, sNOT);

        }

     }
}

}

- M.Shiz

---

不掩盖一个有趣的问题，但是很好奇为什么一个没有任何努力的问题会得到几个赞？ - achAmháin

我完全同意@Dukeling的观点。昨天在元站上，我也曾对此进行过一些争论。有趣的问题比无聊的问题更有可能获得赞同（不管是否显示了努力）。 - Taslim Oseni

@achAmháin 这是算法标签的典型特征。 - m69 ''snarky and unwelcoming''

Answer 1

这里有一个完全使用Arrays的解决方案，没有循环且更加简短。如上面建议的那样，应该对有效性进行检查。

    int value = 42;
    int groups = 5;

    int residue = value % groups;
    int[] res = new int[groups];
    int division = value / groups;
    Arrays.fill(res, 0, residue, division +1);
    Arrays.fill(res, residue, res.length, division);

    System.out.println(Arrays.toString(res));

- antonpuz

Answer 2

以下是一种解决方案：

public static int[] closestSplit(int intToSplit, int noOfGroups) {

    int[] result = new int[noOfGroups];
    Arrays.fill(result, intToSplit / noOfGroups);
    for (int i = 0; i < intToSplit % noOfGroups; i++) {
        result[i]++;
    }
    return result;

}


// usage:
System.out.println(Arrays.toString(closestSplit(42, 5)));

基本上，它首先创建一个长度为noOfGroups的数组，然后用intToSplit和noOfGroups的整数除法填充该数组。接下来，它将在数组的前intToSplit mod noOfGroups个元素中添加一。如果您需要结果按升序排序，可以从数组末尾循环或使用Arrays.sort。

- Sweeper

Answer 3

解决这个问题时需要考虑的主要事项是余数。

从上面的例子中，我们打算将61分成2份，61 / 2 的余数为1。由于我们将其分成两组，这两组中只有1组必须是((int) 61 / 2) + 1。剩下的（一）组可以是((int) 61 / 2)。

另外，考虑将42分成5份，42 / 5 的余数为2。由于我们将其分成5组，这五组中只有2组必须是((int) 42 / 5) + 1。剩下的（三）组可以是((int) 42 / 5)。

以下是代码：

public int[] spitNumbers(int number, int groups){

    int[] result = new int[groups];  //The array we'd return at the end

    int shift = number % groups;  //I used this to check the remainder.

    for(int i = 0; i < result.length; i++){

    /* The if-statement below checks for two things:
       - if the remainder is zero
       - if we've reached the shifting stage.
    */
        if((shift == 0) || (i < shift)){
            result[i] = number / groups;
        }

    // The else statement starts being fired when the shifting stage has been reached.

        else{
            result[i] = (number / groups) + 1;
        }
    }
    return result;
}

我希望这能帮到你.. 祝编程愉快！

- Taslim Oseni

Answer 4

请看一下这个解决方案，我测试了一下，它可以工作。

public static int[] number(int number, int divider) {
    if (number == 0 || number < divider) {
        return new int[]{0};
    }
    if (number == 1 || number == divider) {
        return new int[]{1};
    }
    double r = (double) number / divider;
    int upperCount = number % divider;
    return IntStream.range(0, divider).map(i ->{
        if (i < upperCount) {
            return (int) Math.ceil(r);
        }
        return (int) Math.floor(r);
    }).toArray();
}

附注：稍微简化了一下

- ImZ