Trouver tous les postes de sous-chaîne dans une chaîne plus longue en C#

Pourquoi ne pas utiliser le construit en classe RegEx:

public static IEnumerable<int> GetAllIndexes(this string source, string matchString)
{
   matchString = Regex.Escape(matchString);
   foreach (Match match in Regex.Matches(source, matchString))
   {
      yield return match.Index;
   }
}

Si vous avez besoin de réutiliser l'expression puis de les compiler et de les mettre en cache quelque part. Modifier la matchString param pour une Regex matchExpression dans une autre surcharge pour la réutilisation de cas.

Version polie + cas en ignorant support:

public static int[] AllIndexesOf(string str, string substr, bool ignoreCase = false)
{
    if (string.IsNullOrWhiteSpace(str) ||
        string.IsNullOrWhiteSpace(substr))
    {
        throw new ArgumentException("String or substring is not specified.");
    }

    var indexes = new List<int>();
    int index = 0;

    while ((index = str.IndexOf(substr, index, ignoreCase ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal)) != -1)
    {
        indexes.Add(index++);
    }

    return indexes.ToArray();
}

Salut belle réponse par @Matti Virkkunen

public static List<int> AllIndexesOf(this string str, string value) {
    if (String.IsNullOrEmpty(value))
        throw new ArgumentException("the string to find may not be empty", "value");
    List<int> indexes = new List<int>();
    for (int index = 0;; index += value.Length) {
        index = str.IndexOf(value, index);
        if (index == -1)
            return indexes;
        indexes.Add(index);
        index--;
    }
}

Mais cela couvre les cas de test comme AOOAOOA
où la sous-chaîne

sont AOOA et AOOA

Sortie 0 et 3

J'ai remarqué qu'au moins deux solutions proposées n'est pas gérer le chevauchement des résultats de recherche. Je n'ai pas vérifier l'un marqué avec la coche verte. Ici est celui qui traite le chevauchement des résultats de recherche:

    public static List<int> GetPositions(this string source, string searchString)
    {
        List<int> ret = new List<int>();
        int len = searchString.Length;
        int start = -1;
        while (true)
        {
            start = source.IndexOf(searchString, start +1);
            if (start == -1)
            {
                break;
            }
            else
            {
                ret.Add(start);
            }
        }
        return ret;
    }

public static Dictionary<string, IEnumerable<int>> GetWordsPositions(this string input, string[] Susbtrings)
{
    Dictionary<string, IEnumerable<int>> WordsPositions = new Dictionary<string, IEnumerable<int>>();
    IEnumerable<int> IndexOfAll = null;
    foreach (string st in Susbtrings)
    {
        IndexOfAll = Regex.Matches(input, st).Cast<Match>().Select(m => m.Index);
        WordsPositions.Add(st, IndexOfAll);

    }
    return WordsPositions;
}

J'ai trouvé ce exemple et intégrés dans une fonction:

    public static int solution1(int A, int B)
{
//Check if A and B are in [0...999,999,999]
if ( (A >= 0 && A <= 999999999) && (B >= 0 && B <= 999999999))
{
if (A == 0 && B == 0)
{
return 0;
}
//Make sure A < B
if (A < B)
{                    
//Convert A and B to strings
string a = A.ToString();
string b = B.ToString();
int index = 0;
//See if A is a substring of B
if (b.Contains(a))
{
//Find index where A is
if (b.IndexOf(a) != -1)
{                            
while ((index = b.IndexOf(a, index)) != -1)
{
Console.WriteLine(A + " found at position " + index);
index++;
}
Console.ReadLine();
return b.IndexOf(a);
}
else
return -1;
}
else
{
Console.WriteLine(A + " is not in " + B + ".");
Console.ReadLine();
return -1;
}
}
else
{
Console.WriteLine(A + " must be less than " + B + ".");
//Console.ReadLine();
return -1;
}                
}
else
{
Console.WriteLine("A or B is out of range.");
//Console.ReadLine();
return -1;
}
}
static void Main(string[] args)
{
int A = 53, B = 1953786;
int C = 78, D = 195378678;
int E = 57, F = 153786;
solution1(A, B);
solution1(C, D);
solution1(E, F);
Console.WriteLine();
}

Retourne:

53 trouvé à la position 2

78 trouvé à la position 4

78 trouvé à la position 7

57 n'est pas dans 153786