Python 如何基于1在一组线段上分配值 问题描述

我们有一组介于

[1，…，4]

之间的整数值。我们希望在1的基础上将特定值分配到

[1，…，10]

之间不同长度的段中

我们在下表中显示了一个示例：

   Example Value  segments  distribution
    a       4       4          1 on each segment
    b       3       4          1 on the first 3 segments
    c       3       2          2 on the first segment ( 1 + 1) and 1 on the second segment

我的解决办法如下：

• 如果值>=段，则在段上循环，并向每个段添加1，直到分派值等于值
• 如果值<分段，则按降序循环分段，并向每个分段添加1，直到到达第一个分段。计算值与1s总数之间的差值，然后将其添加到第一段中

---

源代码 所有示例（a、b、c）都在下面的代码中表示。具有以下输出：

#example a [1, 1, 1, 1]
#example b [1, 1, 1, 0]
#example c [2, 1]

#!/usr/bin/env python

import os
import re
import sys
import argparse


if __name__ == "__main__":
    threshold = 4

    #(a) value = 3 and segments = 4
    dispatch = 1
    value = 4 + 1
    seg1 = [0,0,0,0]
    for i in range(0, len(seg1)):
        if dispatch == value:
            break
        seg1[i] += 1
        dispatch += 1

    print ("example a %s" %seg1)

    # (b) value = 3 and segments = 4
    dispatch = 1
    value = 3 + 1
    seg2 = [0,0,0,0]
    for i in range(0, len(seg2)):
        if dispatch == value:
            break
        seg2[i] += 1
        dispatch += 1

    print ("example b %s" %seg2)

    # (c) value = 3 and segments = 2
    value = 3 + 1
    dispatch = 1
    seg3 = [0,0]
    for i in range(len(seg3) - 1, -1, -1):
        if i == 0:
            seg3[i] = value - dispatch
            break
        seg3[i] += 1
        dispatch += 1

    print ("example c %s" %seg3)

---

问题: 我发现我使用的解决方案非常难看。我无法从这些例子中推断出一个公式。有没有一个公式可以从这些例子中推断出来？这将使算法背后有一个公式lol

我的代码是用C编写的，但我发现用python在 在这里

---

一些可能对实施有用的信息：

设

V

为值的总数，

S

为段的总数

1） 每个段将获得的最小值数：

V/S

。（考虑整数除法）

2） 现在我们只剩下

V%S

值，因为每个

S

段将获得

V/S

值。 对于

V%S

值，您只需运行一个从

1到V%S

的循环，然后将

1

添加到每个段

代码：

#include<stdio.h>

int main()
{
    int V=10;  //no. of values
    int S=4;   //no. of segments

    int arr[4];  //Considering 0-based indexing
    int minimumValues = V/S;
    int remaining = V%S;
    for(int i=0;i<S;i++)
    {
        arr[i]=minimumValues;

        if(i<remaining)
            arr[i]++;
    }

    for(int i=0;i<S;i++)
        printf("%d, ",arr[i]);
    return 0;
}

#包括
int main（）
{
int V=10；//值的数量
int S=4；//段数
int arr[4]；//考虑基于0的索引
int最小值=V/S；
剩余整数=V%S；
对于（int i=0；i一些在实现中可能有用的信息：

设
V
为值的总数，
S
为段的总数

1） 每个段将获得的最小值数：
V/S
（考虑整数除法）

2） 现在我们只剩下
V%S
值，因为每个
S
段将获得
V/S
值。
对于
V%S
值，您只需运行一个从
1到V%S
的循环，然后将
1
添加到每个段

代码：

#include<stdio.h>

int main()
{
    int V=10;  //no. of values
    int S=4;   //no. of segments

    int arr[4];  //Considering 0-based indexing
    int minimumValues = V/S;
    int remaining = V%S;
    for(int i=0;i<S;i++)
    {
        arr[i]=minimumValues;

        if(i<remaining)
            arr[i]++;
    }

    for(int i=0;i<S;i++)
        printf("%d, ",arr[i]);
    return 0;
}

#包括
int main（）
{
int V=10；//值的数量
int S=4；//段数
int arr[4]；//考虑基于0的索引
int最小值=V/S；
剩余整数=V%S；
对于（int i=0；i而言，数学公式非常简单：

value / segments

为您提供至少必须放入每个分段的项目数

value % segments

提供接收额外项目的段数

举个例子：

                      v/s    v%s
a       4       4      1      0
b       3       4      0      3
c       3       2      1      1

这样，您就得到了一个非常简单的算法：

unsigned int n = value/segments;
unsigned int c = value%segments;
for(unsigned int i = 0; i < segments; ++i)
    theSegments[i] = n + (i < c);

unsigned int n=值/段；
无符号整数c=值%段；
for（无符号整数i=0；i

或者，如果要跳过阵列：

unsigned int f(unsigned int values, unsigned int segments, theSegment)
{
    // assuming theSegment being checked for < segments
    return value/segments + (theSegment < value%segments) 
}

unsigned int f（unsigned int值、unsigned int段、segment）
{
//假设正在检查段数<段数
返回值/段+（段<值%段）
}

如果要使用基于1的数组（将索引0作为伪索引）：

for（unsigned int i=1；i数学公式非常简单：

value / segments

为您提供至少必须放入每个分段的项目数

value % segments

提供接收额外项目的段数

举个例子：

                      v/s    v%s
a       4       4      1      0
b       3       4      0      3
c       3       2      1      1

这样，您就得到了一个非常简单的算法：

unsigned int n = value/segments;
unsigned int c = value%segments;
for(unsigned int i = 0; i < segments; ++i)
    theSegments[i] = n + (i < c);

unsigned int n=值/段；
无符号整数c=值%段；
for（无符号整数i=0；i

或者，如果要跳过阵列：

unsigned int f(unsigned int values, unsigned int segments, theSegment)
{
    // assuming theSegment being checked for < segments
    return value/segments + (theSegment < value%segments) 
}

unsigned int f（unsigned int值、unsigned int段、segment）
{
//假设正在检查段数<段数
返回值/段+（段<值%段）
}

如果要使用基于1的数组（将索引0作为伪索引）：

for（unsigned int i=1；i）如果您的代码有效，并且您正在寻找一种更优雅的方法，请尝试。谢谢@jsheeran，但我正在尝试找到一个数学公式或更好的算法。我正在尝试看看是否可以找到伪代码。“我的代码是C语言，但我发现在这里用python表示它更容易。”怎么回事？你可以把你的C代码复制/粘贴到这里，然后使用编辑器的“代码示例”按钮（看起来像
{}
；选择你刚才粘贴的代码）。不需要用不同的语言生成重复的代码…如果您的代码工作正常，并且您正在寻找一种更优雅的方法，请尝试。谢谢@jsheeran，但我正在尝试找到一个数学公式或更好的算法。我正在试着看看是否可以找到伪代码。“我的代码是C语言的，但我发现在这里用python来表示它更容易。”怎么回事？你可以把你的C代码复制/粘贴到这里，然后使用编辑器的“代码示例”按钮（看起来像
{}
；之前选择你刚刚粘贴的代码）。不需要用不同的语言生成重复的代码。。。