Extrait de nombre à la fin de la chaîne en C#

Probablement au cours de l'analyse de ce un peu, mais comment stackoverflow suggérer, c'est la meilleure façon de retourner un entier qui est contenue à la fin d'une chaîne.

Jusqu'à présent j'ai pensé à utiliser une simple boucle, LINQ et les regex, mais je suis curieux de savoir quelles sont les approches que je vais obtenir de la communauté. Évidemment, ce n'est pas un problème difficile à résoudre mais qui aurait pu allouer de la variance dans les solutions.

Donc, pour être plus précis, comment voulez-vous créer une fonction pour renvoyer un arbitrairement long entier long qui est ajouté à la fin de la arbitrairement une longue chaîne de caractères?

CPR123 => 123
ABCDEF123456 => 123456

regex [0-9]+$

OriginalL'auteur Maxim Gershkovich | 2012-11-01

.net c#parsing regex

Utiliser cette expression régulière:

\d+$

var result = Regex.Match(input, @"\d+$").Value;

ou à l'aide de Stack, probablement plus efficace:

var stack = new Stack<char>();

for (var i = input.Length - 1; i >= 0; i--)
{
    if (!char.IsNumber(input[i]))
    {
        break;
    }

    stack.Push(input[i]);
}

var result = new string(stack.ToArray());

OriginalL'auteur Kirill Polishchuk

14

Obligatoire LINQ one-liner
```
var input = "ABCD1234";
var result = string.Concat(input.ToArray().Reverse().TakeWhile(char.IsNumber).Reverse());
```
Je pense que ses le grand de toutes les réponses. J'ai été à la recherche pour cela. Merci!

OriginalL'auteur ttu
3

Regex serait le plus simple, dans la mesure de mon expérience.
```
Regex ex = new Regex(@"(\d+)$")
```
Cela devrait correspondre. Simplement conclure que dans une fonction.

Les parenthèses dans l'expression rationnelle sont inutiles 😉 (et même d'engager des frais généraux, qui est ce que l'OP a voulu éviter)
Na pas savoir que, mais là encore, j'ai juste appris à propos de Regex moins de 4 jours dans la classe lol 🙂 Merci de me laisser savoir, si.

OriginalL'auteur Jason Renaldo
2
```
[^0-9]+([0-9]+)
```
devrait le faire je pense

Que faire si il y sont des entiers avant de l'un à l'extrémité de la chaîne? Que faire si il n'y a pas de non-chiffres avant l'entier à la fin de la chaîne?
Que " pas ce qu'il a demandé, ses exemples ont été pour les lettres, les chiffres. De toute façon, comme je l'ai dit, Kirill la réponse est mieux parce que c'est plus simple & traite à la fois les situations de toute façon
Hm d'accord. J'ai lu "arbitrairement longue chaîne" en tant que "chaîne de caractères arbitraire". Aussi "arbitrariy long" comprend 0-longueur, je suppose.
Il fait, mais dans ce cas, je ne pense pas que c'est ce qu'il voulait dire, je l'aurais fait normalement vérifier que de l'extérieur à un Regex de toute façon

OriginalL'auteur Glenn Slaven
1

Est-il toujours dans le format LettersNumbers?

Dans ce cas, ce serait le travail:
```
Regex _cellAddressRegex = new Regex(@"(?<Column>[a-z]+)(?<Row>[0-9]+)", RegexOptions.Compiled | RegexOptions.IgnoreCase);
var rowm = Convert.ToInt32(parts.Groups["Row"]);
```
Je ne voudrais pas utiliser le Compiled option. Vous payez un important coût initial pour compiler les regex en MSIL, quand autant que vous savez que c'est seulement gong pour être utilisé une fois, et c'est tellement simple qu'il ne sera probablement pas bénéficier de l'optimisation de toute façon.
En effet. J'ai pris cela à partir d'une base de code de la mine où il fait sens, mais pour une fois, il ne le fait pas.

OriginalL'auteur Michael Stum
1

Regex motif comme \d+$ est un peu cher étant donné que, par défaut, une chaîne est analysée à partir de la gauche vers la droite. Une fois que le moteur d'expressions régulières trouve 1 dans 12abc34, il va de match 2, et quand il rencontre a, le match est omis, la position suivante est essayé, et ainsi de suite.

Toutefois, dans .NET regex, il y a un RegexOptions.RightToLeft modificateur. Il fait le moteur d'expressions régulières analyser la chaîne de droite à gauche et vous pouvez obtenir les matchs qui sont connus pour être plus près de la fin, beaucoup plus rapidement.
```
var result = Regex.Match("000AB22CD1234", @"\d+$", RegexOptions.RightToLeft);
if (result.Success) 
{ 
    Console.Write(result.Value);
}  //=> 1234
```
Voir le en ligne C# démo.

OriginalL'auteur Wiktor Stribiżew

Une simple boucle devrait probablement battu toute autre solution d'une simplicité et d'efficacité. Et le final de la chaîne renvoyée est peut être juste une fois copié sans l'utilisation de la Pile, StringBuilder, chaîne.Concat ou d'autres plus complexes de la chaîne des fonctions de soutien.

string GetNumberFromEnd(string text)
{
    int i = text.Length - 1;
    while (i >= 0)
    {
        if (!char.IsNumber(text[i])) break;
        i--;
    }
    return text.Substring(i + 1);
}

Ou il peut même être retourné directement que le type int:

bool GetIntFromEnd(string text, out int number)
{
    int i = text.Length - 1;
    while (i >= 0)
    {
        if (!char.IsNumber(text[i])) break;
        i--;
    }
    return int.TryParse(text.Substring(i + 1), out number);
}

OriginalL'auteur Chronos

Suis-je autorisé à aller fou avec cette?

using System.Text;
using System.Linq;

static string GetNum(string input)
{
    StringBuilder sb = new StringBuilder();
    for (int i = input.Length - 1; i >= 0; i--)
    {
        if (input[i] < 48 || input[i] > 57)
            break;

        sb.Append(input[i]);
    }

    return String.Concat(sb.ToString().ToCharArray().Reverse());
}

OriginalL'auteur Ichabod Clay

Vous devez vous connecter pour publier un commentaire.