Algorithm 数量分布_Algorithm_Language Agnostic

Algorithm 数量分布

algorithm language-agnostic

Algorithm 数量分布,algorithm,language-agnostic,Algorithm,Language Agnostic,问题：我们有x个复选框，我们希望均匀地检查其中的y 示例1：选择50个复选框，共100个 [-] [x] [-] [x] ... [-] [-] [x] [-] [-] [x] ... 示例2：选择总共100个的33个复选框 [-] [x] [-] [x] ... [-] [-] [x] [-] [-] [x] ... 示例3：选择66个复选框，共100个： [-] [x] [x] [-] [x] [x] ... 但是我们很难想出一个公式来在代码中检查它们，尤其是当你使用11/111或

问题：我们有x个复选框，我们希望均匀地检查其中的y

示例1：选择50个复选框，共100个

[-]
[x]
[-]
[x]
...

[-]
[-]
[x]
[-]
[-]
[x]
...

示例2：选择总共100个的33个复选框

[-]
[x]
[-]
[x]
...

[-]
[-]
[x]
[-]
[-]
[x]
...

示例3：选择66个复选框，共100个：

[-]
[x]
[x]
[-]
[x]
[x]
...

但是我们很难想出一个公式来在代码中检查它们，尤其是当你使用11/111或类似的东西时。有人有想法吗？

让我们先假设

可以被

整除。然后我们表示

p=y/x

，解很简单。浏览列表，每个

元素，标记其中的1个

现在，假设

r=y%x

为非零。仍然

p=y/x

，其中

是整数除法。因此，您需要：

在第一个
```
p-r
```
元素中，标记1个元素
在最后一个
```
r
```
元素中，标记2个元素

注意：这取决于如何定义均匀分布。您可能希望将

部分与

x+1

元素分散在

p-r

部分与

元素之间，这确实是同样的问题，可以递归解决

好吧，所以它实际上并不正确。不过，我认为这样做可以：

无论可除性如何：

如果
```
y>2*x
```
，则每
```
p=y/x
```
元素标记1个元素，
```
x
```
次
如果
```
y<2*x
```
，则标记全部，并在
```
y
```
复选框中取消标记
```
y-x
```
（与前一种情况类似，但是
```
x
```
被
```
y-x
```
替换）

注意：这取决于如何定义均匀分布。例如，您可能希望在

和

p+1

元素之间进行更改，以便更好地分布它们。

假设复选框的数量为C，X的数量为N

您的示例指出，C=111和N=11是最麻烦的情况

试着这样做：将C/N除以。称之为D。将数组中的索引作为双倍数字I。将另一个变量作为计数器M

double D = (double)C / (double)N;
double I = 0.0;
int M = N;
while (M > 0) {
    if (checkboxes[Round(I)].Checked) { //  if we selected it, skip to next
        I += 1.0;
        continue;
    }
    checkboxes[Round(I)].Checked = true;
    M --;
    I += D;
    if (Round(I) >= C) { //  wrap around the end
        I -= C;
    }
}

请注意，四舍五入（x）应返回与x最接近的整数值

这张支票可能对你有用。

我认为关键是要计算你希望每张支票有多少个盒子

假设你想要100盒33张支票<代码>100/33=3.030303…，因此您希望每3.030303。。。盒。这意味着每3.030303。。。框中，您需要添加一个复选框。100个盒子里有66张支票意味着每1.51515张支票就有一张。。。盒子，111个盒子里有11张支票意味着每10.0909就有一张支票。。。盒子，等等

double count = 0;
for (int i = 0; i < boxes; i++) {
    count += 1;
    if (count >= boxes/checks) {
        checkboxes[i] = true;
        count -= count.truncate(); // so 1.6 becomes 0.6 - resetting the count but keeping the decimal part to keep track of "partial boxes" so far
    }
}

double count=0；
对于（int i=0；i=方框/支票）{
复选框[i]=真；
count-=count.truncate（）；//因此1.6变为0.6-重置计数，但保留小数部分以跟踪“部分框”
}
}

对于

计数

，您可能更愿意使用

十进制

，而不是

双精度

，或者由于舍入错误，最后一个框可能会被跳过。

下面是一个使用整数算术的简单解决方案：

void check(char boxes[], int total_count, int check_count)
{
    int i;

    for (i = 0; i < total_count; i++)
        boxes[i] = '-';

    for (i = 0; i < check_count; i++)
        boxes[i * total_count / check_count] = 'x';
}

与：

正确性假设

0=0

<代码>i，

总计数

和

检查计数

都将

=0

将是

。当n>0
和d>0
时：
(n * d - 1) / d < n

（n*d-1）/d

换句话说，如果我们取n*d/d
，轻推分子，商也会下降
因此，（check\u count-1）*总计数/检查计数
将小于总计数
。不会发生被零除的情况，因为如果check\u count
为0，则相关循环的迭代次数将为零



快速html/javascript解决方案：
<html>
<body>
<div id='container'></div>
<script>
var cbCount = 111;
var cbCheckCount = 11;
var cbRatio = cbCount / cbCheckCount;
var buildCheckCount = 0;

var c = document.getElementById('container');

for (var i=1; i <= cbCount; i++) {
  // make a checkbox
  var cb = document.createElement('input');
  cb.type = 'checkbox';

  test = i / cbRatio - buildCheckCount;
  if (test >= 1) {
    // check the checkbox we just made
    cb.checked = 'checked';
    buildCheckCount++;
  }

  c.appendChild(cb);
  c.appendChild(document.createElement('br'));
}
</script>
</body></html>


var-cbCount=111；
var cbCheckCount=11；
var cbRatio=cbCount/cbCheckCount；
var buildCheckCount=0；
var c=document.getElementById（'container'）；
对于（变量i=1；i=1）{
//选中我们刚做的复选框
cb.checked=‘checked’；
buildCheckCount++；
}
c、 儿童（cb）；
c、 appendChild（document.createElement（'br'））；
}
调整本月早些时候的代码。设置要检查的复选框和编号，并对截面尺寸应用公式（N*i+N）/M-（N*i）/M
。（另见乔伊·亚当斯的答案。）
在python中，调整后的代码是：
  N=100; M=33; p=0;
  for i in range(M):
     k = (N+N*i)/M
     for j in range(p,k-1): print "-",
     print "x",
     p=k

产生

-x--x--x--x---[…]x--x----x

其中[…]表示25次-x重复。
当M=66时代码给出

 XX-X-X-X-X-X-[…] X-X-X-X-X 
其中…[…]主要代表<代码> XX-<／代码>重复，中间有一个代码> x-< /Cord>。
注意，在C或java中：
将替换为（i=0；i-like算法适用于均匀分布复选框。“x”的输出对应于Y坐标变化。可以选择初始误差作为范围[0..places]中的随机值，以避免偏差
def Distribute(places, stars):
err = places // 2
res = ''
for i in range(0, places):
    err = err - stars
    if err < 0 :
        res = res + 'x'
        err = err + places
    else:
        res = res + '-'
print(res)

Distribute(24,17)
Distribute(24,12)
Distribute(24,5)

output:

x-xxx-xx-xx-xxx-xx-xxx-x

-x-x-x-x-x-x-x-x-x-x-x-x

--x----x----x---x----x--

def分发（地点、星星）：
err=places//2
res=''
对于范围内的i（0个位置）：
err=err-stars
如果误差<0：
res=res+'x'
错误=错误+位置
其他：
res=res+'-'
打印（res）
分发（24,17）
分发（24,12）
分发（24,5）
输出：
x-xxx-xx-xx-xxx-xx-xxx-xx-xxx-x
-x-x-x-x-x-x-x-x-x-x-x-x-x
--x---x---x---x---x--
如何使用
制作数组，洗牌并选择前n个元素。你不需要洗牌所有元素，只需要洗牌数组的前n个。洗牌可以在大多数语言库中找到。
这是什么语言/环境？浏览器？javascript？Windows应用程序？Gnome？KDE？C#但我不认为这有多大关系，伪代码是