Fractionner la chaîne numérique et trouver la somme

Question

Comment écrire une méthode qui prend un seul argument. Le seul argument est une chaîne s, qui contient uniquement des chiffres non nuls.

Cette fonction doit imprimer la longueur de la plus longue sous-chaîne contiguë de l'art, de telle sorte que la longueur de la sous-chaîne est 2 * N chiffres (longueur maximale de la chaîne est 49) et la somme des chiffres de gauche de N est égal à la somme des N chiffres les plus à droite.S'il n'y a pas une telle chaîne, votre fonction devrait imprimer 0

Je suis apprenant à C#. J'ai vu ce puzzle et je n'ai pas réussi à le faire.

Exemple d'entrée: 123.231 et de sortie attendu est 6

Explication:

1 + 2 + 3 = 2 + 3 + 1. La longueur de la plus longue sous-chaîne = 6 où la somme des premier demi = deuxième moitié

Exemple d'entrée # 2: 986561517416921217551395112859219257312 sortie est 36

static int myMethod(string s) { 

var input = "123231"; 
bool expected = 
new System.Text.RegularExpressions.Regex("^[1-9]+$").IsMatch(input); 

return 0; 
} 

Answer 1

Une solution en utilisant beaucoup LINQ, espérons que vous aide. Le "truc" est que vous devez vérifier à la fois les nouvelles versions de la chaîne entière, à savoir lop de premier int ainsi que le dernier. Cette question a été posée auparavant ici à SO bien, mais comme une question C++. Il semble beaucoup plus agréable en C# :)

int GetSumString(string s) 
{ 
    // Convert everything to int[], easier that way in .NET 
    var numbersOrg = s.Select(t => int.Parse(t.ToString())).ToArray(); 

    // Its possible to optimize by using ienumerable and lazy evaluation i guess, but I'm lazy :) 
    var queue = new Queue<int[]>(); 
    queue.Enqueue(numbersOrg); 

    while (queue.Any()) 
    { 
     var numbers = queue.Dequeue(); 

     var firstHalf = numbers.Take(numbers.Length/2).Sum(); 
     var secondHalf = numbers.Skip(numbers.Length/2).Sum(); 
     // It must be of even length (% 2) and the sum of the first half must be equal to the last half. 
     if (numbers.Length % 2 == 0 && firstHalf == secondHalf) 
      return numbers.Length; 

     // Console.WriteLine("tried: " + string.Join("", numbers) + " gave (" + firstHalf + "," + secondHalf + ")"); 
     // Only enqueue when we have something left in the array 
     if (numbers.Length > 1) 
     { 
      queue.Enqueue(numbers.Take(numbers.Length - 1).ToArray()); 
      queue.Enqueue(numbers.Skip(1).ToArray()); 
     } 
    } 
    return 0; 
} 

La solution est en tant que telle qui est fait les contrôles dans le bon ordre, à savoir la première « solution » est GARANTI être la plus longue solution.

Answer 2

boucle juste à travers la possible combinaisons. Exemple pour la chaîne 123231:

1=2   -> fail 
1+2=3+2  -> fail 
1+2+3=2+3+1 -> len=6, longest so far 
2=3   -> fail 
2+3=2+3  -> len=4, not longer 
3=2   -> fail 
3+2=3+1  -> fail 
2=3   -> fail 
3=1   -> fail 

Quelque chose comme ceci:

int longest = 0; 
for (int i = 0; i < str.Length; i++) { 
    for (j = longest + 1; i + j * 2 <= str.Length; j++) { 
    if (sum(str, i, j) == sum(str, i + j, j)) { 
     longest = j; 
    } 
    } 
} 

int sum(string str, int offset, int len) { 
    int s = 0; 
    for (int i = 0; i < len; i++) s += (int)(str[offset + i] - '0'); 
    return s; 
}