C#

Kevin Marois wrote:

This app isn't targeted to programmers.

Bastard Programmer from Hell
If you can't read my code, try converting it here[^]

int lastindexof = searchString.ToList().FindLastIndex(']');

private string test = @"Sample1[Model:M1; Year:1990]Sample2[Model:M3; Year:1997];"

List<Point> bracketIndexes = new List<Point>();

char rBrack = '[';
char lBrack = ']';

int loc = 0;
int limit = test.Length;
int brackStart, brackEnd;

while (loc < limit)
{
    brackStart = test.IndexOf(rBrack, loc);
    if (brackStart == -1) break;
    
    brackEnd = test.IndexOf(lBrack, brackStart + 1);
    if (brackEnd == -1) break;
    
    loc += brackEnd;
    
    bracketIndexes.Add(new Point(brackStart, brackEnd));
    
    loc++;
}

foreach (Point pt in bracketIndexes)
{
    Console.WriteLine("{0} at {1} : {2} at {3}", test[pt.X], pt.X, test[pt.Y], pt.Y);
};

// actual output to Console:
//[ at 7 : ] at 27
//[ at 35 : ] at 55

Regex findEm = new Regex(@"(?<=Sample)(?<SampleNo>\d+)(?<Start>\[)(?<Data>.*?)(?<End>\])");
string input = "Sample1[Model:M1; Year:1990]";
Match m = findEm.Match(input);
if (m.Success)
    {
    Console.WriteLine("Sample {0}: {1}{2}{3}\n       {4}, {5}",
                        m.Groups["SampleNo"].Value,
                        m.Groups["Start"].Value,
                        m.Groups["Data"].Value,
                        m.Groups["End"].Value,
                        m.Groups["Start"].Index,
                        m.Groups["End"].Index);
    }

Sample 1: [Model:M1; Year:1990]
       7, 27

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();
    }
}