要检查一列非负整数是否平衡，可以想象一下将各个权重放在板上，然后尝试将板平衡在枢轴上，以使枢轴左右的汇总相对权重相同。相对重量是通过将其重量乘以其到枢轴的距离得出的（请参见杠杆定律）。

^{（来源：维基百科）}

该图像对应于一个列表[100, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5]。该列表是平衡的，因为5到枢轴的距离为20，而到枢轴100的距离为1和5*20 = 100 = 100*1。

例子

 3 1 5 7
#########
     ^

在这种情况下，枢轴位于的正下方5，3具有距离2和1且7具有距离1。因此，枢轴的左侧和右侧的两边总计为7（3*2 + 1*1在左侧和7*1右侧），因此列表[3, 1, 5, 7]是平衡的。

但是请注意，枢轴不必放在列表元素之一的下面，而也可以放在两个列表元素之间：

 6 3 1
#######
  ^

在这种情况下，距离变为0.5, 1.5, 2.5, ...依此类推。此列表也是平衡的，因为6*0.5 = 3 = 3*0.5 + 1*1.5。

枢轴只能放置在一个数字的正下方或两个数字之间的正中，而不能放置在两个数字之间的三分之二处。

任务

考虑到非负整数的列表，在任何合理的格式，输出truthy如果列表可以值平衡和falsy否则值。

您可以假定输入列表包含至少两个元素，并且至少一个元素为非零。

这是一个代码挑战，因此每种语言中字节数最少的答案将获胜。

真实的测试用例

[1, 0]
[3, 1, 5, 7]
[6, 3, 1]
[100, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5]
[10, 4, 3, 0, 2, 0, 5]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[7, 7, 7, 7]

虚假的测试用例

[1, 2]
[3, 6, 5, 1, 12]
[0, 0, 2, 0, 1, 0]
[1, 2, 3, 4, 5, 6, 7, 8, 9]
[6, 3, 2, 4, 0, 1, 2, 3]
[4, 0, 0, 2, 3, 5, 2, 0, 1, 2, 3, 0, 0, 1, 2, 4, 3, 1, 3, 0, 0, 2]
[100, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5]

_{在沙盒化过程中发现了许多相关的挑战： 数量是否均衡？，序列的均衡指数，平衡在跷跷板上一组权重，平衡话，我将翻倒？和哪里枢轴属于？}

Pyth，12个 10字节

!%ys*VQUQs

在线尝试

感谢Xcoder先生和Outgolfer的Erik，节省了2个字节。

说明

!%ys*VQUQs
    *VQUQ    Multiply each input by its index.
  ys         Take twice the sum (to handle half-integer positions).
!%       sQ  Check if that's a multiple of the total weight.

Wolfram语言（Mathematica），36字节

IntegerQ[2#.Range[t=Tr[1^#]]/(t-1)]&

这是坐标系中的质心问题，其原点位于这些点之一，然后确定CM是否落在晶格宽度= 1/2的晶格点上。

在线尝试！

05AB1E，6个字节

ƶO·IOÖ

在线尝试！

怎么样？

·O·IOÖ〜完整程序。I =输入。

Lift〜提升I.将每个元素与其从1开始的索引相乘。
 喔〜
  ·〜双。 
     Ö〜是的倍数？
   IO〜I之和

果冻，6个字节

×JSḤọS

在线尝试！

好吧，看起来Leaky Nun指出了毫无意义。

使用助记符的Pyth方法。

返回正整数（真）或零（伪）。

R，34个字节

function(n)!(n%*%seq(n)*2)%%sum(n)

在线尝试！

将输入作为向量。Ports 助记符的答案。返回一个1x1矩阵。

Japt，10字节

í* x*2 vUx

在线尝试！

说明：

 í* x*2 vUx
U            // Implicit Input                 [3, 1, 5, 7]
 í           // Pair the input with its index  [[3,0],[1,1],[5,2],[7,3]]
  *          // Multiply each item             [0,1,10,21]
    x        // Sum                            32
     *2      // Double                         64
        v    // Divisible by:
         Ux  //   Sum of Input                 16
             // Explicit Output                1

返回1真相，0虚假。

Python 2，41个字节

S=s=0
for n in input():S-=s;s-=n
1>>2*S%s

输出是通过退出代码进行的，因此0为真实，1为虚假。

在线尝试！

朱莉娅，31 27字节

@Dennis节省了4个字节

!n=2n[i=1:end]⋅i%sum(n)<1

在线尝试！

Ruby，47个字节

多亏了Xcoder先生，节省了2个字节

->k{(k.map.with_index{|x,i|x*i*2}.sum%k.sum)<1}

在线尝试！

C， 140个  137字节

float l,r;i,j,t;f(L,n)int*L;{for(i=t=-1;++i<2*n;t*=l-r)for(l=r=j=0;j<n;++j)l+=j<i/2.?L[j]*(i/2.-j):0,r+=j>i/2.?L[j]*(j-i/2.):0;return!t;}

在线尝试！

Python 3，51个字节

lambda k:sum(i*e*2for i,e in enumerate(k))%sum(k)<1

在线尝试！

Perl 6、23个字节

{sum(1..*Z*$_)*2%%.sum}

测试一下

使用其他各种条目中的算法。

展开：

{  # bare block lambda with implicit parameter ｢$_｣

    sum(

        1 .. *  # Range starting from 1

      Z*        # Zip using &infix:«*»

        $_      # the input

    ) * 2

  %%            # is divisible by

    .sum        # the sum of the input (implicit method call on ｢$_｣)
}

Japt，11 10 8字节

最初受Mnemonic解决方案启发

x* vUx*½

试试吧

1由于ETHproductions，节省了3个字节。

说明

数组的隐式输入U。通过加法（x）进行缩减，从而将每个元素乘以基于0的索引（*）。检查结果是否被v原始输入（Ux）的总和平均除（），并且每个元素都乘以0.5（*½）。

C＃，71字节

打高尔夫球

a=>{int i,s,S=s=i=0;while(i<a.Length){S-=s;s-=a[i++];}return 2*S%s<1;};

不打高尔夫球

a => {
    int
        i, s, S = s = i = 0;

    while( i < a.Length ) {
        S -= s;
        s -= a[ i++ ];
    }

    return 2 * S % s < 1;
};

完整代码

using System;

namespace Namespace {
    class Program {
        static void Main( String[] args ) {
            Func<Int32[], Boolean> f = a => {
                int
                    i, s, S = s = i = 0;

                while( i < a.Length ) {
                    S -= s;
                    s -= a[ i++ ];
                }

                return 2 * S % s < 1;
            };

            List<Int32[]>
                testCases = new List<Int32[]>() {
                    new Int32[] {1, 0},
                    new Int32[] {3, 1, 5, 7},
                    new Int32[] {6, 3, 1},
                    new Int32[] {100, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5},
                    new Int32[] {10, 4, 3, 0, 2, 0, 5},
                    new Int32[] {1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
                    new Int32[] {7, 7, 7, 7},

                    new Int32[] {1, 2},
                    new Int32[] {3, 6, 5, 1, 12},
                    new Int32[] {0, 0, 2, 0, 1, 0},
                    new Int32[] {1, 2, 3, 4, 5, 6, 7, 8, 9},
                    new Int32[] {6, 3, 2, 4, 0, 1, 2, 3},
                    new Int32[] {4, 0, 0, 2, 3, 5, 2, 0, 1, 2, 3, 0, 0, 1, 2, 4, 3, 1, 3, 0, 0, 2},
                    new Int32[] {100, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5},
                };

            foreach( Int32[] testCase in testCases ) {
                Console.WriteLine( $"{{ {String.Join(", ", testCase)} }}\n{f( testCase )}" );
            }

            Console.ReadLine();
        }
    }
}

发布

• 1.0 - 71 bytes-初始溶液。

笔记

我可能有，也可能没有，很“借用” Dennis Python 2解决方案 ...

Haskell，39个字节

f l=2*sum(zipWith(*)l[0..])`mod`sum l<1

在线尝试！

APL（Dyalog），15字节

0≡+⌿|(+⌿+⍨×⍳∘≢)

在线尝试！

对我来说看起来很讨厌

Python 2中，78 75个字节

感谢Xcoder先生的-3个字节

lambda l:0in[sum(v*(i-y*2)for y,v in enumerate(l))for i in range(len(l)*2)]

在线尝试！

朱莉娅0.6，25字节

~=sum
!x=~cumsum(2x)%~x<1

在线尝试！

PHP，139128字节

<?php $a=explode(',',fgets(STDIN));for($i=0;$i<count($a)-.5;$i+=.5){$z=0;foreach($a as $k=>$v)$z+=($k-$i)*$v;if($z==0)die(1);}?>

在线尝试！

• -2字节，用于消除周围的引号，die这要归功于manassehkatz
• -9个字节归功于学习社区标准

迅捷，76字节

{var i=0,t=0;print($0.reduce(0){$0+($1*i,t+=$1,i+=1).0}*2%t<1)}as([Int])->()

在线尝试！

Perl 5，55 +1（a）= 56字节

$.=0;map$.+=$p++*$_,@F;$#F+($p=$i-=.5)&&$.&&redo;say!$.

在线尝试！