// Online C# Editor for free

// Write, Edit and Run your C# code using C# Online Compiler

​

​

​

using System;

using System.Text.RegularExpressions;

using System.Text;

​

public class RegexSimplifier

{

        public static string Optimize(string regex, bool optimizeForLength)

    {

        string previous;

        do

        {

            previous = regex;

            regex = RemoveRedundantParentheses(regex);

            regex = SimplifyNestedQuantifiers(regex, optimizeForLength);

            regex = MergeConsecutiveCharacters(regex, optimizeForLength);

            regex = CombineStarQuantifiers(regex, optimizeForLength);

            regex = OptimizeRepeatedQuantifiers(regex, optimizeForLength);

        } while (regex != previous);

​

        return regex;

    }

​

    // Rule 1: Remove redundant parentheses

    private static string RemoveRedundantParentheses(string input)

    {

        return Regex.Replace(input, @"\(([01]+)\)", match =>

        {

            string inner = match.Groups[1].Value;

            return inner.Contains("*") || inner.Contains("|") ? match.Value : inner;

        });

    }

​

    // Rule 2: Simplify nested quantifiers (a*)* → a*

    private static string SimplifyNestedQuantifiers(string input, bool optimizeForLength)

    {

        return Regex.Replace(input, @"\((.*?)\*\)\*", match =>

        {

            string inner = match.Groups[1].Value;

            string replacement = $"{inner}*";

            return ShouldReplace(match.Value, replacement, optimizeForLength) ? replacement : match.Value;

        });

    }

​

    // Rule 3/4: Merge consecutive characters and combine with star

    private static string MergeConsecutiveCharacters(string input, bool optimizeForLength)

    {

        // Replace sequences like 111 with {n}

        input = Regex.Replace(input, @"([0])\1{2,}|([1])\2{2,}", match =>

        {

            char c = match.Value[0];

            int count = match.Length;

            string replacement = $"{c}{{{count}}}";

            return ShouldReplace(match.Value, replacement, optimizeForLength) ? replacement : match.Value;

        });

​

        // Replace patterns like 11(1)* with {min,}

        input = Regex.Replace(input, @"(?<char>[01])(\k<char>+)\(\k<char>\*\)", match =>

        {

            char c = match.Groups["char"].Value[0];

            int min = match.Groups[1].Length + 1;

            string replacement = $"{c}{{{min},}}";

            return ShouldReplace(match.Value, replacement, optimizeForLength) ? replacement : match.Value;

        });

​

        return input;

    }

​

    // Rule 6/8: Combine consecutive star quantifiers

    private static string CombineStarQuantifiers(string input, bool optimizeForLength)

    {

        return Regex.Replace(input, @"(\w+\*)\1+", match =>

        {

            string replacement = match.Groups[1].Value;

            return ShouldReplace(match.Value, replacement, optimizeForLength) ? replacement : match.Value;

        });

    }

​

    // Rule 6: Optimize repeated quantifiers

    private static string OptimizeRepeatedQuantifiers(string input, bool optimizeForLength)

    {

        return Regex.Replace(input, @"(\(.*?\)\*)\1", match =>

        {

            string replacement = match.Groups[1].Value;

            return ShouldReplace(match.Value, replacement, optimizeForLength) ? replacement : match.Value;

        });

    }

​

    private static bool ShouldReplace(string original, string replacement, bool optimizeForLength)

    {

        return !optimizeForLength || replacement.Length <= original.Length;

    }

}

​

public class RegexChecker

{

    private string NumberConvertion(int number, int dimension)

    {

        if (dimension < 2 || dimension > 36)

        {

            throw new ArgumentOutOfRangeException(nameof(dimension), "only from 2 to 36.");

        }

​

        StringBuilder result = new StringBuilder();

​

        if (number == 0)

        {

            return "0";

        }

​

        bool isNegative = number < 0;

        number = Math.Abs(number);

​

        while (number > 0)

        {

            int remainder = number % dimension;

            char c = (remainder < 10) ? (char)('0' + remainder) : (char)('A' + (remainder - 10));

            result.Append(c);

            number /= dimension;

        }

​

        if (isNegative)

        {

            result.Append('-');

        }

​

        char[] chars = result.ToString().ToCharArray();

        Array.Reverse(chars);

​

        return new string(chars);

    }

​

    public bool Check(string regex, int division, int dimension = 2, bool ignoreTests = true, bool showTests = false,

        bool showOnlyBadResults = false, int operationCount = 10000)

    {

        bool result = true;

​

        for (int i = 0; i < operationCount && (result || showTests); i++)

        {

            int number = Random.Shared.Next();

            string convertedNumber = NumberConvertion(number, dimension);

            bool regexResult = Regex.IsMatch(convertedNumber, regex, RegexOptions.IgnoreCase);

​

            result = result && (regexResult == (number % division == 0));

​

            if (showOnlyBadResults)

            {

                if (regexResult != (number % division == 0))

                {

                    Console.WriteLine($"{number}, {convertedNumber}, {number % division == 0}, {regexResult}");

                }

​

                continue;

            }

​

            if (showTests)

            {

                Console.WriteLine($"{number}, {convertedNumber}, {number % division == 0}, {regexResult}");

            }

        }

​

        Console.WriteLine($"{regex}, {division}, {result}");

​

        return result;

    }

}

​

public class HelloWorld

{

    private static readonly RegexChecker _regexChecker = new RegexChecker(); 

    public static void Main(string[] args)

    {

        //var a = new RegexSimplifier();

        string regex = "^(0|1(((0(00)*011)*0(00)*1((1)*00(00)*1)*(1)*00(00)*011)*((0(00)*011)*0(00)*1((1)*00(00)*1)*(1)*01|(0(00)*011)*1)1)*((0(00)*011)*0(00)*1((1)*00(00)*1)*(1)*00(00)*011)*((0(00)*011)*0(00)*1((1)*00(00)*1)*(1)*01|(0(00)*011)*1)0|1(((0(00)*011)*0(00)*1((1)*00(00)*1)*(1)*00(00)*011)*((0(00)*011)*0(00)*1((1)*00(00)*1)*(1)*01|(0(00)*011)*1)1)*((0(00)*011)*0(00)*1((1)*00(00)*1)*(1)*00(00)*011)*(0(00)*011)*0(00)*010|1(((0(00)*011)*0(00)*1((1)*00(00)*1)*(1)*00(00)*011)*((0(00)*011)*0(00)*1((1)*00(00)*1)*(1)*01|(0(00)*011)*1)1)*((0(00)*011)*0(00)*1((1)*00(00)*1)*(1)*00(00)*011)*(0(00)*011)*0(00)*1((1)*00(00)*1)*(1)*00(00)*010)+$";

        int number = 6;

        _regexChecker.Check(regex, number, 2, true, false, false, 10000);

        string a = RegexSimplifier.Optimize(regex, true);

        string b = RegexSimplifier.Optimize(regex, false);

        string[] examples = {

            "(0)",       // → 0

            "(0*)*",     // → 0*

            "111",       // → 1{3} (if optimizeForLength=false)

            "0*0*",      // → 0*

            "1(1*)"      // → 1+

        };

​

        foreach (string ex in examples)

        {

            Console.WriteLine($"Original: {ex}");

            Console.WriteLine($"Optimized (length): {RegexSimplifier.Optimize(ex, true)}");

            Console.WriteLine($"Optimized (no length): {RegexSimplifier.Optimize(ex, false)}");

            Console.WriteLine();

        }

        _regexChecker.Check(a, number, 2, true, false, false, 10000);

        _regexChecker.Check(b, number, 2, true, false, false, 10000);

        Console.WriteLine (a.Length);

        Console.WriteLine (b.Length);

    }

}