Question

My question for today is:
How can I make function that could find all words matching the pattern?

For example we have word: duck and we want find all words starting from that word duck.

I am looking for best perfomance function, I would be glad if it could be using LINQ.
So far I made something like that (it doesn’t work yet):

public List<List<string>> FindWordsPostfix(List<Parameters.Words> wordsChess, List<string> wordsFromDictionary, int width)
    {
        List<List<string>> listPostfixForstructxIndex = new List<List<string>>();

        foreach (Parameters.Words structx in wordsChess)
        {
            //1for each structx I have some parameters eg. name, length, index
            //2for each word (name) I need find word from dict. starting that word(name)

            //list storing lists of words for each of the structx object
            List<string> list = new List<string>();

            foreach (String wordDictionary in wordsFromDictionary)
            {
                Match match = Regex.Match(wordDictionary, structx.word, RegexOptions.IgnoreCase);
                if(match.Success && (match.Length > structx.length))
                {
                    list.Add(match.Value);
                }

            }
            //add list of words to main list
            listPostfixForstructxIndex.Add(list);
        }
        throw new NotImplementedException();
    }

Parameters.Words is a struct containing: string name, int length, etc...

Why my function is bad and doesn’t storing any data?

PS2. I edited the question. I had to clean up that mess what I did.

Answer 1

if(match.Success && (match.Length > struct.dlugosc))

The Match’s length is never going to be longer than the struct’s length – the struct’s length at minimum is that of the string, plus all the other items in it.

What else were you testing for after match.Success?

If you want some matching code for what I think you’re asking for, the following works a charm:

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;

using System.Text.RegularExpressions;

namespace Word_Ending_Finder
{
    public partial class Form1 : Form
    {
        private List<string> WordsToFind = new List<string>();
        private List<MySpecialStringStruct> PassagesToSearch = new List<MySpecialStringStruct>();

        public Form1()
        {
            InitializeComponent();
            PassagesToSearch.Add(new MySpecialStringStruct("This is a test passage with a test ending.", 0));
            PassagesToSearch.Add(new MySpecialStringStruct("This is a second test passage with a test ending.", 0));
            PassagesToSearch.Add(new MySpecialStringStruct("This is a third passage that won't match.", 0));

            WordsToFind.Add(@"ing\b");
            WordsToFind.Add(@"\bsecond\b");
            WordsToFind.Add(@"\bgarbage text\b");
        }

        private void bnGo_Click(object sender, EventArgs e)
        {
            txtResults.Text = "";
            string Separator = "------------------------------------------";

            StringBuilder NewText = new StringBuilder();
            foreach (string SearchWord in WordsToFind)
            {
                NewText.AppendLine(string.Format("Now searching {0}", SearchWord));
                List<MatchValue> Results = FindPassages(PassagesToSearch, SearchWord);
                if (Results.Count == 0)
                {
                    NewText.AppendLine("No Matches Found");
                }
                else
                {
                    foreach (MatchValue ThisMatch in Results)
                    {
                        NewText.AppendLine(string.Format("In passage \"{0}\":", ThisMatch.WhichStringStruct.Passage));
                        foreach (Match M in ThisMatch.MatchesFound)
                        {
                            NewText.AppendLine(string.Format("\t{0}", M.Captures[0].ToString()));
                        }
                    }
                }
                NewText.AppendLine(Separator);
            }

            txtResults.Text = NewText.ToString();
        }

        private List<MatchValue> FindPassages(List<MySpecialStringStruct> PassageList, string WhatToFind)
        {
            Regex MatchPattern = new Regex(WhatToFind);
            List<MatchValue> ReturnValue = new List<MatchValue>();
            foreach (MySpecialStringStruct SearchTarget in PassageList)
            {
                MatchCollection MatchList = MatchPattern.Matches(SearchTarget.Passage);
                if (MatchList.Count > 0)
                {
                    MatchValue FoundMatchResult = new MatchValue();
                    FoundMatchResult.WhichStringStruct = SearchTarget;
                    FoundMatchResult.MatchesFound = MatchList;
                    ReturnValue.Add(FoundMatchResult);
                }
            }
            return ReturnValue;
        }
    }

    public class MatchValue
    {
        public MySpecialStringStruct WhichStringStruct;
        public MatchCollection MatchesFound;
    }

    public struct MySpecialStringStruct
    {
        public string Passage;
        public int Id;

        public MySpecialStringStruct(string passage, int id)
        {
            Passage = passage;
            Id = id;
        }
    }
}

The output:

Now searching ing\b
In passage "This is a test passage with a test ending.":
ing
In passage "This is a second test passage with a test ending.":
ing
------------------------------------------
Now searching \bsecond\b
In passage "This is a second test passage with a test ending.":
second
------------------------------------------
Now searching \bgarbage text\b
No Matches Found
------------------------------------------