Statistics 求整数数组的平均值

假设您有一个int数组（在任何具有固定大小int的语言中）。如何计算最接近其平均值的整数

编辑：为了清楚起见，结果不必出现在数组中。也就是说，对于输入数组[3,6,7]，预期结果是5。另外，我想我们需要指定一个特定的舍入方向，所以，如果你接近两个数字，就说向下舍入

编辑：这不是家庭作业。我已经五年没做作业了。这是我第一次在stackoverflow上，所以请友好点

---

编辑：显而易见的求和和和除法可能会溢出，因此我尝试考虑一种溢出安全的方法，适用于大型数组和大型整数。我认为正确处理溢出（不作弊，不使用其他类型）是这个问题最困难的部分。

通过将数字相加，除以数字，并舍入来计算总和：

mean = (int)((sum + length/2) / length;

如果您担心溢出，可以执行以下操作：

int mean = 0, remainder = 0
foreach n in number
   mean += n / length
   remainder += n % length
   if remainder > length
       mean += 1
       remainder -= length
if remainder > length/2
   mean += 1
print "mean is: " mean

---

请注意，这不是很快。

嗯。。。计算平均值，然后四舍五入到整数，怎么样<代码>舍入（mean（thearray））大多数语言都有允许您指定舍入方法的工具

编辑：所以这个问题实际上是关于避免溢出，而不是关于舍入。让我明确一点，我同意（在评论中）有人所说的，在实践中不需要担心，因为这种情况很少发生，当它发生时，您总是可以使用更大的数据类型

我看到其他几个人给出的答案基本上是将数组中的每个数字除以数组的计数，然后相加。这也是一个好办法。但为了好玩，这里有一个替代方案（在C-ish伪代码中）：

---

琐事：这种方法，或者类似的方法，对于计算元素紧密聚集在一起的数组的平均值也非常有效。

欢迎使用。鱼，希望你在这里过得愉快

下面的伪代码显示了在总和适合整数类型的情况下如何执行此操作，并将四舍五入到最接近的整数

在您的示例中，数字加和为16，除以3得到5 1/3，即四舍五入为5

sum = 0
for i = 1 to array.size
    sum = sum + array[i]
sum = sum / array.size
sum = round (sum)

---

用于获取平均值的伪代码：

double mean = 0
int count = 0
foreach int number in numbers
    count++
    mean += number - mean / count

round(mean) // rounds up
floor(mean + 0.5) // rounds up
ceil(mean - 0.5) // rounds down

四舍五入通常涉及添加0.5，然后截断（地板），这就是为什么3.5四舍五入为4。如果要将3.5向下四舍五入，请自己进行四舍五入编码，但顺序相反：减去0.5，然后找到上限

---

编辑：更新的需求（无溢出）

此伪代码查找平均值并涵盖溢出问题：

double avg = 0
int count = 0
for x in array:
    count += 1
    avg = avg * (count - 1) / count   // readjust old average
    avg += x / count                  // add in new number

length ← length of list
average ← 0
for each result in the list do:
    average ← average + ( result / length )
end for

之后，您可以应用舍入代码。如果在您的语言中没有简单的取整方法，那么类似的方法将起作用（超过0.5时取整）：

int-temp=avg-int（avg）//查找小数部分
如果温度这里有一种快速、合理的溢出安全的方法，并且当元素数量事先未知时，可以工作

// The length of someListOfNumbers doesn't need to be known in advance.
int mean(SomeType someListOfNumbers) {  
    double mean = 0, count = 0;
    foreach(element; someListOfNumbers) {
        count++;
        mean += (element - mean) / count;
    }
    if(count == 0) {
        throw new UserIsAnIdiotException(
                  "Problem exists between keyboard and chair.");
    }
    return cast(int) floor(mean);
}

保证不会溢出：

double avg = 0
int count = 0
for x in array:
    count += 1
    avg = avg * (count - 1) / count   // readjust old average
    avg += x / count                  // add in new number

length ← length of list
average ← 0
for each result in the list do:
    average ← average + ( result / length )
end for

如果使用ints，由于截断（六个4的平均值为0），这在精确度方面会有很大的问题。
手臂装配。=]未经测试。不会溢出。曾经（我希望如此。）

可能会被优化一点。（可能使用FP/LR？）=S可能拇指在这里工作得更好

.arm

; r0 = pointer to array of integers
; r1 = number of integers in array
; returns mean in r0
mean:
stmfd sp!, {r4,r5}
mov r5, r1

mov r2, 0          ; sum_lo
mov r3, 0          ; sum_hi

cmp r1, 0          ; Check for empty array
bz .end

.loop:
ldr r4, [r0], #4
add r2, r2, r4
adc r3, r3, #0     ; Handle overflow
sub r1, r1, #1     ; Next
bnz .loop

.end:
div r0, r2, r3, r5 ; Your own 64-bit/32-bit divide: r0 = (r3r2) / r5
bx lr

你会如何计算平均数？@fish-我不是大卫，但就个人而言，我会计算平均数，将所有数字相加，然后将结果除以它们的计数，即除以有多少个数字。这通常是计算平均值的一种非常有效的方法。这是一个很好的开始，但余数+=n%长度仍然可能在较大长度时溢出。例如，如果长度为INT_MAX/2+2，数组中的前两个条目为INT_MAX/2+1，我们将溢出。这可能会发生，但在什么体系结构上，内存中可以有大小为：）的数组。。此外，它也不能很好地处理负数。通过添加不使用更大数据类型的人为限制，看起来您只是有点困难。请解释一下你为什么不能这样做。我想这更像是一个理论问题。在这里，我们有一个简单的，处处定义的函数，我们在小学时学过，如果不跳出函数的范围，似乎很难安全地计算它。更实际地说，可能没有更大的类型。总是有更大的类型，即使您必须自己实现它。任何其他解决方案都有失去准确性的风险，因为您正在添加不同比例的数字。这可能是允许的，这取决于你想要什么。这个问题从一开始就可以/应该用更好的措辞：我回答这个问题时，它似乎是关于四舍五入，但实际上是关于避免溢出。我很想编辑和重写它，但我不确定这是否合适……不会溢出，因为您使用的是浮点，或者您给出的答案不准确（大多数情况下）。
length ← length of list
average ← 0
for each result in the list do:
    average ← average + ( result / length )
end for

.arm

; r0 = pointer to array of integers
; r1 = number of integers in array
; returns mean in r0
mean:
stmfd sp!, {r4,r5}
mov r5, r1

mov r2, 0          ; sum_lo
mov r3, 0          ; sum_hi

cmp r1, 0          ; Check for empty array
bz .end

.loop:
ldr r4, [r0], #4
add r2, r2, r4
adc r3, r3, #0     ; Handle overflow
sub r1, r1, #1     ; Next
bnz .loop

.end:
div r0, r2, r3, r5 ; Your own 64-bit/32-bit divide: r0 = (r3r2) / r5
bx lr