Travailler sur un mot, un dilemme en utilisant une chaîne de caractères, un tableau de caractères ou un générateur de chaînes de caractères ?

Question

Je travaille sur un échecs (pas de grille). Ce site échecs (pas de grille) a X rangées.
Dans chacune des rangées, nous avons Y blocs.

Je voudrais savoir quels mots je peux trouver dans chacune des rangées. De plus, quels sont les index de début et de fin des mots.

Donc ma tactique pour une rangée est :

• Prendre tous les éléments de la ligne (-cat--dog----) et les sauvegarder dans une chaîne de caractères.
• opérer sur les indices de la chaîne en utilisant for(...){...}

Est-ce une bonne idée ou peut-être devrais-je convertir cette chaîne en tableau de caractères et ensuite opérer ?

Quelle est la méthode la plus rapide pour y parvenir ? Qu'en est-il de StringBuilder ?

@Oden thx pour la correction mais je ne voulais pas dire grille mais juste une échecs :)

---

Quelque part, j'ai mal écrit cette question. (Peut-être ai-je mal formulé la question. C'est difficile de donner une forme à cette question pour moi, alors désolé).

La question du problème principal a été simplement incluse dans le titre principal de ce sujet.
Quelle méthode serait la plus rapide lors du traitement de plusieurs mots par exemple ? mamma--mia (chaque élément est un symbole ansi, disons au format chaîne) ?

Je me demande donc si, si je ne travaillais que sur une chaîne de caractères, il serait plus rapide de convertir d'abord la chaîne enCharArray et de travailler ensuite. Ou peut-être en utilisant stringBuilder.

Je demande simplement ce qui est plus rapide : le travail ou les caractères, les chaînes ou les éléments du constructeur de chaînes dans ma méthode :( Ce qui serait plus rapide dans une grande fonction/méthode -> c'est la question.

Answer 1

Je suggère
1) créer un objet pour contenir les points,
2) modulariser les parties pour analyser la chaîne de caractères (de préférence dans une classe, mais une méthode ferait l'affaire),
3) utilisez ensuite LINQ pour obtenir toutes les lignes contenant les valeurs de la colonne que vous recherchez.

Un exemple est le suivant :

void Main()
{
    const string columnName = "ColumnYouSeek";

    var dgv = GetDataGridView(columnName);  
    var items = GetItems(dgv, columnName);
    // items now contains what you want
}    

Créez un objet pour contenir vos valeurs

 class ItemWithIndex
 {
    public string Text { get; set; }
    public int StartIndex { get; set; }
    public int EndIndex { get; set; }

    public override string ToString()
    {
        return string.Format(
                 "{0}: Starts at {1}, Ends at {2}", 
                 Text, StartIndex, EndIndex);
     }
 }

Modifiez le texte ci-dessous pour pointer vers votre DataGridView.

public System.Windows.Forms.DataGridView GetDataGridView(string columnName)
{
    var dgv = new System.Windows.Forms.DataGridView();
    var column = new System.Windows.Forms.DataGridViewTextBoxColumn();
    column.DataPropertyName = columnName;
    column.Name = columnName;
    dgv.Columns.Add(column);
    dgv.Rows.Add("-cat--dog----");
    dgv.Rows.Add("--elephant----mouse----");
    return dgv;
}

Modulariser pour obtenir des articles

public IEnumerable<ItemWithIndex> GetItems(
        System.Windows.Forms.DataGridView dgv, string columnName)
{
    var rows = dgv.Rows.Cast<System.Windows.Forms.DataGridViewRow>();   
    var rowData = rows.Select(x => (x.Cells[columnName].Value ?? "").ToString());
    return rowData.SelectMany(x => GetWords(x));
}    

Modulariser les portions pour obtenir les mots individuels
Note : Ceci peut être testé en unité et refactorisé.

public IEnumerable<ItemWithIndex> GetWords(string val)
{
    var index = val.IndexOf("-");
    while (index >= 0 && index + 1 < val.Length)
    {
        var startIndex = index + 1;
        var endIndex = val.IndexOf("-", startIndex);
        if (endIndex < 0)
            endIndex = val.Length - 1; // end of string
        var text = val.Substring(startIndex, endIndex - startIndex);
        index = endIndex;
        if (string.IsNullOrEmpty(text))
            continue;
        yield return new ItemWithIndex
                        {
                            Text = text,
                            StartIndex = startIndex,
                            EndIndex = endIndex,
                        };
    }
}

Answer 2

Le goulot d'étranglement des performances auquel vous êtes confronté n'est pas dans la construction de la chaîne, mais dans la recherche des mots que vous recherchez. Si vous avez m les mots que vous cherchez, vous pourriez finir par parcourir la chaîne en cherchant des mots m temps. Ce n'est pas nécessaire ! Vous pouvez essayer de créer une énorme expression régulière * correspondant à toutes les sous-chaînes que vous recherchez. De la manière dont ils sont construits *, ils ne transmettent la chaîne qu'une seule fois (en fait, si vous commencez par un 'a', ils sont dans un état qui leur dit "cela pourrait être le début de tous les mots commençant par a", si le caractère suivant est un 'b', l'état dit "cela pourrait être soit le début d'un mot commençant par ab, soit le début d'un mot commençant par b").

• http://www.regular-expressions.info/dotnet.html
• http://en.wikipedia.org/wiki/Finite-state_machine

Answer 3

On dirait que vous devriez utiliser un tableau bidimensionnel de chaînes - string[,] ou un tableau en dents de scie (selon que chaque ligne a le même nombre de blocs ou non).

Une autre option est d'utiliser une liste générique de listes. List<List<string>> .

L'une ou l'autre de ces options vous permet d'interroger directement vos données par index.