C#

public static string BetweenChars(this string text, char left, char right)
{
    string result = string.Empty;
    int leftPos = text.IndexOf(left, 0)+1;
    int rightPos = text.LastIndexOf(right);
    if (leftPos >= 0 && rightPos > leftPos)
    {
        result = text.Substring(leftPos, rightPos - leftPos);
    }
    return result;
}

public static void DelimiterPos(this string text, char left, char right, out int leftPos, out int rightPos)
{
    string result = string.Empty;
    leftPos = text.IndexOf(left, 0);
    rightPos = text.LastIndexOf(right);
}

if (textBox1.TextLength == 3)
{
textBox2.Focus();
}
if (textBox2.TextLength == 3)
{
textBox1.Focus();
}

//check if length is 3 for both textboxes before checking equality.
if(textbox1.TextLength == 3 && textbox2.TextLength == 3){
if (textBox1.Text == textBox2.Text)
{
textBox3.Text = "PASSED";
textBox1.Clear();
textBox2.Clear();
textBox1.Focus();
}
if (textBox1.Text != textBox2.Text)
{
textBox3.Text = "FAILED";
}
}

Quote:

BTW, I cant use btnclick event.

public static class Patterns
{
    public static IEnumerable<string> GroupPatterns(this string pattern)
    {
        char prev = '\0';
        char[] item = new char[pattern.Length];
        int itemIndex = 0;
        
        foreach (char c in pattern)
        {
            if (c != prev)
            {
                if (itemIndex != 0)
                {
                    yield return new string(item, 0, itemIndex);
                    Array.Clear(item, 0, itemIndex);
                    itemIndex = 0;
                }
                
                prev = c;
            }
            
            item[itemIndex] = c;
            itemIndex++;
        }
        
        if (itemIndex != 0)
        {
            yield return new string(item, 0, itemIndex);
        }
    }
}

{
    "DDDD",
    "-",
    "AAAA",
    "-",
    "D",
    "A",
    "-",
    "A",
    "D"
}

public static class Patterns
{
    ...
    
    public static Regex PatternToRegularExpression(this string pattern)
    {
        var parts = new List<string>();
        foreach (string part in pattern.GroupPattern())
        {
            switch (part[0])
            {
                case 'D':
                case 'd':
                {
                    parts.Add("\\d{" + part.Length + "}");
                    break;
                }
                case 'A':
                case 'a':
                {
                    parts.Add("[A-Z]{" + part.Length + "}");
                    break;
                }
                default:
                {
                    parts.Add(Regex.Escape(part));
                    break;
                }
            }
        }
        
        string regexPattern = string.Concat(parts);
        return new Regex(regexPattern, RegexOptions.IgnoreCase);
    }
}

\d{4}-[a-z]{4}-\d{1}[a-z]{1}-[a-z]{1}\d{1}

List<string> patternList = new List<string>();
foreach(char ch in pattern)
{
    if (patternList.Count == 0 || !patternList.Last().Contains(ch))
    {
        patternList.Add(ch.ToString());
    }
    else
    {
        patternList[patternList.Count-1] += ch.ToString();
    }
}

John Simmons / outlaw programmer wrote:

patternList.Last()

John Simmons / outlaw programmer wrote:

patternList[patternList.Count-1] += ch.ToString();

Richard Deeming wrote:

Hey, I thought you were avoiding LINQ!

Richard Deeming wrote:

String concatenation in a loop - because that never affects the performance of your code at all.

patternList[patternList.Count-1] = string.Format("{0}{1}", patternList[patternList.Count-1], ch);

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;

namespace TestSubjectMatterReco
{
    class Program
    {
        static void Main(string[] args)
        {
            bool run = true;
            while (run)
            {
                Console.WriteLine("Add string to use");
                string subject = Console.ReadLine();
                Console.WriteLine("Add Pattern Line to use");
                string Pattern = Console.ReadLine();
                var sout = Parse(subject, Pattern);

                if (sout.Count() == 0)
                    Console.WriteLine("Unable to detect pattern");
                else
                {
                    int i = 1;
                    sout.ForEach(p => {  Console.WriteLine($"found pattern {p} this is pattern nr {i} of {sout.Count()}"); i++; });
                }                                                                            
                Console.WriteLine("----------------------------------");
                Console.WriteLine();
                Console.WriteLine("Press enter to try again , use q to qwuit");
                var answer = Console.ReadLine();
                if (answer=="q")
                    run = false;
            }            
            
        }        
        static List<string> Parse(string subject, string pattern)
        {
            var subjectList = subject.Split(' ').ToList().Where(p => p.Length == pattern.Length).ToList();
            string result = "";
            //so we have a substring with a lenght that mattches our pattern lenght. 
            if (subjectList.Count() > 0)
            {
                #region break down pattern
                List<string> _patterns = new List<string>();                
                string patt = string.Empty;
                int currindex = 0;          
                foreach (char c in pattern.ToCharArray())
                {                 
                    currindex++;   
                    if (patt == string.Empty)                    
                        patt = c.ToString();                                         
                    else
                    {
                        if (patt.StartsWith(c.ToString()))                        
                            patt += c.ToString();                                                    
                        else
                        {
                            _patterns.Add(patt);
                            patt = c.ToString();                            
                        }
                    }
                    if(currindex == pattern.Length)
                        _patterns.Add(patt);
                }
                int indexinSubjct = 0;
                #endregion
                #region try to find text that fits the pattern
                foreach (string pair in _patterns)
                {
                    //start at the beging.                                         
                    for (int j = subjectList.Count; j > 0; j--)
                    {
                        if (pair.StartsWith("D"))
                        {
                            if (!ParseDigit(subjectList[j-1].Substring(indexinSubjct, pair.Length)))
                                subjectList.Remove(subjectList[j-1]);
                        }
                        else if (pair.StartsWith("A"))
                        {
                            if (!ParseLetter(subjectList[j-1].Substring(indexinSubjct, pair.Length)))
                                subjectList.Remove(subjectList[j-1]);
                        }
                        else
                        {
                            string part = subjectList[j - 1].Substring(indexinSubjct, pair.Length);
                            if(part != pair)
                                subjectList.Remove(subjectList[j - 1]);
                        }
                        //seperator
                    }
                    indexinSubjct += pair.Length;
                }
                return subjectList;                
            }
            return new List<string>();
            #endregion  
        }        
        static bool ParseLetter(string sequence)
        {
           return sequence.All(p => char.IsLetter(p));
        }
        static bool ParseDigit(string sequence)
        {
            return sequence.All(p => char.IsDigit(p));
        }
        
    }
}

var pattern = "DDDD-AA-DD";

while ( pattern.Length > 0 ) {
   char ch1 = pattern[ 0 ];
   string item = string.Join( "", pattern.TakeWhile( p => p == ch1 ) );
   pattern = pattern.TrimStart( ch1 );
   Console.WriteLine( item );
}

Attention Member 12106926: Please note the code shown here was written a few years ago, and has not been tested, recently. I would strongly advise you to use this code (if you find it useful) only as the basis for your own code, and, as always, to test thoroughly.

public static class IEnumerableExtensions
{
    public static IEnumerable<List<T1>> GroupByContiguous<T1>(this IEnumerable<T1> src, T1 delimiter)
    {
        // trim any leading/trailing delimiters
        var src1 = src.TrimStart<T1>(delimiter)
            .TrimEnd<T1>(delimiter);

        List<T1> srcList = src1.ToList();

        T1 current;
        T1 previous = srcList.First();

        List<T1> element = new List<T1>();

        element.Add(previous);

        for (int i = 1; i < srcList.Count; i++)
        {
            current = srcList[i];

            if (current.Equals(delimiter))
            {
                previous = delimiter;
                continue;
            }

            if (! current.Equals(previous))
            {
                yield return element;
                element = new List<T1>();
                previous = current;
            }

            element.Add(current);
        }

        if (element.Count > 0) yield return element;
    }

    public static IEnumerable<T> TrimStart<T>(this IEnumerable<T> totrim, T trimthis)
    {
        return totrim.SkipWhile(itm => itm.Equals(trimthis));
    }

    public static IEnumerable<T> TrimEnd<T>(this IEnumerable<T> totrim, T trimthis)
    {
        return totrim.Reverse().SkipWhile(itm => itm.Equals(trimthis)).Reverse();
    }
}

private string text = "-DDDD-AAAA-DAAD-ADDDAA---";

// in some method:
var parsedChars = text.GroupByContiguous<char>(delimiter: '-').ToList();

foreach (var grp in parsedChars)
{
    Console.WriteLine(new string(grp.ToArray()));
}

// output to Console:
DDDD
AAAA
D
AA
D
A
DDD
AA