Question

我尝试对Codility进行演示测试，以找到阵列的平衡指数。我不确定测试是否要找到数组的平衡指数或什么。我用Google搜索并找到了以下示例：

序列的平衡指数是一个指数，使得较低指数处的元素之和等于较高指数处的元素之和。例如，在序列A：
中
A[0]=-7 A[1]=1 A[2]=5 A[3]=2 A[4]=-4 A[5]=3 A[6]=0

3是均衡指数，因为：

A[0] + A[1] + A[2] = A[4] + A[5] +A[6]

6也是一个均衡指数，因为：

A[0] + A[1] + A[2] + A[3] + A[4] + A[5] = 0

根据这些信息，我看到测试数组包含7个元素。看起来中间元素A[3]=2被忽略了。是因为它介于前3个元素和后3个元素之间？在这个例子中，6的均衡指数是如何得出的？

以下是用于计算此内容的方法：

int equi(int arr[], int n) {
    if (n==0) return -1; 
    long long sum = 0;
    int i; 
    for(i=0;i<n;i++) sum+=(long long) arr[i]; 

    long long sum_left = 0;    
    for(i=0;i<n;i++) {
        long long sum_right = sum - sum_left - (long long) arr[i];
        if (sum_left == sum_right) return i;
        sum_left += (long long) arr[i];
    } 
    return -1; 
}

当我参加Codility演示测试时，我使用了下面的方法，for循环最初从0开始。我收到了错误答案＆＃34; 1, 5, 2, 1, 4, 0的测试用例的消息，并且Codility正在寻找11的结果。

我在我的方法中修改了两个for循环，并在i = 1启动了第一个循环，在i = 2启动了第二个循环，直到它产生了11的结果，Codility对此感到满意。我基本上只是调整了这个方法，直到Codility很高兴（因为Codility指出这是他们正在寻找的答案，因此我的射击时间为11），但我不知道为什么Codility很高兴或者我调整的重要性是什么 - 只是命中和错过：

        ...
        int[] B = new int[] { 1, 5, 2, 1, 4, 0 };

        Console.WriteLine(solution3(B));
    }

    public int solution3(int[] A)
    {
        long rsum = 0;

        for (int i = 1; i < A.Count(); i++)
            rsum += A[i];

        long lsum = A[0];
        int min = (int)Math.Abs(lsum - rsum);

        for (int i = 2; i < A.Count() - 1; i++)
        {
            lsum += A[i];
            rsum -= A[i];
            int diff = (int)Math.Abs(lsum - rsum);
            if (diff >= min)
                min = diff;
        }

        return min;
    }

为什么这个（命中和错过）的调整满足Codility测试？实际上什么是均衡指数？怎么到达？注意：如果步骤A和步骤E之间有步骤（我必须在步骤之间插入）步骤B，C和D是什么？

Answer 1

什么是均衡指数以及如何确定？

将您的阵列视为具有不同尺寸重量的板（负重量可以被认为是连接到板上的氦气球）。每个重量从左到右编号。您的任务是在任何编号位置的板下放置一个支点，以实现电路板平衡。（我们将董事会本身视为失重，并假设权重与中心的距离无关紧要。）无论哪个位置使董事会平衡都是均衡指数。支点处的重量不会“计数”，因为它不在任何一侧;它在中间。

以下是第一个例子的图片：

这里，3是平衡指数，因为支点左边的权重之和等于支点右边的权重之和（-7 + 5 + 1 = -1 = -4 + 3） + 0）。

以下是第二个例子：

由于同样的原因，我们看到6也是一个均衡指数。支点左侧的所有元素加起来为零。由于支点右侧没有元素，因此该总和也为零。

找到均衡指数的基本算法是：

遍历数组并添加所有元素。将此金额称为total。
将变量left_sum初始化为零。
将变量right_sum初始化为total。
现在第二次循环遍历数组。对于每个数组项：
1. 从right_sum。
2. 将left_sum与right_sum进行比较。如果它们相等，那么当前项目的指数就是均衡指数。
3. 将当前项的值添加到left_sum。

这就是它的全部内容。现在有意义吗？

我的算法发生了什么？

至于为什么“Codility演示测试”期望包含元素{ 1, 5, 2, 1, 4, 0 }的数组的结果为11，我不能说。你从未在你的问题中说过实际的演示问题。如果问题是在该数组中找到第一个均衡指数，那么答案是该数组没有。单步执行上述算法，下面是每个数组索引的左右求和：

Index  Left  Right
-----  ----  -----
    0     0     12
    1     1      7
    2     6      5
    3     8      4
    4     9      0
    5    13      0

如您所见，左边的总和没有等于正确总和的索引。 11的预期结果无论如何都没有意义，因为只有六个元素。因此，如果该阵列存在均衡指数，则必须介于0和5之间。所以我猜测提出的问题肯定是别的。在我甚至开始猜测你的算法为什么或不正确之前，你必须在你的问题中包含问题陈述。

Answer 2

嗯，基于我对数组平衡指数的理解，我提出了以下算法，我在另一个数组上测试了平衡指数作为索引3和索引6，但我也在原始数据上测试了这个算法返回-1的数组（与11无关）。以下是样本：

        private void button6_Click_1(object sender, EventArgs e)
    {
        //int[] arr = new int[7] { -7, 1, 5, 2, -4, 3, 0 }; //--new array
        int[] arr = new int[6] { 1, 5, 2, 1, 4, 0 };  //--original array
        List<int> lst = new List<int>();
        int p = arr.Length;
        int i = 0;
        int q = 0;
        int t = 0;
        do
        {
            t = equilibrium(arr, arr.Length, q);
            if (lst.IndexOf(t) == -1)
                lst.Add(t);
            q = t;
            i++;
        } while (i < p);

        foreach (var m in lst)
            Console.WriteLine(m);            
    }

    private int equilibrium( int[] arr, int n, int q1)
    {
       int i, j;
       int leftsum, rightsum;

       for (i = 0; i < n; ++i)
       {
          leftsum = 0;
          rightsum = 0;

          for (j = 0; j < i; j++)
             leftsum += arr[j];

          for (j = i + 1; j < n; j++)
             rightsum += arr[j];

          if (leftsum == rightsum && q1 != i)
             return i;
       }

       return -1;
    }

这个算法对我来说很有意义，但是当我在Codility上尝试使用int [] arr = new int [] {2,2,1,0,1}的数组时;我得到了一个“错误的答案 - 预期3”在我的测试应用程序中，我的算法返回了1，这是它在Codility上返回的内容。他们在哪里为这个阵列拿出3？因此，我不理解数组的均衡指数。任何建议表示赞赏。

阵列的平衡指数如何工作？

2 个答案: