blocks|key|156293|text|这段代码可以工作，但并不美观。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|156294|它首先将所有三个值相除(它对这些值求底，因此您将“丢失”余数)，然后将余数相除：|156295|long+n+=+x+/+3
+++++++++%2B+y+/+3
+++++++++%2B+z+/+3
+++++++++%2B+(+x+%25+3
+++++++++++++%2B+y+%25+3
+++++++++++++%2B+z+%25+3
+++++++++++)+/+3|code-block|syntax|javascript|156296|请注意，当有一个或多个负值时，上述示例并不总是正常工作。|156297|正如Ulugbek所讨论的，由于下面的评论数量呈爆炸式增长，这里是当前正值和负值的最佳解决方案。|156298|感谢Ulugbek+Umirov，James+S，KevinZ，Marc+van+Leeuwen，gnasher729的回答和评论，这是当前的解决方案：|offset|length|156299|static+long+CalculateAverage(long+x,+long+y,+long+z)
{
++++return+(x+%25+3+%2B+y+%25+3+%2B+z+%25+3+%2B+6)+/+3+-+2
++++++++++++%2B+x+/+3+%2B+y+/+3+%2B+z+/+3;
}

static+long+CalculateAverage(params+long[]+arr)
{
++++int+count+=+arr.Length;
++++return+(arr.Sum(n+=>+n+%25+count)+%2B+count+*+(count+-+1))+/+count+-+(count+-+1)
+++++++++++%2B+arr.Sum(n+=>+n+/+count);
}|156300|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/users/1803777/ulugbek-umirov|1|https://stackoverflow.com/users/2463120/james-s|2|https://stackoverflow.com/users/3517622/kevinz|3|https://stackoverflow.com/users/1436796/marc-van-leeuwen|4|https://stackoverflow.com/users/3255455/gnasher729^0|0|0|0|0|0|2|E|0|H|7|1|P|6|2|W|G|3|1D|A|4|0|0^^$0|@$1|2|3|4|5|6|7|18|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|19|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|1A|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|1B|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|1C|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|1D|8|@]|9|@$O|1E|P|1F|1|1G]|$O|1H|P|1I|1|1J]|$O|1K|P|1L|1|1M]|$O|1N|P|1O|1|1P]|$O|1Q|P|1R|1|1S]]|A|$]]|$1|Q|3|R|5|F|7|1T|8|@]|9|@]|A|$G|H]]|$1|S|3|-4|5|6|7|1U|8|@]|9|@]|A|$]]]|T|$U|$5|V|W|X|A|$Y|Z]]|10|$5|V|W|X|A|$Y|11]]|12|$5|V|W|X|A|$Y|13]]|14|$5|V|W|X|A|$Y|15]]|16|$5|V|W|X|A|$Y|17]]]]

This code will work, but isn't that pretty.

It first divides all three values (it floors the values, so you 'lose' the remainder), and then divides the remainder:

<pre><code>long n = x / 3
 + y / 3
 + z / 3
 + ( x % 3
 + y % 3
 + z % 3
 ) / 3
</code></pre>

Note that the above sample does not always work properly when having one or more negative values.

As discussed with Ulugbek, since the number of comments are exploding below, here is the current BEST solution for both positive and negative values.

Thanks to answers and comments of <a href="https://stackoverflow.com/users/1803777/ulugbek-umirov">Ulugbek Umirov</a>, <a href="https://stackoverflow.com/users/2463120/james-s">James S</a>, <a href="https://stackoverflow.com/users/3517622/kevinz">KevinZ</a>, <a href="https://stackoverflow.com/users/1436796/marc-van-leeuwen">Marc van Leeuwen</a>, <a href="https://stackoverflow.com/users/3255455/gnasher729">gnasher729</a> this is the current solution:

<pre><code>static long CalculateAverage(long x, long y, long z)
{
 return (x % 3 + y % 3 + z % 3 + 6) / 3 - 2
 + x / 3 + y / 3 + z / 3;
}

static long CalculateAverage(params long[] arr)
{
 int count = arr.Length;
 return (arr.Sum(n =&gt; n % count) + count * (count - 1)) / count - (count - 1)
 + arr.Sum(n =&gt; n / count);
}
</code></pre>

blocks|key|2741859|text|注意-帕特里克已经给了a+great+answer。在此基础上，您可以为任意数量的整数创建一个通用版本，如下所示：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2741860|long+x+=+long.MaxValue;
long+y+=+long.MaxValue+-+1;
long+z+=+long.MaxValue+-+2;

long[]+arr+=+{+x,+y,+z+};
var+avg+=+arr.Select(i+=>+i+/+arr.Length).Sum()+
++++++++%2B+arr.Select(i+=>+i+%25+arr.Length).Sum()+/+arr.Length;|code-block|syntax|javascript|2741861|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/23949829/839601^0|B|E|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

NB - Patrick has already given <a href="https://stackoverflow.com/a/23949829/839601">a great answer</a>. Expanding on this you could do a generic version for any number of integers like so:

<pre><code>long x = long.MaxValue;
long y = long.MaxValue - 1;
long z = long.MaxValue - 2;

long[] arr = { x, y, z };
var avg = arr.Select(i =&gt; i / arr.Length).Sum() 
 + arr.Select(i =&gt; i % arr.Length).Sum() / arr.Length;
</code></pre>

blocks|key|157469|text|帕特里克·霍夫曼报道了posted+a+great+solution。但如果需要，它仍然可以通过其他几种方式实现。使用here算法，我有了另一个解决方案。如果仔细实现，它可能会比具有缓慢硬件因子的系统中的多个分区更快。通过使用divide+by+constants技术，可以从黑客的喜好中进一步优化它|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|157470|public+class+int128_t+{
++++private+int+H;
++++private+long+L;

++++public+int128_t(int+h,+long+l)
++++{
++++++++H+=+h;
++++++++L+=+l;
++++}

++++public+int128_t+add(int128_t+a)
++++{
++++++++int128_t+s;
++++++++s.L+=+L+%2B+a.L;
++++++++s.H+=+H+%2B+a.H+%2B+(s.L+<+a.L);
++++++++return+b;
++++}

++++private+int128_t+rshift2()++//+right+shift+2
++++{
++++++++int128_t+r;
++++++++r.H+=+H+>>+2;
++++++++r.L+=+(L+>>+2)+%7C+((H+&+0x03)+<<+62);
++++++++return+r;
++++}

++++public+int128_t+divideby3()
++++{
++++++++int128_t+sum+=+{0,+0},+num+=+new+int128_t(H,+L);
++++++++while+(num.H+%7C%7C+num.L+>+3)
++++++++{
++++++++++++int128_t+n_sar2+=+num.rshift2();
++++++++++++sum+=+add(n_sar2,+sum);
++++++++++++num+=+add(n_sar2,+new+int128_t(0,+num.L+&+3));
++++++++}

++++++++if+(num.H+==+0+&&+num.L+==+3)
++++++++{
++++++++++++//+sum+=+add(sum,+1);
++++++++++++sum.L%2B%2B;
++++++++++++if+(sum.L+==+0)+sum.H%2B%2B;
++++++++}
++++++++return+sum;+
++++}
};

int128_t+t+=+new+int128_t(0,+x);
t+=+t.add(new+int128_t(0,+y));
t+=+t.add(new+int128_t(0,+z));
t+=+t.divideby3();
long+average+=+t.L;|code-block|syntax|javascript|157471|在64位平台上的C/C%2B%2B中，使用__int128要容易得多|style|CODE|157472|int64_t+average+=+((__int128)x+%2B+y+%2B+z)/3;|157473|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/23949829/839601|1|https://stackoverflow.com/a/11694778/995714|2|http://www.hackersdelight.org/divcMore.pdf^0|B|N|0|1N|4|1|35|J|2|0|0|H|8|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@$A|11|B|12|1|13]|$A|14|B|15|1|16]|$A|17|B|18|1|19]]|C|$]]|$1|D|3|E|5|F|7|1A|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|1B|8|@$A|1C|B|1D|K|L]]|9|@]|C|$]]|$1|M|3|N|5|F|7|1E|8|@]|9|@]|C|$G|H]]|$1|O|3|-4|5|6|7|1F|8|@]|9|@]|C|$]]]|P|$Q|$5|R|S|T|C|$U|V]]|W|$5|R|S|T|C|$U|X]]|Y|$5|R|S|T|C|$U|Z]]]]

Patrick Hofman has <a href="https://stackoverflow.com/a/23949829/839601">posted a great solution</a>. But if needed it can still be implemented in several other ways. Using the algorithm <a href="https://stackoverflow.com/a/11694778/995714">here</a> I have another solution. If implemented carefully it may be faster than the multiple divisions in systems with slow hardware divisors. It can be further optimized by using <a href="http://www.hackersdelight.org/divcMore.pdf" rel="nofollow noreferrer">divide by constants</a> technique from hacker's delight

<pre><code>public class int128_t {
 private int H;
 private long L;

 public int128_t(int h, long l)
 {
 H = h;
 L = l;
 }

 public int128_t add(int128_t a)
 {
 int128_t s;
 s.L = L + a.L;
 s.H = H + a.H + (s.L &lt; a.L);
 return b;
 }

 private int128_t rshift2() // right shift 2
 {
 int128_t r;
 r.H = H &gt;&gt; 2;
 r.L = (L &gt;&gt; 2) | ((H &amp; 0x03) &lt;&lt; 62);
 return r;
 }

 public int128_t divideby3()
 {
 int128_t sum = {0, 0}, num = new int128_t(H, L);
 while (num.H || num.L &gt; 3)
 {
 int128_t n_sar2 = num.rshift2();
 sum = add(n_sar2, sum);
 num = add(n_sar2, new int128_t(0, num.L &amp; 3));
 }

 if (num.H == 0 &amp;&amp; num.L == 3)
 {
 // sum = add(sum, 1);
 sum.L++;
 if (sum.L == 0) sum.H++;
 }
 return sum; 
 }
};

int128_t t = new int128_t(0, x);
t = t.add(new int128_t(0, y));
t = t.add(new int128_t(0, z));
t = t.divideby3();
long average = t.L;
</code></pre>

In C/C++ on 64-bit platforms it's much easier with <code>__int128</code>

<pre><code>int64_t average = ((__int128)x + y + z)/3;
</code></pre>

blocks|key|2741888|text|您可以根据数字之间的差异来计算数字的平均值，而不是使用总和。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2741889|假设x是最大值，y是中位数，z是最小值(正如你所说的)。我们称它们为最大值、中值和最小值。|2741890|根据@UlugbekUmirov的评论添加了条件检查器：|2741891|long+tmp+=+median+%2B+((min+-+median)+/+2);++++++++++++//Average+of+min+2+values
if+(median+>+0)+tmp+=+median+%2B+((max+-+median)+/+2);+//Average+of+max+2+values
long+mean;
if+(min+>+0)+{
++++mean+=+min+%2B+((tmp+-+min)+*+(2.0+/+3));+//Average+of+all+3+values
}+else+if+(median+>+0)+{
++++mean+=+min;
++++while+(mean+!=+tmp)+{
++++++++mean+%2B=+2;
++++++++tmp--;
++++}
}+else+if+(max+>+0)+{
++++mean+=+max;
++++while+(mean+!=+tmp)+{
++++++++mean--;
++++++++tmp+%2B=+2;
++++}
}+else+{
++++mean+=+max+%2B+((tmp+-+max)+*+(2.0+/+3));
}|code-block|syntax|javascript|2741892|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|O|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|P|8|@]|9|@]|A|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

You can calculate the mean of numbers based on the differences between the numbers rather than using the sum.

Let's say x is the max, y is the median, z is the min (as you have). We will call them max, median and min.

Conditional checker added as per @UlugbekUmirov's comment:

<pre><code>long tmp = median + ((min - median) / 2); //Average of min 2 values
if (median &gt; 0) tmp = median + ((max - median) / 2); //Average of max 2 values
long mean;
if (min &gt; 0) {
 mean = min + ((tmp - min) * (2.0 / 3)); //Average of all 3 values
} else if (median &gt; 0) {
 mean = min;
 while (mean != tmp) {
 mean += 2;
 tmp--;
 }
} else if (max &gt; 0) {
 mean = max;
 while (mean != tmp) {
 mean--;
 tmp += 2;
 }
} else {
 mean = max + ((tmp - max) * (2.0 / 3));
}
</code></pre>

blocks|key|2954639|text|因为C使用floored除法而不是欧几里得除法，所以计算三个无符号值的四舍五入平均值可能比计算三个有符号值更容易。只需在获得无符号平均值之前将0x800000000000000000UL与每个数字相加，在获得结果后减去它，然后使用未经检查的强制转换返回Int64以获得有符号平均值。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2954640|要计算无符号平均值，请计算这三个值的前32位的总和。然后计算三个值的底部32位的和，再加上上面的和，再加上一加一就是四舍五入的结果。平均值是第一次求和的0x55555555倍，再加上第二次求和的三分之一。|2954641|32位处理器上的性能可以通过生成三个"sum“值来增强，每个值都是32位长，因此最终结果是((0x55555555UL+*+sumX)<<32)+%2B+0x55555555UL+*+sumH+%2B+sumL/3；可以通过用((sumL+*+0x55555556UL)+>>+32)替换sumL/3来进一步增强性能，尽管((sumL+*+0x55555556UL)+>>+32)优化器可能知道如何用乘法替换除以3，并且它的代码实际上可能比显式乘法操作更有效。|2954642|entityMap^0|3I|5|0|0|19|1M|31|T|3W|6|4D|T|0^^$0|@$1|2|3|4|5|6|7|L|8|@$9|M|A|N|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|O|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|P|8|@$9|Q|A|R|B|C]|$9|S|A|T|B|C]|$9|U|A|V|B|C]|$9|W|A|X|B|C]]|D|@]|E|$]]|$1|J|3|-4|5|6|7|Y|8|@]|D|@]|E|$]]]|K|$]]

Because C uses floored division rather than Euclidian division, it may easier to compute a properly-rounded average of three unsigned values than three signed ones. Simply add 0x8000000000000000UL to each number before taking the unsigned average, subtract it after taking the result, and use an unchecked cast back to <code>Int64</code> to get a signed average.

To compute the unsigned average, compute the sum of the top 32 bits of the three values. Then compute the sum of the bottom 32 bits of the three values, plus the sum from above, plus one [the plus one is to yield a rounded result]. The average will be 0x55555555 times the first sum, plus one third of the second.

Performance on 32-bit processors might be enhanced by producing three "sum" values each of which is 32 bits long, so that the final result is <code>((0x55555555UL * sumX)&lt;&lt;32) + 0x55555555UL * sumH + sumL/3</code>; it might possibly be further enhanced by replacing <code>sumL/3</code> with <code>((sumL * 0x55555556UL) &gt;&gt; 32)</code>, though the latter would depend upon the JIT optimizer [it might know how to replace a division by 3 with a multiply, and its code might actually be more efficient than an explicit multiply operation].

blocks|key|155076|text|您可以利用这样一个事实，即您可以将每个数字写为y+=+ax+%2B+b，其中x是一个常量。每个a都是y+/+x+(除法的整数部分)。每个b都是y+%25+x+(该除法的剩余/模数)。如果您以智能的方式选择此常量，例如，通过选择最大数的平方根作为常量，则可以获得x数的平均值，而不会出现溢出问题。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|155077|可以通过以下命令找到任意数字列表的平均值：|155078|(+(+sum(+all+A's+)+/+length+)+*+constant+)+%2B+
(+(+sum(+all+A's+)+%25+length+)+*+constant+/+length)+%2B
(+(+sum(+all+B's+)+/+length+)|code-block|syntax|javascript|155079|其中%25表示模数，/表示除法的“整体”部分。|155080|这个程序看起来像这样：|155081|class+Program
{
++++static+void+Main()
++++{
++++++++List<long>+list+=+new+List<long>();
++++++++list.Add(+long.MaxValue+);
++++++++list.Add(+long.MaxValue+-+1+);
++++++++list.Add(+long.MaxValue+-+2+);

++++++++long+sumA+=+0,+sumB+=+0;
++++++++long+res1,+res2,+res3;
++++++++//You+should+calculate+the+following+dynamically
++++++++long+constant+=+1753413056;

++++++++foreach+(long+num+in+list)
++++++++{
++++++++++++sumA+%2B=+num+/+constant;
++++++++++++sumB+%2B=+num+%25+constant;
++++++++}

++++++++res1+=+(sumA+/+list.Count)+*+constant;
++++++++res2+=+((sumA+%25+list.Count)+*+constant)+/+list.Count;
++++++++res3+=+sumB+/+list.Count;

++++++++Console.WriteLine(+res1+%2B+res2+%2B+res3+);
++++}
}|155082|entityMap^0|N|A|10|1|19|1|1C|5|1X|5|3I|1|0|0|0|2|1|8|1|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]|$9|X|A|Y|B|C]|$9|Z|A|10|B|C]|$9|11|A|12|B|C]|$9|13|A|14|B|C]|$9|15|A|16|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|17|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|18|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|19|8|@$9|1A|A|1B|B|C]|$9|1C|A|1D|B|C]]|D|@]|E|$]]|$1|O|3|P|5|6|7|1E|8|@]|D|@]|E|$]]|$1|Q|3|R|5|J|7|1F|8|@]|D|@]|E|$K|L]]|$1|S|3|-4|5|6|7|1G|8|@]|D|@]|E|$]]]|T|$]]

You could use the fact that you can write each of the numbers as <code>y = ax + b</code>, where <code>x</code> is a constant. Each <code>a</code> would be <code>y / x</code> (the integer part of that division). Each b would be <code>y % x</code> (the rest/modulo of that division). If you choose this constant in an intelligent way, for example by choosing the square root of the maximum number as a constant, you can get the average of <code>x</code> numbers without having problems with overflow.

The average of an arbitrary list of numbers can be found by finding:

<pre><code>( ( sum( all A's ) / length ) * constant ) + 
( ( sum( all A's ) % length ) * constant / length) +
( ( sum( all B's ) / length )
</code></pre>

where <code>%</code> denotes modulo and <code>/</code> denotes the 'whole' part of division.

The program would look something like:

<pre><code>class Program
{
 static void Main()
 {
 List&lt;long&gt; list = new List&lt;long&gt;();
 list.Add( long.MaxValue );
 list.Add( long.MaxValue - 1 );
 list.Add( long.MaxValue - 2 );

 long sumA = 0, sumB = 0;
 long res1, res2, res3;
 //You should calculate the following dynamically
 long constant = 1753413056;

 foreach (long num in list)
 {
 sumA += num / constant;
 sumB += num % constant;
 }

 res1 = (sumA / list.Count) * constant;
 res2 = ((sumA % list.Count) * constant) / list.Count;
 res3 = sumB / list.Count;

 Console.WriteLine( res1 + res2 + res3 );
 }
}
</code></pre>

blocks|key|2954803|text|用supercat的修正修补Patrick+Hofman的解决方案，我给你提供以下内容：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2954804|static+Int64+Avg3+(+Int64+x,+Int64+y,+Int64+z+)
{
++++UInt64+flag+=+1ul+<<+63;
++++UInt64+x_+=+flag+%5E+(UInt64)+x;
++++UInt64+y_+=+flag+%5E+(UInt64)+y;
++++UInt64+z_+=+flag+%5E+(UInt64)+z;
++++UInt64+quotient+=+x_+/+3ul+%2B+y_+/+3ul+%2B+z_+/+3ul
++++++++%2B+(+x_+%25+3ul+%2B+y_+%25+3ul+%2B+z_+%25+3ul+)+/+3ul;
++++return+(Int64)+(quotient+%5E+flag);
}|code-block|syntax|javascript|2954805|和N个元素的情况：|2954806|static+Int64+AvgN+(+params+Int64+[+]+args+)
{
++++UInt64+length+=+(UInt64)+args.Length;
++++UInt64+flag+=+1ul+<<+63;
++++UInt64+quotient_sum+=+0;
++++UInt64+remainder_sum+=+0;
++++foreach+(+Int64+item+in+args+)
++++{
++++++++UInt64+uitem+=+flag+%5E+(UInt64)+item;
++++++++quotient_sum+%2B=+uitem+/+length;
++++++++remainder_sum+%2B=+uitem+%25+length;
++++}

++++return+(Int64)+(+flag+%5E+(+quotient_sum+%2B+remainder_sum+/+length+)+);
}|2954807|这总是给出均值的下限()，并消除所有可能的边缘情况。|2954808|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/users/363751/supercat|1|https://stackoverflow.com/users/993547/patrick-hofman^0|1|8|0|E|E|1|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@$A|Z|B|10|1|11]|$A|12|B|13|1|14]]|C|$]]|$1|D|3|E|5|F|7|15|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|16|8|@]|9|@]|C|$]]|$1|K|3|L|5|F|7|17|8|@]|9|@]|C|$G|H]]|$1|M|3|N|5|6|7|18|8|@]|9|@]|C|$]]|$1|O|3|-4|5|6|7|19|8|@]|9|@]|C|$]]]|P|$Q|$5|R|S|T|C|$U|V]]|W|$5|R|S|T|C|$U|X]]]]

Patching <a href="https://stackoverflow.com/users/993547/patrick-hofman">Patrick Hofman</a>'s solution with <a href="https://stackoverflow.com/users/363751/supercat">supercat</a>'s correction, I give you the following:

<pre><code>static Int64 Avg3 ( Int64 x, Int64 y, Int64 z )
{
 UInt64 flag = 1ul &lt;&lt; 63;
 UInt64 x_ = flag ^ (UInt64) x;
 UInt64 y_ = flag ^ (UInt64) y;
 UInt64 z_ = flag ^ (UInt64) z;
 UInt64 quotient = x_ / 3ul + y_ / 3ul + z_ / 3ul
 + ( x_ % 3ul + y_ % 3ul + z_ % 3ul ) / 3ul;
 return (Int64) (quotient ^ flag);
}
</code></pre>

And the N element case:

<pre><code>static Int64 AvgN ( params Int64 [ ] args )
{
 UInt64 length = (UInt64) args.Length;
 UInt64 flag = 1ul &lt;&lt; 63;
 UInt64 quotient_sum = 0;
 UInt64 remainder_sum = 0;
 foreach ( Int64 item in args )
 {
 UInt64 uitem = flag ^ (UInt64) item;
 quotient_sum += uitem / length;
 remainder_sum += uitem % length;
 }

 return (Int64) ( flag ^ ( quotient_sum + remainder_sum / length ) );
}
</code></pre>

This always gives the floor() of the mean, and eliminates every possible edge case.

blocks|key|2954820|text|如果你知道你有N个值，你能将每个值除以N并将它们相加吗？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2954821|long+GetAverage(long*+arrayVals,+int+n)
{
++++long+avg+=+0;
++++long+rem+=+0;

++++for(int+i=0;+i<n;+%2B%2Bi)
++++{
++++++++avg+%2B=+arrayVals[i]+/+n;
++++++++rem+%2B=+arrayVals[i]+%25+n;
++++}

++++return+avg+%2B+(rem+/+n);
}|code-block|syntax|javascript|2954822|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

If you know you have N values, can you just divide each value by N and sum them together?

<pre><code>long GetAverage(long* arrayVals, int n)
{
 long avg = 0;
 long rem = 0;

 for(int i=0; i&lt;n; ++i)
 {
 avg += arrayVals[i] / n;
 rem += arrayVals[i] % n;
 }

 return avg + (rem / n);
}
</code></pre>

blocks|key|2742170|text|此函数在两个除法中计算结果。它应该很好地推广到其他除数和单词大小。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2742171|它的工作原理是计算双字相加结果，然后计算除法。|2742172|Int64+average(Int64+a,+Int64+b,+Int64+c)+{
++++//+constants:+0x10000000000000000+div/mod+3
++++const+Int64+hdiv3+=+UInt64(-3)+/+3+%2B+1;
++++const+Int64+hmod3+=+UInt64(-3)+%25+3;

++++//+compute+the+signed+double-word+addition+result+in+hi:lo
++++UInt64+lo+=+a;+Int64+hi+=+a>=0+?+0+:+-1;
++++lo+%2B=+b;+hi+%2B=+b>=0+?+lo<b+:+-(lo>=UInt64(b));
++++lo+%2B=+c;+hi+%2B=+c>=0+?+lo<c+:+-(lo>=UInt64(c));

++++//+divide,+do+a+correction+when+high/low+modulos+add+up
++++return+hi>=0+?+lo/3+%2B+hi*hdiv3+%2B+(lo%253+%2B+hi*hmod3)/3
+++++++++++++++++:+lo/3%2B1+%2B+hi*hdiv3+%2B+Int64(lo%253-3+%2B+hi*hmod3)/3;
}|code-block|syntax|javascript|2742173|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

This function computes the result in two divisions. It should generalize nicely to other divisors and word sizes.

It works by computing the double-word addition result, then working out the division.

<pre><code>Int64 average(Int64 a, Int64 b, Int64 c) {
 // constants: 0x10000000000000000 div/mod 3
 const Int64 hdiv3 = UInt64(-3) / 3 + 1;
 const Int64 hmod3 = UInt64(-3) % 3;

 // compute the signed double-word addition result in hi:lo
 UInt64 lo = a; Int64 hi = a&gt;=0 ? 0 : -1;
 lo += b; hi += b&gt;=0 ? lo&lt;b : -(lo&gt;=UInt64(b));
 lo += c; hi += c&gt;=0 ? lo&lt;c : -(lo&gt;=UInt64(c));

 // divide, do a correction when high/low modulos add up
 return hi&gt;=0 ? lo/3 + hi*hdiv3 + (lo%3 + hi*hmod3)/3
 : lo/3+1 + hi*hdiv3 + Int64(lo%3-3 + hi*hmod3)/3;
}
</code></pre>

blocks|key|157676|text|数学|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|157677|(x+%2B+y+%2B+z)+/+3+=+x/3+%2B+y/3+%2B+z/3

(a[1]+%2B+a[2]+%2B+..+%2B+a[k])+/+k+=+a[1]/k+%2B+a[2]/k+%2B+..+%2B+a[k]/k|code-block|syntax|javascript|157678|代码|157679|long+calculateAverage+(long+a+[])
{
++++double+average+=+0;

++++foreach+(long+x+in+a)
++++++++average+%2B=+(Convert.ToDouble(x)/Convert.ToDouble(a.Length));

++++return+Convert.ToInt64(Math.Round(average));
}

long+calculateAverage_Safe+(long+a+[])
{
++++double+average+=+0;
++++double+b+=+0;

++++foreach+(long+x+in+a)
++++{
++++++++b+=+(Convert.ToDouble(x)/Convert.ToDouble(a.Length));

++++++++if+(b+>=+(Convert.ToDouble(long.MaxValue)-average))
++++++++++++throw+new+OverflowException+();

++++++++average+%2B=+b;
++++}

++++return+Convert.ToInt64(Math.Round(average));
}|157680|entityMap^0|0|2|0|0|0|2|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@]|E|$]]|$1|M|3|N|5|H|7|X|8|@]|D|@]|E|$I|J]]|$1|O|3|-4|5|6|7|Y|8|@]|D|@]|E|$]]]|P|$]]

Math

<pre><code>(x + y + z) / 3 = x/3 + y/3 + z/3

(a[1] + a[2] + .. + a[k]) / k = a[1]/k + a[2]/k + .. + a[k]/k
</code></pre>

Code

<pre><code>long calculateAverage (long a [])
{
 double average = 0;

 foreach (long x in a)
 average += (Convert.ToDouble(x)/Convert.ToDouble(a.Length));

 return Convert.ToInt64(Math.Round(average));
}

long calculateAverage_Safe (long a [])
{
 double average = 0;
 double b = 0;

 foreach (long x in a)
 {
 b = (Convert.ToDouble(x)/Convert.ToDouble(a.Length));

 if (b &gt;= (Convert.ToDouble(long.MaxValue)-average))
 throw new OverflowException ();

 average += b;
 }

 return Convert.ToInt64(Math.Round(average));
}
</code></pre>

blocks|key|157682|text|我也尝试过，并提出了一个更快的解决方案(尽管只有大约3/4)。它使用一个单独的除法|type|unstyled|depth|inlineStyleRanges|entityRanges|data|157683|public+static+long+avg(long+a,+long+b,+long+c)+{
++++final+long+quarterSum+=+(a>>2)+%2B+(b>>2)+%2B+(c>>2);
++++final+long+lowSum+=+(a&3)+%2B+(b&3)+%2B+(c&3);
++++final+long+twelfth+=+quarterSum+/+3;
++++final+long+quarterRemainder+=+quarterSum+-+3*twelfth;
++++final+long+adjustment+=+smallDiv3(lowSum+%2B+4*quarterRemainder);
++++return+4*twelfth+%2B+adjustment;
}|code-block|syntax|javascript|157684|其中，smallDiv3使用乘法除以3，并且仅适用于小参数|offset|length|style|CODE|157685|private+static+long+smallDiv3(long+n)+{
++++assert+-30+<=+n+&&+n+<=+30;
++++//+Constants+found+rather+experimentally.
++++return+(64/3*n+%2B+10)+>>+6;
}|157686|这是一个包含测试和基准测试的whole+code，results没有那么令人印象深刻。|157687|entityMap|0|LINK|mutability|MUTABLE|url|https://dl.dropboxusercontent.com/u/4971686/published/maaartin/so/Avg3Benchmark.java|1|https://microbenchmarks.appspot.com/runs/d3bfdd45-0918-4f39-a63a-a03b60e4e31c#r:scenario.benchmarkSpec.methodName^0|0|0|3|9|0|0|E|A|0|P|7|1|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|12|8|@$I|13|J|14|K|L]]|9|@]|A|$]]|$1|M|3|N|5|D|7|15|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|16|8|@]|9|@$I|17|J|18|1|19]|$I|1A|J|1B|1|1C]]|A|$]]|$1|Q|3|-4|5|6|7|1D|8|@]|9|@]|A|$]]]|R|$S|$5|T|U|V|A|$W|X]]|Y|$5|T|U|V|A|$W|Z]]]]

I also tried it and come up with a faster solution (although only by a factor about 3/4). It uses a single division

<pre><code>public static long avg(long a, long b, long c) {
 final long quarterSum = (a&gt;&gt;2) + (b&gt;&gt;2) + (c&gt;&gt;2);
 final long lowSum = (a&amp;3) + (b&amp;3) + (c&amp;3);
 final long twelfth = quarterSum / 3;
 final long quarterRemainder = quarterSum - 3*twelfth;
 final long adjustment = smallDiv3(lowSum + 4*quarterRemainder);
 return 4*twelfth + adjustment;
}
</code></pre>

where <code>smallDiv3</code> is division by 3 using multipliation and working only for small arguments

<pre><code>private static long smallDiv3(long n) {
 assert -30 &lt;= n &amp;&amp; n &lt;= 30;
 // Constants found rather experimentally.
 return (64/3*n + 10) &gt;&gt; 6;
}
</code></pre>

Here is the <a href="https://dl.dropboxusercontent.com/u/4971686/published/maaartin/so/Avg3Benchmark.java" rel="nofollow">whole code</a> including a test and a benchmark, the <a href="https://microbenchmarks.appspot.com/runs/d3bfdd45-0918-4f39-a63a-a03b60e4e31c#r:scenario.benchmarkSpec.methodName" rel="nofollow">results</a> are not that impressive.

blocks|key|2954949|text|试试这个：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2954950|long+n+=+Array.ConvertAll(new[]{x,y,z},v=>v/3).Sum()
+++++%2B++(Array.ConvertAll(new[]{x,y,z},v=>v%253).Sum()+/+3);|code-block|syntax|javascript|2954951|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Try this:

<pre><code>long n = Array.ConvertAll(new[]{x,y,z},v=&gt;v/3).Sum()
 + (Array.ConvertAll(new[]{x,y,z},v=&gt;v%3).Sum() / 3);
</code></pre>

I have 3 very large signed integers.

<pre><code>long x = long.MaxValue;
long y = long.MaxValue - 1;
long z = long.MaxValue - 2;
</code></pre>

I want to calculate their truncated average. Expected average value is <code>long.MaxValue - 1</code>, which is <code>9223372036854775806</code>.

It is impossible to calculate it as:

<pre><code>long avg = (x + y + z) / 3; // 3074457345618258600
</code></pre>

Note: I read all those questions about average of 2 numbers, but I don't see how that technique can be applied to average of 3 numbers.

It would be very easy with the usage of <code>BigInteger</code>, but let's assume I cannot use it.

<pre><code>BigInteger bx = new BigInteger(x);
BigInteger by = new BigInteger(y);
BigInteger bz = new BigInteger(z);
BigInteger bavg = (bx + by + bz) / 3; // 9223372036854775806
</code></pre>

If I convert to <code>double</code>, then, of course, I lose precision:

<pre><code>double dx = x;
double dy = y;
double dz = z;
double davg = (dx + dy + dz) / 3; // 9223372036854780000
</code></pre>

If I convert to <code>decimal</code>, it works, but also let's assume that I cannot use it.

<pre><code>decimal mx = x;
decimal my = y;
decimal mz = z;
decimal mavg = (mx + my + mz) / 3; // 9223372036854775806
</code></pre>

Question: Is there a way to calculate the truncated average of 3 very large integers only with the usage of <code>long</code> type? Don't consider that question as C#-specific, just it is easier for me to provide samples in C#.

Average of 3 long integers

我有3个非常大的有符号整数。long x = long.MaxValue;long y = long.MaxValue - 1;long z = long.MaxValue - 2;我想计算它们的截断平均值。预期平均值为9223372036854775806的long.MaxValue - 1。它不可能计算为：long...

问3个长整型的平均值
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问3个长整型的平均值EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问3个长整型的平均值
EN