C++ 求一个关于余度的算法

最小化值|（A[0]+…+A[p-1]）-（A[p]+…+A[N-1]）|

重要的

确保有效地处理所有角落案例和大型输入。不要假设，不要相信任何人

所以我尝试了蛮力apporach，但是我得到了66%的正确率，并且我没有通过一个只有两个数字的测试用例

int solution(vector<int> &a) {
   int sumLeft = 0;
     int sumRight = 0;
     int minDiff = 9999999;
    for(int b=0; b< a.size();b++)
    { 
            
    sumLeft+=a[b];
    sumRight = 0;       
    for (int j = b+1; j < a.size();j++)
            
    {
        sumRight+=a[j];
            
    }

    int diff = abs(sumLeft - sumRight);

    if ( diff < minDiff )
    {

        minDiff = diff;
    }
    
    }

  return minDiff;
}

int解决方案（向量&a）{
int sumleet=0；
int sumRight=0；
int minDiff=9999999；
对于（int b=0；b

确保有效地处理所有角落案例和大型输入。不要假设，不要相信任何人

如果您有编号

10^17

和

10^16

？然后，最小差值大于您初始化的

minDiff

这也解释了为什么只有两个数字的测试用例失败

我至少会使用64位整数，尽管问题陈述暗示这些值甚至可能超过64位整数。如果你想用C++来解决这个问题，那是个坏消息。

这个如何？< /P>

int solution(vector<int> &a) {
    int sumLeft = 0;
    int sumRight = 0;

    for(int b=0; b< a.size();b++)
        sumRight += a[b];

    int minDiff = sumRight;

    for(int b=0; b< a.size();b++)
    {
        sumLeft  += a[b];
        sumRight -= a[b];

        int diff = abs(sumLeft - sumRight);

        if ( diff < minDiff )
        {
            minDiff = diff;
        }
    }

    return minDiff;
}

int解决方案（向量&a）{
int sumleet=0；
int sumRight=0；
对于（int b=0；b

此解决方案获得100%通过率。 这个任务中的棘手时刻是考虑到两个分区必须是非空的

#include <algorithm>

int solution(vector<int> &A) {
    auto n= 0;
    for(auto& ai: A) {
        ai+= n;
        n= ai;
    }
    auto f_diff=
    [&A](int ai) {
        return abs(A.back() - (ai + ai));
    };
    auto min_diff= f_diff(A.front());
    for_each(next(begin(A)), prev(end(A)), [&](int ai) {
        auto diff= f_diff(ai);
        if(diff < min_diff) {
            min_diff= diff;
        }
    });
    return min_diff;

    // write your code in C++11
}

#包括
整数解（向量&A）{
自动n=0；
用于（自动和人工智能：A）{
ai+=n；
n=ai；
}
自动f_差异=
[&A]（国际人工智能）{
返回abs（A.back（）-（ai+ai））；
};
自动最小偏差=最小偏差（A.前（））；
对于每个（下一个（开始（A）），上一个（结束（A）），[&]（内部ai）{
自动差异=f_差异（ai）；
如果（差值<最小差值）{
最小差值=差值；
}
});
返回最小差值；
//用C++11编写代码
}

以下解决方案将为您提供100%的C语言覆盖率和性能#

public int解决方案（int[]A）
{
long MindDifference=Int32.MaxValue；
长底和=0；
长表层=0；
长期总计=总金额（）；
for（int i=0；iif（数学绝对值（底部和-顶部）但是你想达到什么目的？你函数的目的是什么？它有什么问题？这使得算法更有效，但如果数字很大，它仍然会失败。编辑-initial
minDiff
计算方式不同。我想用
MAX\u INT
初始化minDiff

，但它可能没有定义；试试看使用

（int）（~0U>>1）

那么。你是如何得出这个解决方案的？我应该学习离散数学吗？它真的很聪明哪一个解决方案？如果你指的是代码组织，它很简单：分区点的每一次移动都会删除

a[b]

从一部分添加到另一部分，因此您可以增量修改两个和，只需提前计算其中一个。与初始化表达式有关的是，U2代码的最大值为

int

：除最左边的位（符号位）外的所有位都已设置。我通过取无符号的零0U，然后求反~0U（产生所有位1），然后右移一位（~0U>>1），使符号位为零。然后我转换为

（int）

.Done.我将minDiff改为INT\u MAX，但两个数字仍然失败错误答案双两个元素得到0预期2000

#include <algorithm>

int solution(vector<int> &A) {
    auto n= 0;
    for(auto& ai: A) {
        ai+= n;
        n= ai;
    }
    auto f_diff=
    [&A](int ai) {
        return abs(A.back() - (ai + ai));
    };
    auto min_diff= f_diff(A.front());
    for_each(next(begin(A)), prev(end(A)), [&](int ai) {
        auto diff= f_diff(ai);
        if(diff < min_diff) {
            min_diff= diff;
        }
    });
    return min_diff;

    // write your code in C++11
}

public int solution(int[] A)
        {
            long minDifference = Int32.MaxValue;
            long bottomSum = 0;
            long topSum = 0;

            long total = A.Sum();

            for (int i = 0; i < A.Length-1; i++)
            {
                bottomSum += A[i];
                topSum =(long) (total - bottomSum);

                if (Math.Abs(bottomSum - topSum) <= minDifference) 
                {
                    minDifference = Math.Abs(bottomSum - topSum);
                }
            }
            return Convert.ToInt32(minDifference);
        }