C++ 求C+中左右和相等的最长子串+；

我在解决一个问题，我遇到了一些问题：

完成函数getEqualSumSubstring，它只接受一个参数。单参数是一个字符串

s

，它只包含非零数字。 此函数应打印

s

的最长连续子串的长度，使子串的长度为2*N位，最左边的N位之和等于最右边的N位之和。如果没有此类字符串，则函数应打印0

int getEqualSumSubstring（字符串s）{
int i=0，j=i，foundLength=0；
对于（i=0；i以下代码不应该使用tempString.length（）而不是s.length（）吗

此代码有效

int getEqualSumSubstring(string s) {
    int i=0,j=i,foundLength=0;
    for(i=0;i<s.length();i++)
    {
        for(j=i;j<s.length();j++)
        {
            int temp = j-i+1;

            if(temp%2==0)
            {
                int leftSum=0,rightSum=0;
                string tempString=s.substr(i,temp);
                // printf("%d ",tempString.length());
                for(int k=0;k<temp/2;k++)
                {
                    leftSum=leftSum+tempString[k]-48;
                    rightSum=rightSum+tempString[k+(temp/2)]-48;
                }
                if((leftSum==rightSum)&&(leftSum!=0))
                    if(tempString.length()>foundLength)
                    foundLength=tempString.length(); 
            }
        }
    }
    return(foundLength);
}

int getEqualSumSubstring（字符串s）{
int i=0，j=i，foundLength=0；
对于（i=0；i这两行中的数字48的基本原理是什么

for(int k=0;k<temp/2;k++)
{
    leftSum=leftSum+tempString[k]-48;
    rightSum=rightSum+tempString[k+(temp/2)]-48;
}

for（int k=0；k
下面是我的问题代码…谢谢！！
公共类国际公司{
公共字符串getEqualSumSubstring_com（字符串s）
{
int j；
int num=0；
整数和=0；
int m=s.长度（）；
//计算字符串数组长度
对于（int i=m；i>1；i--）
{
sum=sum+m；
m=m-1；
}
字符串[]d=新字符串[总和]；
int k=0；
字符串ans=“NULL”；
//提取字符串
对于（int i=0；i=i+1；k++，j--）
{
num=k；
d[k]=s.子串（i，j）；
}
k=num+1；
}
//对字符串进行排序，使最长的字符串位于。。。
对于（int i=0；i这是我的解决方案，我可以确认它是有效的。上面的解决方案对我来说并不有效——它们不知怎么地给了我编译错误。我在InterviewStreet上遇到了同样的问题，提出了一个糟糕的、不完整的解决方案，适用于9/15个测试用例，因此我不得不花更多的时间编写代码

其思想是，我将从给定输入的每一半（左半部分和右半部分）中获取所有可能的子字符串，对它们进行排序并将其附加到两个单独的列表中，然后查看是否存在匹配项，而不是关心获取左和右的和（这也是我最初做的）

为什么?

假设字符串“423”和“234”的总和相同；如果我对它们进行排序，它们都将是“234”，因此匹配。由于这些数字必须是连续的且长度相等，因此我不再需要担心将它们作为数字相加并进行检查

例如，如果我得到12345678，那么在左边，for循环会给我：

[1,121231234,2,23234,3,34]

右边：

[5,5675678，…]

等等

但是，我只考虑长度至少为2的子字符串

我将这些子字符串中的每一个都附加到ArrayList中，通过转换为字符数组，然后再转换回字符串进行排序

现在所有这些都完成了，下一步是看看这两个数组列表中是否有相同数字的相同字符串。我只需将temp_b的每个字符串与temp_a的第一个字符串进行检查，然后与temp_a的第二个字符串进行检查，依此类推

如果我得到一个匹配项（比如“234”和“234”），我会将这些匹配子字符串的长度设置为我的tempCount（tempCount=3）。我还有另一个名为“count”的变量来跟踪这些匹配子字符串的最大长度（如果这是匹配项的第一次出现，那么count=0会被tempCount=3覆盖，因此count=3）

对于带有变量int end的奇数/偶数字符串长度，原因是在代码s.length（）/2+j行中，输入的长度恰好是11，然后：

s、 长度（）=11

s、 长度（）/2=11/5=5.5=5

因此在for循环中，s.length（）/2+j，其中j在s.length（）/2处最大，将变成：

5+5=10

它没有达到获取字符串最后一个索引所需的s.length（）

这是因为子字符串函数需要的结束索引比您为charAt（i）之类的内容设置的索引大1

为了演示，输入“47582139875”将生成以下输出：
[47，457，4578，24578，57，578，2578，58，258，28]这是我对这个问题的解决方案，包括测试。我添加了一个额外的函数，只是因为我觉得它比上面的解决方案更容易阅读

#include <string>
#include <iostream>

using namespace std;

int getMaxLenSumSubstring( string s ) 
{
    int N = 0; // The optimal so far...

int leftSum = 0, rightSum=0, strLen=s.size();
int left, right;

for(int i=0;i<strLen/2+1;i++) {
    left=(s[i]-int('0')); right=(s[strLen-i-1]-int('0'));
    leftSum+=left; rightSum+=right;

    if(leftSum==rightSum) N=i+1;
}

return N*2;
}

int getEqualSumSubstring( string s ) {
    int maxLen = 0, substrLen, j=1;

for( int i=0;i<s.length();i++ ) {
    for( int j=1; j<s.length()-i; j++ ) {
        //cout<<"Substring = "<<s.substr(i,j);
        substrLen = getMaxLenSumSubstring(s.substr(i,j));
        //cout<<", Len ="<<substrLen;
        if(substrLen>maxLen) maxLen=substrLen;
    }
}

return maxLen;
}

#包括
#包括
使用名称空间std；
int getMaxLenSumSubstring（字符串s）
{
int N=0；//到目前为止的最佳值。。。
int leftSum=0，rightSum=0，strLen=s.size（）；
int左，右；
对于（inti=0；i，这里是这个问题的完整Java程序。
复杂性为O（n^3）
不过，这可以在O（n^2）中解决。有关O（n^2）复杂性解决方案，请参阅

import java.util.Scanner；
导入静态java.lang.System.out；
公共类子串问题{
公共静态void main（字符串参数[]）{
扫描仪sc=新的扫描仪（System.in）；
println（“输入数字字符串：”）；
字符串s=sc.nextLine（）；
int n=（new SubStringProblem（））.getEqualSumSubString（s）；
out.println（“最长和子字符串为”+n）；
}
public int getEqualSumSubString（字符串s）{
int N；
如果（s.length（）%2==0）
{
//绳子是平的
N=s.长度（）；
}
否则{
//字符串是奇数
N=s.长度（）-1；
}
布尔标志=假；
int sum1，sum2；
做{
for（int k=0；kSimple solution.O（n*n）.s-输入字符串

var longest = 0;
for (var i = 0; i < s.length-1; i++) {
    var leftSum = rightSum = 0;

    for (var j = i, k = i+1, l = 2; j >=0 && k < s.length; j--, k++, l+=2) {
        leftSum += parseInt(s[j]);
        rightSum += parseInt(s[k]);

        if (leftSum == rightSum && l > longest) {
            longest = l;
        }
    }
}

console.log(longest);

var最长=0；
对于（变量i=0；i=0&&k最长）{
最长=l；
}
}
}
console.log（最长）；
<
 Below is my code for the question... Thanks !!


    public class IntCompl {

        public String getEqualSumSubstring_com(String s)
        {
            int j;
            int num=0;
            int sum = 0;
            int m=s.length();

            //calculate String array Length

            for (int i=m;i>1;i--)
            {
                sum = sum + m;
                m=m-1;
            }
            String [] d = new String[sum];
            int k=0;
            String ans = "NULL";

            //Extract strings

            for (int i=0;i<s.length()-1;i++)
            {
            for (j=s.length();j>=i+1;k++,j--)
            {
                num = k;
                d[k] = s.substring(i,j);
            }
            k=num+1;
            }

            //Sort strings in such a way that the longest strings precede...

            for (int i=0; i<d.length-1; i++)
            {
                for (int h=1;h<d.length;h++)
                {
                if (d[i].length() > d[h].length())
                 {
                    String temp;
                    temp=d[i];
                    d[i]=d[h];          
                    d[h]=temp;
                 }
                }       
            }

            // Look for the Strings with array size 2*N (length in even number) and such that the 
            //the sum of left N numbers is = to the sum of right N numbers.
            //As the strings are already in decending order, longest string is searched first and break the for loop once the string is found.

            for (int x=0;x<d.length;x++)
            {
                int sum1=0,sum2=0;
                if (d[x].length()%2==0 && d[x].length()<49)
                {
                    int n;
                    n = d[x].length()/2;
                    for (int y=0;y<n;y++)
                    {
                        sum1 = sum1 + d[x].charAt(y)-'0';
                    }
                    for (int y=n;y<d[x].length();y++)
                    {
                        sum2 = sum2 + d[x].charAt(y)-'0';
                    }
                    if (sum1==sum2)
                    {
                        ans = d[x];
                        break;
                    }

                }
            }
                return ans;

            }
        }

public static int getEqualSumSubtring(String s){

    // run through all possible length combinations of the number string on left and right half
    // append sorted versions of these into new ArrayList

    ArrayList<String> temp_a = new ArrayList<String>();
    ArrayList<String> temp_b = new ArrayList<String>();

    int end; // s.length()/2 is an integer that rounds down if length is odd, account for this later 

    for( int i=0; i<=s.length()/2; i++ ){
        for( int j=i; j<=s.length()/2; j++ ){
            // only account for substrings with a length of 2 or greater
            if( j-i > 1 ){ 
                char[] tempArr1 = s.substring(i,j).toCharArray();
                Arrays.sort(tempArr1);
                String sorted1 = new String(tempArr1);
                temp_a.add(sorted1);
                //System.out.println(sorted1);

                if( s.length() % 2 == 0 )
                    end = s.length()/2+j;
                else // odd length so we need the extra +1 at the end
                    end = s.length()/2+j+1; 
                char[] tempArr2 = s.substring(i+s.length()/2, end).toCharArray();
                Arrays.sort(tempArr2);
                String sorted2 = new String(tempArr2);
                temp_b.add(sorted2);
                //System.out.println(sorted2);
            }

        }

    }

    // For reference
    System.out.println(temp_a);
    System.out.println(temp_b);

    // If the substrings match, it means they have the same sum

    // Keep track of longest substring
    int tempCount = 0 ;
    int count = 0;
    String longestSubstring = "";

    for( int i=0; i<temp_a.size(); i++){
        for( int j=0; j<temp_b.size(); j++ ){
            if( temp_a.get(i).equals(temp_b.get(j)) ){

                tempCount = temp_a.get(i).length();

                if( tempCount > count ){
                    count = tempCount;
                    longestSubstring = temp_a.get(i);

                }
            }

        }
    }

    System.out.println(longestSubstring);
    return count*2;
}

#include <string>
#include <iostream>

using namespace std;

int getMaxLenSumSubstring( string s ) 
{
    int N = 0; // The optimal so far...

int leftSum = 0, rightSum=0, strLen=s.size();
int left, right;

for(int i=0;i<strLen/2+1;i++) {
    left=(s[i]-int('0')); right=(s[strLen-i-1]-int('0'));
    leftSum+=left; rightSum+=right;

    if(leftSum==rightSum) N=i+1;
}

return N*2;
}

int getEqualSumSubstring( string s ) {
    int maxLen = 0, substrLen, j=1;

for( int i=0;i<s.length();i++ ) {
    for( int j=1; j<s.length()-i; j++ ) {
        //cout<<"Substring = "<<s.substr(i,j);
        substrLen = getMaxLenSumSubstring(s.substr(i,j));
        //cout<<", Len ="<<substrLen;
        if(substrLen>maxLen) maxLen=substrLen;
    }
}

return maxLen;
}

int main() {
    cout<<endl<<"Test 1 :"<<getEqualSumSubstring(string("123231"))<<endl;

    cout<<endl<<"Test 2 :"<<getEqualSumSubstring(string("986561517416921217551395112859219257312"))<<endl;

    cout<<endl<<"Test 3:"<<getEqualSumSubstring(string("47582139875"))<<endl;

}

import java.util.Scanner;
import static java.lang.System.out;
 public class SubStringProblem{
  public static void main(String args[]){
 Scanner sc = new Scanner(System.in);
 out.println("Enter the Digit String:");
 String s = sc.nextLine();
 int n = (new SubStringProblem()).getEqualSumSubString(s);
 out.println("The longest Sum SubString is "+n);
 }
    public int getEqualSumSubString(String s){
 int N;
 if(s.length()%2==0)
 {
    //String is even
    N = s.length();     
 }
 else{ 
    //String is odd
    N=s.length()-1;
 }
 boolean flag =false;
 int sum1,sum2;
 do{    
    for(int k=0;k<=s.length()-N;k++){   
        sum1=0;
        sum2=0;
        for(int i =k,j=k+N-1;i<j;i++,j--)
        {   
            sum1=sum1 + Integer.parseInt(s.substring(i,i+1));
            sum2+=Integer.parseInt(s.substring(j,j+1));
        }
        if(sum1==sum2){
        return N;
        }
    }   
    N-=2;
 flag =true;
}while(N>1);
return -1;
}
}

var longest = 0;
for (var i = 0; i < s.length-1; i++) {
    var leftSum = rightSum = 0;

    for (var j = i, k = i+1, l = 2; j >=0 && k < s.length; j--, k++, l+=2) {
        leftSum += parseInt(s[j]);
        rightSum += parseInt(s[k]);

        if (leftSum == rightSum && l > longest) {
            longest = l;
        }
    }
}

console.log(longest);