分享｜用正则表达式刷leetcode是什么体验？附带正则表达式可视化图

using System.Text.RegularExpressions;
public class Solution {
    static Regex regex = new(@"(?x)(?<=\s)(?=\S)
(?<=(?=(?>(?=\d)
    (?>(?'-maxwith')(?'k')|){10}
    (?>(?'-k')(?'maxwith'){10}|){10}
    (?=[147](?'maxwith')|)(?=[258](?'maxwith'){2}|)(?=[3459](?'maxwith'){3}|)(?=[6789](?'maxwith'){6}|)\d
)+)(?>.+))
(?n)(((?(maxwith)(?>(?'-1')(?'-maxwith')(?'maxwith1')(?>(?'-1')(?'-maxwith')(?'maxwith1')|){9}|){10}(?(maxwith)|(?'flag'))|
(?>(?'-1')(?'-maxwith1')(?'maxwith')(?>(?'-1')(?'-maxwith1')(?'maxwith')|){9}|){10}(?(maxwith1)|(?'flag'))))
((?'-flag')
|(?!(?'-flag'))((?>(?'1'(?'2'\S))+)(?=\s|\b)(?(x)(?'y')(?(3)(?'-3'))|(?'3'))(?'x')|((?<=(?'-z'.)*)|(?(3)(?'-3')(?'z'))(?<=(?'-z'.)+)(?'z')(?=(?'1'(?'2'\s)))|
(?(3)(?'-3')(?'z'){2})(?<=(?'-z'.){2,})(?'z'){2}(?=(?'1'(?'2'\s))){2}|(?(3)(?'-3')(?'z'){3})(?<=(?'-z'.){3,})(?'z'){3}(?=(?'1'(?'2'\s))){3}|
(?(3)(?'-3')(?'z'){4})(?<=(?'-z'.){4,})(?'z'){4}(?=(?'1'(?'2'\s))){4}|(?(3)(?'-3')(?'z'){5})(?<=(?'-z'.){5,})(?'z'){5}(?=(?'1'(?'2'\s))){5}|
(?(3)(?'-3')(?'z'){6})(?<=(?'-z'.){6,})(?'z'){6}(?=(?'1'(?'2'\s))){6}|(?(3)(?'-3')(?'z'){7})(?<=(?'-z'.){7,})(?'z'){7}(?=(?'1'(?'2'\s))){7}|
(?(3)(?'-3')(?'z'){8})(?<=(?'-z'.){8,})(?'z'){8}(?=(?'1'(?'2'\s))){8}|(?(3)(?'-3')(?'z'){9})(?<=(?'-z'.){9,})(?'z'){9}(?=(?'1'(?'2'\s))){9}|
(?(3)(?'-3')(?'z'){10})(?<=(?'-z'.){10,})(?'z'){10}(?=(?'1'(?'2'\s))){10})(?'1'(?'2'\s)))))+
(?!(?'-1'))(\b(?(y)(?<=\S))|(?<=.)(?=\s)|$)|(\S+\s)+$", RegexOptions.Compiled);
    public IList<string> FullJustify(string[] words, int maxWidth) {
        var concatStr = maxWidth + "          "+string.Join(" ",words)+" ";
        var mhes = regex.Matches(concatStr);
        List<string> result = new List<string>();
        for(var i = 0; i < mhes.Count - 1; i++)
        {
            var mh = mhes[i];
            var chars = new char[mh.Groups[2].Captures.Count];
            for(var j = 0; j < mh.Groups[2].Captures.Count; j++)
                chars[j] = mh.Groups[2].Captures[j].Value[0];
            result.Add(new string(chars));
        }
        //对最后一行做特殊处理
        var index = mhes.Last().Index;
        var str = concatStr.Substring(index).TrimStart(' ').TrimEnd(' ');
        str = str.PadRight(maxWidth,' ');
        result.Add(str);

        return result;
    }
}

using System.Text.RegularExpressions;
public class Solution {
    static Regex regex = new(@"(?x)(?<=\s)(?=\S)
(?<=(?=(?>(?=\d)
    (?>(?'-maxwith')(?'k')|){10}
    (?>(?'-k')(?'maxwith'){10}|){10}
    (?=[147](?'maxwith')|)(?=[258](?'maxwith'){2}|)(?=[3459](?'maxwith'){3}|)(?=[6789](?'maxwith'){6}|)\d
)+)(?>.+))
(?n)(?((?(maxwith)(?>(?'-1')(?'-maxwith')(?'maxwith1')(?>(?'-1')(?'-maxwith')(?'maxwith1')|){9}|){10}(?(maxwith)(?!))|
(?>(?'-1')(?'-maxwith1')(?'maxwith')(?>(?'-1')(?'-maxwith1')(?'maxwith')|){9}|){10}(?(maxwith1)(?!))))
|((?>(?'1'(?'2'\S))+)(?=\s|\b)(?(x)(?'y')(?(3)(?'-3'))|(?'3'))(?'x')|((?<=(?'-z'.)*)|(?(3)(?'-3')(?'z'))(?<=(?'-z'.)+)(?'z')(?=(?'1'(?'2'\s)))|
(?(3)(?'-3')(?'z'){2})(?<=(?'-z'.){2,})(?'z'){2}(?=(?'1'(?'2'\s))){2}|(?(3)(?'-3')(?'z'){3})(?<=(?'-z'.){3,})(?'z'){3}(?=(?'1'(?'2'\s))){3}|
(?(3)(?'-3')(?'z'){4})(?<=(?'-z'.){4,})(?'z'){4}(?=(?'1'(?'2'\s))){4}|(?(3)(?'-3')(?'z'){5})(?<=(?'-z'.){5,})(?'z'){5}(?=(?'1'(?'2'\s))){5}|
(?(3)(?'-3')(?'z'){6})(?<=(?'-z'.){6,})(?'z'){6}(?=(?'1'(?'2'\s))){6}|(?(3)(?'-3')(?'z'){7})(?<=(?'-z'.){7,})(?'z'){7}(?=(?'1'(?'2'\s))){7}|
(?(3)(?'-3')(?'z'){8})(?<=(?'-z'.){8,})(?'z'){8}(?=(?'1'(?'2'\s))){8}|(?(3)(?'-3')(?'z'){9})(?<=(?'-z'.){9,})(?'z'){9}(?=(?'1'(?'2'\s))){9}|
(?(3)(?'-3')(?'z'){10})(?<=(?'-z'.){10,})(?'z'){10}(?=(?'1'(?'2'\s))){10})(?'1'(?'2'\s))))+
(?!(?'-1'))(\b(?(y)(?<=\S))|(?<=.)(?=\s)|$)|(\S+\s)+$", RegexOptions.None);
    public IList<string> FullJustify(string[] words, int maxWidth) {
        var concatStr = maxWidth + "          "+string.Join(" ",words)+" ";
        var mhes = regex.Matches(concatStr);
        List<string> result = new List<string>();
        for(var i = 0; i < mhes.Count - 1; i++)
        {
            var mh = mhes[i];
            var chars = new char[mh.Groups[2].Captures.Count];
            for(var j = 0; j < mh.Groups[2].Captures.Count; j++)
                chars[j] = mh.Groups[2].Captures[j].Value[0];
            result.Add(new string(chars));
        }
        //对最后一行做特殊处理
        var index = mhes.Last().Index;
        var str = concatStr.Substring(index).TrimStart(' ').TrimEnd(' ');
        str = str.PadRight(maxWidth,' ');
        result.Add(str);

        return result;
    }
}

using System.Text.RegularExpressions;
public class Solution {
    public bool IsPalindrome(int x) {
        return Regex.IsMatch(x.ToString(), @"^(.)*.?(?>(?'-1'\1)*)(?!(?'-1'))$");
    }
}

using System.Text.RegularExpressions;
public class Solution {
    string[] strs = new string[]{"I","II","III","IV","V","VI", "VII", "VIII", "IX","X", "XX", "XXX",
 "XL", "L", "LX", "LXX", "LXXX", "XC","C", "CC", "CCC", "CD", "D", "DC", "DCC", "DCCC", "CM","","","","","","M", "MM", "MMM"};
    public string IntToRoman(int num) {
        var s = num.ToString("#a#S#J#A");
        var d = Regex.Replace(s, "(?n)(0|(?<![1-9]))[AaJS]", "");
        return Regex.Replace(d, @"\d[AaJS]", m => strs[m.ValueSpan[0]+m.ValueSpan[1]-'r'/*'A'-'1'*/]);
    }
}

using System.Text.RegularExpressions;
public class Solution {
    public bool IsValid(string s) {
        return Regex.IsMatch(s, @"^(?>\((?=.*?(\)))|{(?=.*?(?'1'}))|\[(?=.*?(?'1']))|(?'-1'\1))+$(?!(?'-1'))");
    }
}

using System.Text.RegularExpressions;
public class Solution {
    static Regex regex = new Regex(@"(?x)^(?!
    (?=(?>[^\n]{9}\n)*?[^\n]*?(\d)[^\n]*?\1)|
    (?=(?>[^\n]{9}\n)*?(?'offset'[^\n])*?(?'1'\d)(?>[^\n]*\n)
        (?>[^\n]{9}\n)*?(?>(?'-offset'[^\n])*)\1
    )|
    (?=(?>(?>[^\n]{9}\n){3}){0,2}?(?'next'[^\n]{9}\n)??
        (?>(?'offset'[^\n]){3}){0,2}?.{0,2}?(?'1'\d)(?>[^\n]*\n)
        (?>(?!(?'-next'))(?>[^\n]{9}\n))??(?>(?'-offset'[^\n])*).{0,2}?\1
    )
)", RegexOptions.Compiled);
    public bool IsValidSudoku(char[][] board) {
        return regex.IsMatch(string.Join("\n", board.Select(s => string.Join("", s))));
    }
}

using System.Text.RegularExpressions;
public class Solution {
    Regex regex = new Regex(@"(\d)\1*");
    public string CountAndSay(int n) {
        if(n == 1)
            return "1";
        return regex.Replace(CountAndSay(n - 1),m => m.Length.ToString() + m.Value[0]);
        return Regex.Replace("9876543210,"+CountAndSay(n - 1),@"((\d))(?'1'\1)*(?<=(\d)(?'-1'\d)+,\d*)|(\d+,)","${3}${2}");
    }
}

using System.Text.RegularExpressions;
public class Solution {
    public int LengthOfLastWord(string s) {
        return  new Regex(@"\w+(?=\s*$)",RegexOptions.RightToLeft).Match(s).Length;
    }
}

using System.Text.RegularExpressions;
public class Solution {
    public bool IsNumber(string s) {
        var pattern = @"^[+-]?(?:(\d)*(?'1'(\d)*\.(?'2'\d)*(?'-2'))?(?:[eE][+-]?\d+)?)$(?'-1')";
        return Regex.IsMatch(s,pattern);
    }
}

using System.Text.RegularExpressions;
public class Solution {
    public IList<string> FullJustify(string[] words, int maxWidth) {
        var pattern = @"(?<=\s)(?=\S)(?n)(?((?'-1'){"
                    + maxWidth +
                    @"})|((?>(?'1'(?'2'\S))+)(?=\s|\b)(?(x)(?'y')(?(3)(?'-3'))|(?'3'))(?'x')|((?<=(?'-z'.)*)|(?(3)(?'-3')(?'z'))(?<=(?'-z'.)+)(?'z')(?=(?'1'(?'2'\s)))|(?(3)(?'-3')(?'z'){2})(?<=(?'-z'.){2,})(?'z'){2}(?=(?'1'(?'2'\s))){2}|(?(3)(?'-3')(?'z'){3})(?<=(?'-z'.){3,})(?'z'){3}(?=(?'1'(?'2'\s))){3}|(?(3)(?'-3')(?'z'){4})(?<=(?'-z'.){4,})(?'z'){4}(?=(?'1'(?'2'\s))){4}|(?(3)(?'-3')(?'z'){5})(?<=(?'-z'.){5,})(?'z'){5}(?=(?'1'(?'2'\s))){5}|(?(3)(?'-3')(?'z'){6})(?<=(?'-z'.){6,})(?'z'){6}(?=(?'1'(?'2'\s))){6}|(?(3)(?'-3')(?'z'){7})(?<=(?'-z'.){7,})(?'z'){7}(?=(?'1'(?'2'\s))){7}|(?(3)(?'-3')(?'z'){8})(?<=(?'-z'.){8,})(?'z'){8}(?=(?'1'(?'2'\s))){8}|(?(3)(?'-3')(?'z'){9})(?<=(?'-z'.){9,})(?'z'){9}(?=(?'1'(?'2'\s))){9}|(?(3)(?'-3')(?'z'){10})(?<=(?'-z'.){10,})(?'z'){10}(?=(?'1'(?'2'\s))){10})(?'1'(?'2'\s))))+(?!(?'-1'))(\b(?(y)(?<=\S))|(?<=.)(?=\s)|$)|(\S+\s)+$";
        var concatStr = "          "+string.Join(" ",words)+" ";
        var mhes = Regex.Matches(concatStr,pattern);
        List<string> result = new List<string>();
        var i = 0;
        for(; i < mhes.Count - 1; i++)
        {
            var mh = mhes[i];
            var chars = new char[mh.Groups[2].Captures.Count];
            for(var j = 0; j < mh.Groups[2].Captures.Count; j++)
                chars[j] = mh.Groups[2].Captures[j].Value[0];
            result.Add(new string(chars));
        }
        //对最后一行做特殊处理
        var index = mhes.Last().Index;
        var str = concatStr.Substring(index).TrimStart(' ').TrimEnd(' ');
        str = str.PadRight(maxWidth,' ');
        result.Add(str);

        return result;
    }
}

using System.Text.RegularExpressions;
public class Solution {
    static Regex regex = new Regex(@"(?n)(/+((?'dir'(\.*\w\.*)+|\.{3,})|\.\.((?'-dir')|)|\.|))+");
    static Regex regex_ = new Regex(@"(?n)(?>((?'-1'/+((?>\.*\w\.*)*|\.{3,})(?=/|$))|/+\.(?=/|$))*(?>(?'1'/+\.\.(?=/|$))+))+|/+$|(?<=/)/+|/+\.(?=/|$)", RegexOptions.RightToLeft);
    public string SimplifyPath(string path) {
        //第一种正则表达式解法
        var result = regex_.Replace(path, "");
        return result == ""? "/" : result;
        //第二种正则表达式解法
        return regex.Replace(path, m =>
        {
            var s = "";
            var Captures = m.Groups["dir"].Captures;
            for(var i = 0; i < Captures.Count; i++)
                s += "/" + Captures[i].Value;
            return s == ""? "/" : s;
        });
    }
}

using System.Text.RegularExpressions;
public class Solution {
    public IList<string> RestoreIpAddresses(string s) {
        var mh = Regex.Match(s, @"^(?=\d{3,12})(?=(\d(?'x1')|(?!0)\d\d(?'x2')|(?!0|([3-9]|2([6-9]|5[6-9])))\d{3}(?'x3'))(?=(?>\d{3,9})$)(\d(?'y1')|(?!0)\d\d(?'y2')|(?!0|([3-9]|2([6-9]|5[6-9])))\d{3}(?'y3'))(?=(?>\d{2,6})$)(\d(?'z1')|(?!0)\d\d(?'z2')|(?!0|([3-9]|2([6-9]|5[6-9])))\d{3}(?'z3'))(?=(?>\d{1,3})$)((?'-x1')((?'-y1')((?'-z1')(?(r111)(?!)|(?'r111'))|(?'-z2')(?(r112)(?!)|(?'r112'))|(?'-z3')(?(r113)(?!)|(?'r113')))|(?'-y2')((?'-z1')(?(r121)(?!)|(?'r121'))|(?'-z2')(?(r122)(?!)|(?'r122'))|(?'-z3')(?(r123)(?!)|(?'r123')))|(?'-y3')((?'-z1')(?(r131)(?!)|(?'r131'))|(?'-z2')(?(r132)(?!)|(?'r132'))|(?'-z3')(?(r133)(?!)|(?'r133'))))|(?'-x2')((?'-y1')((?'-z1')(?(r211)(?!)|(?'r211'))|(?'-z2')(?(r212)(?!)|(?'r212'))|(?'-z3')(?(r213)(?!)|(?'r213')))|(?'-y2')((?'-z1')(?(r221)(?!)|(?'r221'))|(?'-z2')(?(r222)(?!)|(?'r222'))|(?'-z3')(?(r223)(?!)|(?'r223')))|(?'-y3')((?'-z1')(?(r231)(?!)|(?'r231'))|(?'-z2')(?(r232)(?!)|(?'r232'))|(?'-z3')(?(r233)(?!)|(?'r233'))))|(?'-x3')((?'-y1')((?'-z1')(?(r311)(?!)|(?'r311'))|(?'-z2')(?(r312)(?!)|(?'r312'))|(?'-z3')(?(r313)(?!)|(?'r313')))|(?'-y2')((?'-z1')(?(r321)(?!)|(?'r321'))|(?'-z2')(?(r322)(?!)|(?'r322'))|(?'-z3')(?(r323)(?!)|(?'r323')))|(?'-y3')((?'-z1')(?(r331)(?!)|(?'r331'))|(?'-z2')(?(r332)(?!)|(?'r332'))|(?'-z3')(?(r333)(?!)|(?'r333')))))(\d|(?!0)\d\d|(?!0|([3-9]|2([6-9]|5[6-9])))\d{3})$|){19}");
        var result = new List<string>();
        for(var i = 0; i < mh.Groups[1].Captures.Count; i++)
        {
            result.Add(mh.Groups[1].Captures[i].Value+"."+mh.Groups[4].Captures[i].Value+"."+mh.Groups[7].Captures[i].Value+"."+mh.Groups[23].Captures[i].Value);
        }
        return result;
    }
}

using System.Text.RegularExpressions;
public class Solution {
    public bool IsPalindrome(string s) {
        return Regex.IsMatch(s,@"^(?ni)((?'1'[a-z0-9])|[^a-z0-9])*((?'2'[a-z0-9])|[^a-z0-9])\2?((?'-1'\1)|[^a-z0-9])*(?!(?'-1'))$");
    }
}

using System.Text.RegularExpressions;
public class Solution {
    static Regex regexInitial = new Regex(@"(?:\.0+)+$|(?<=\.|^)0+(?=(\d)+)(?'-1'){6}|(?'1'){6}((?'-1'\d)+)|\.");
    public int CompareVersion(string version1, string version2) {
		/*第一种regular express 方法*/
        version1 = regexInitial.Replace(version1, m => new string('0',m.Groups[1].Captures.Count)+m.Groups[2].Value);
        version2 = regexInitial.Replace(version2, m => new string('0',m.Groups[1].Captures.Count)+m.Groups[2].Value);
        var mh = Regex.Match(version1+"#"+version2, @"(?n)(?(w)|(?=[147](?'1')|)(?=[258](?'1'){2}|)(?=[3459](?'1'){3}|)(?=[6789](?'1'){6}|)\d(?=(?>.*?#((?'-offset'.)(?'c'))*(?<=(.(?'offset')(?'-c'))*))(?=[147](?'2')|)(?=[258](?'2'){2}|)(?=[3459](?'2'){3}|)(?=[6789](?'2'){6}|)\d(?>$(?'e')|)(?'offset')((?'-1')(?'-2')|){9})(?(1)(?'w1')(?'w')|(?(2)(?'w2')(?'w')|(?(#)(?(e)|(?'w2')(?'w'))|(?(e)(?'w1')(?'w'))))))+");
        if(mh.Groups["w1"].Success) return 1;
        if(mh.Groups["w2"].Success) return -1;
        return 0;

		/*第二种regular express 方法*/
        if(version1.Length > version2.Length)
            version2 = version2 + new string('0',version1.Length - version2.Length);
        else if(version1.Length < version2.Length)
            version1 = version1 + new string('0',version2.Length - version1.Length);
        var mh1 = Regex.Match(version1+"#"+version2, @"(?n)(?(w)|(?=[147](?'1')|)(?=[258](?'1'){2}|)(?=[3459](?'1'){3}|)(?=[6789](?'1'){6}|)\d(?=(?>.*?#((?'-offset'.)(?'c'))*(?<=(.(?'offset')(?'-c'))*))(?=[147](?'2')|)(?=[258](?'2'){2}|)(?=[3459](?'2'){3}|)(?=[6789](?'2'){6}|)\d(?'offset')(?<=(.(?'-1')(?'-2'))*))(?(1)(?'w1')(?'w')|(?(2)(?'w2')(?'w'))))+");
        if(mh1.Groups["w1"].Success) return 1;
        if(mh1.Groups["w2"].Success) return -1;
        return 0;

		/*regular 方法*/
        for(int i = 0,j=0; i < version1.Length||j < version2.Length;i++,j++)
        {
            var v1 = 0;
            for(;i<version1.Length&&version1[i] != '.';i++)
            {
                v1 = v1 * 10 + version1[i] - '0';
            }
            var v2 = 0;
            for(;j<version2.Length&&version2[j] != '.';j++)
            {
                v2 = v2 * 10 + version2[j] - '0';
            }
            if(v1 > v2) return 1;
            if(v1 < v2) return -1;
        }
        return 0;
    }
}

using System.Text.RegularExpressions;

public class Solution {
    static readonly string[] map = {"","One","Two","Three","Four","Five","Six","Seven","Eight","Nine",""/*10*/,"","","","","","","","","Hundred","Thousand","Million","Billion","","",
    "Twenty","Thirty","Forty","Fifty","Sixty","Seventy","Eighty","Ninety","",
    "Ten","Eleven","Twelve","Thirteen","Fourteen","Fifteen","Sixteen","Seventeen","Eighteen","Nineteen"};
    public string NumberToWords(int num) {
        if(num == 0) return "Zero";
        var s = num.ToString("GR#F#C#B#E#C#B#D#C#B#A");
        var d = Regex.Replace(s, @"([2-9])B(?<=^(.).+)|1B(?'1'[0-9])(?<=^.(?'2'.).+)|^[A-Z]+|(?<![1-9](?:B|C\dB))0[A-F]", "${1}${2}");
        var r = Regex.Replace(d, @"\d[GR]|\d[A-Z]|.", m => {
            if(m.Value.Length==1) return map[m.Value[0]-'0']+" ";
            else return m.Value[1]>'F'?(map[m.Value[0]+m.Value[1]-'`'/*'0'+'0'*/]+" "):(map[m.Value[0]-'0'] + " " + map[m.Value[1]-'0']+" ");
        });
        return r.TrimEnd(' ').Replace("  "," ");
    }
}

using System.Text.RegularExpressions;
public partial class Solution {
    static Regex regex = new Regex(@"(?<=(.)*).(?=.*(.)(?>(?'-1'.)*)(?!(?'-1'))$)|.(?=(.)*)(?<=^(?!(?'-3'))(?'-3'.)*(?'2'.).*)", RegexOptions.Compiled);
    public void ReverseString(char[] s) {
        if(s.Length > 366)
        {
            for(var i = 0; i < s.Length/2; i++)
            {
                var j = s.Length - i - 1;
                if(i >= j) return;
                var ch = s[i];
                s[i] = s[j];
                s[j] = ch;
            }
            return;
        }
        //var str = Regex.Replace(new string(s),@"(?<=(.)*).(?=.*(.)(?>(?'-1'.)*)(?!(?'-1'))$)|.(?=(.)*)(?<=^(?!(?'-3'))(?'-3'.)*(?'2'.).*)","${2}");
        var str = regex.Replace(new string(s),"${2}");
        Array.Copy(str.ToCharArray(), s, s.Length);
    }
}

using System.Text.RegularExpressions;
public class Solution {
    public string ValidIPAddress(string queryIP) {
        var mh = Regex.Match(queryIP, @"(?n)^((?>(?'ipv4'(?!0|3|2(5[6-9]|[6-9]))\d{3}|(?!0)\d\d|\d)(?'dot'\.)?){4}(?'-dot'){3}(?!(?'-dot'))|([A-Fa-f0-9]{1,4}(?'dot':)){7,}[A-Fa-f0-9]{1,4}(?'-dot'){7}(?!(?'-dot')))$");
        if(mh.Success)
            return mh.Groups["ipv4"].Success?"IPv4":"IPv6";
        return "Neither";
    }
}

using System.Text.RegularExpressions;
public class Solution {
    public bool DetectCapitalUse(string word) {
        //return !Regex.IsMatch(word, @"(?n)[A-Z]((?<=[a-z].)|(?=(?<=..)[a-z]))");
        return Regex.IsMatch(word, @"(?n)^(?>[A-Z]?(?>[A-Z]+|[a-z]+))$");
    }
}

using System.Text.RegularExpressions;
public class Solution {
    public bool IsValid(string code) {
        return Regex.IsMatch(code,@"^(?n)(<(?'TAG_NAME'[A-Z]{1,9})>)(?>(?>(?'-TAG_NAME'</\k'TAG_NAME'>)|(<(?'TAG_NAME'[A-Z]{1,9})>)|[^<]+|<!\[CDATA\[.*?]]>)(?(.)(?!(?!(?'-TAG_NAME')))))+(?!(?'-TAG_NAME'))$");
    }
}

using System.Text.RegularExpressions;
public class Solution {
    //static Regex regex = new Regex(@"(?>^((\()|(?'-2'\))|(?'-3'\))|(\*))+$)(?<=^((?'x1'\*)|(?'-x1'\()|(?'-x'\()|(?'x'\)))+$)", RegexOptions.Compiled);
    static Regex regex = new Regex(@"(?>^(?>\(()()|\)(?'-1')(?>(?'-2')?)|\*(?'1')(?>(?'-2')?))+$)(?!\2)", RegexOptions.Compiled);
    public bool CheckValidString(string s) {
        return regex.IsMatch(s);
    }
}

using System.Text.RegularExpressions;
public class Solution {
    public bool IsOneBitCharacter(int[] bits) {
        return Regex.IsMatch(string.Join("", bits), @"(^|0)(?>(11)*)0$", RegexOptions.RightToLeft);
    }
}

using System.Text.RegularExpressions;
public class Solution {
    public IList<string> RemoveComments(string[] source) {
        return Regex.Replace(string.Join("\n",source), @"(?s)/\*((?!\*/).)*(\*/)?|//[^\n]*", "")
                    .Split("\n").Where(w=>w.Length > 0).ToList();
    }
}

using System.Text.RegularExpressions;
public class Solution {
    static Regex regex = new Regex(@"\b(?:(([a-z]))(?>(?'1'\1)*)(?(\b)(?'z'))(?=(?>.*?#((?'-offset'.)(?'c'))*(?<=((?'offset')(?'-c'.))*))(?>(?>(?'offset'\2((?'-1')|))){3,}|(?>(?'offset'\2(?'-1')))+)(?(z)$)(?!(?'-1'))))+(?=[#,])",RegexOptions.Compiled);
    public int ExpressiveWords(string s, string[] words) {
        var input = string.Join(",", words) + "#" + s;
        return regex.Matches(input).Count;
    }
}

using System.Text.RegularExpressions;
public class Solution {
    static Regex regex = new Regex(@"((?>(\w)*)(?>(#(?'-2')?)+))+(?!(?'-2'))");
    public bool BackspaceCompare(string s, string t) {
        return regex.Replace(s,"") == regex.Replace(t,"");
    }
}

using System.Text.RegularExpressions;
public class Solution {
    static Regex regex = new(@"(?>(?<=^|,)(\d+))(?=,(?>\d+,)*?\1(,|$))", RegexOptions.Compiled);
    public int RepeatedNTimes(int[] nums) {
        var s = regex.Match(string.Join(",", nums)).Value;
        return int.Parse(s);
    }
}

using System.Text.RegularExpressions;
public class Solution {
    public IList<bool> PrefixesDivBy5(int[] nums) {
        return Regex.Match(string.Join("", nums), 
@"(?nx)#开启只捕获命名组，开启忽略pattern中的空白字符且井字符(#)开启行尾注释
((?>(?'-y')(?'z')|){5}(?>(?'-z')(?'y'){2}|){5}#组y记录余数，存在余数y，令 y *= 2；y不会超过5
(?=1(?'y')|)#遇到1，则余数 y += 1;
(?>(?'-y'){5}|)#尝试对余数组y移除5次，如果不够则do noting
(?(y)(?'1').|(?'1'.)))*#存在余数y时，则组1存入一个空捕获组，表示false；否则存入一个数字表示true"
            ).Groups[1].Captures.Select(s => s.Value.Length > 0).ToList();
    }
}

using System.Text.RegularExpressions;
public class Solution {
    static Regex regex = new Regex(@"(?nx)\d(?'r'\d)*
(?<=(
    (((?'-sum')|(?'r'))(?'carry')(?'-sum')|)
    ((?'sum')(?'-carry'))?(?<=\d)(0|1(?'sum'))
)*)
((?'-carry')(?'r')|)", RegexOptions.Compiled);
    public int NumSteps(string s) {
        return regex.Match(s).Groups["r"].Captures.Count;
    }
}

using System.Text.RegularExpressions;
public class Solution {
    static Regex regex = new Regex(@"(?nx)(?>
^(?=[147](?'n')|)(?=[258](?'n'){2}|)(?=[3459](?'n'){3}|)(?=[6789](?'n'){6}|)\d
 (\d(?'n'){9}(?#n最大为10),|,)
(?>(?=\d(?>(?'-k')(?'kk')|){10}(?>(?'-kk')(?'k'){10}|){10}|)
   (?=[147](?'k')|)(?=[258](?'k'){2}|)(?=[3459](?'k'){3}|)(?=[6789](?'k'){6}|)\d
)+(?'-k')
)
(?>(?>(?'-n')(?'ans'\w))+)
(?>(?'-k')
  (?(flag)|(?#当前flag标识当前位置的字符是否可以进行变换)
    (?(.*?c(?<=\k'ans'))(?#当前位置是c)(?'-ans')(?'popnum'))
    (?((?>.*?b)(?<=\k'ans')(?!(?!(?'-ans')(?>.*?c)(?<=\k'ans'))))(?'-ans'){2}(?'popnum'){2}|(?'flag'))
  ){6}
  (?'-flag')?(?=(?>.*?a)(?<=\k'ans')(?'flag')|)(?#此时flag标识顶层位置是a)(?'-ans')
  (?(ans)
    (?((?>.*?c)(?<=\k'ans'))(?=.*?(?'ans'b))|(?=.*?(?'ans'c)))
    |
    (?>(?'-flag')(?=.*?(?'ans'b))|(?=.*?(?'ans'c)))
  )(?'-flag')?
  (?#当前flag用于标识a、b交替填充后续位置)
  (?<=(?'-flag')?(?>(?>(?=.*?(?'ans'b))(?'-flag')|(?=.*?(?'ans'a))(?'flag')).(?'-popnum'))*)
|){100}(?!\k'k')", RegexOptions.Compiled);
    public string GetHappyString(int n, int k) {
        Match mh = regex.Match($"{n},{k}ababababababc");
        return string.Join("", mh.Groups["ans"].Captures);
    }
}

using System.Text.RegularExpressions;
public class Solution {
    static Regex regex = new Regex(@"(?X)
^(?>(?>(?=\d)#读取k值
    (?(k)(?(k)(?>(?'-k')(?'2')|){100}){10}){10}#如果已读取k值的部分前缀，则将前缀计数转存到组#2
    (?(2)(?(2)(?>(?'-2')(?'k'){10}|){100}){10}){10}#如果组2存储了k值的前缀，则将组#2放大10倍，存入组#k
    (?=[147](?'k')|)(?=[258](?'k'){2}|)(?=[3459](?'k'){3}|)(?=[6789](?'k'){6}|)\d#按位读取k值，存入组#k
)+)
,
(?!.*?1(?>(?'-k'0)*)1(?'-k'))#向前探查，是否有两个1之间元素0的数量小于k
", RegexOptions.Compiled);
    public bool KLengthApart(int[] nums, int k) {
        return regex.IsMatch(k + "," + string.Join("", nums));
    }
}

using System.Text.RegularExpressions;
public class Solution {
    static Regex regex = new Regex(@"(?xn)(?=^((?(1)(?>(?'-1')(?'-sum')(?'2')|){10}(?>(?'-2')
((?'1')(?'sum')){10}|){10})(?=[147](?'1')(?'sum')|)(?=[258]((?'1')(?'sum')){2}|)
(?=[3459]((?'1')(?'sum')){3}|)(?=[6789]((?'1')(?'sum')){6}|)\d)+,((?(2)(?>(?'-2')(?'3')|){10}
(?>(?'-3')(?'2'){10}|){10})(?=[147](?'2')|)(?=[258](?'2'){2}|)(?=[3459](?'2'){3}|)
(?=[6789](?'2'){6}|)\d)+)(?(x)|(?(2)(?>(?'-2')(?'3')(?'-1')|){100}(?(2)(?'x')|(?'sum')
(?'1'))|(?(3)(?>(?'-3')(?'2')(?'-1')|){100}(?(3)(?'x')|(?'sum')(?'1'))))){99}", RegexOptions.Compiled);
    public int NumWaterBottles(int numBottles, int numExchange) {
        return regex.Match(numBottles + "," + numExchange).Groups["sum"].Captures.Count;
    }
}

using System.Text.RegularExpressions;
public class Solution {
    static Regex regex = new Regex(@"(?nx)
(?>(\d+(?<=
    (?>(?>0|1(?'y1')|2(?'y1'){2}|3(?'y1'){3}|4(?'y1'){4}|5(?'y1'){5}|6(?'y1'){6}|7(?'y1'){7}|8(?'y1'){8}|9(?'y1'){9})?)
    (?>(?>0|1(?'y2')|2(?'y2'){2}|3(?'y2'){3}|4(?'y2'){4}|5(?'y2'){5}|6(?'y2'){6}|7(?'y2'){7}|8(?'y2'){8}|9(?'y2'){9})?)
    (?>(?>0|1(?'y3')|2(?'y3'){2}|3(?'y3'){3}|4(?'y3'){4}|5(?'y3'){5}|6(?'y3'){6}|7(?'y3'){7}|8(?'y3'){8}|9(?'y3'){9})?)
    (?>(?>0|1(?'y4')|2(?'y4'){2}|3(?'y4'){3}|4(?'y4'){4}|5(?'y4'){5}|6(?'y4'){6}|7(?'y4'){7}|8(?'y4'){8}|9(?'y4'){9})?)
    (?>(?>0|1(?'y5')|2(?'y5'){2}|3(?'y5'){3}|4(?'y5'){4}|5(?'y5'){5}|6(?'y5'){6}|7(?'y5'){7}|8(?'y5'){8}|9(?'y5'){9})?)
    (?>(?>0|1(?'y6')|2(?'y6'){2}|3(?'y6'){3}|4(?'y6'){4}|5(?'y6'){5}|6(?'y6'){6}|7(?'y6'){7}|8(?'y6'){8}|9(?'y6'){9})?))
(?>(?'-y1')(?'-x1')|)((?'-y1')(?'y2'){10})?(?>(?'-y2')(?'-x2')|){9}((?'-y2')(?'y3'){10})?
    (?>(?'-y3')(?'-x3')|){9}((?'-y3')(?'y4'){10})?(?>(?'-y4')(?'-x4')|){9}((?'-y4')(?'y5'){10})?
    (?>(?'-y5')(?'-x5')|){9}((?'-y5')(?'y6'){10})?(?>(?'-y6')(?'-x6')|){9}
(?((?!(?'-x1'))(?!(?'-x2'))(?!(?'-x3'))(?!(?'-x4'))(?!(?'-x5'))(?!(?'-x6')))
    (?>(?'-y2')(?'z2')|){19}(?>(?'-y3')(?'z3')|){19}(?>(?'-y4')(?'z4')|){19}(?>(?'-y5')(?'z5')|){19}(?>(?'-y6')(?'z6')|){19}
    |(?>(?'-y1')|)(?>(?'-y2')|){19}(?>(?'-y3')|){19}(?>(?'-y4')|){19}(?>(?'-y5')|){19}(?>(?'-y6')|){19}
    (?>(?'-x1')|)(?>(?'-x2')|){19}(?>(?'-x3')|){19}(?>(?'-x4')|){19}(?>(?'-x5')|){19}(?>(?'-x6')|){19})
(?<=(?>(?>0|1(?'x1')|2(?'x1'){2}|3(?'x1'){3}|4(?'x1'){4}|5(?'x1'){5}|6(?'x1'){6}|7(?'x1'){7}|8(?'x1'){8}|9(?'x1'){9})?)
    (?>(?>0|1(?'x2')|2(?'x2'){2}|3(?'x2'){3}|4(?'x2'){4}|5(?'x2'){5}|6(?'x2'){6}|7(?'x2'){7}|8(?'x2'){8}|9(?'x2'){9})?)
    (?>(?>0|1(?'x3')|2(?'x3'){2}|3(?'x3'){3}|4(?'x3'){4}|5(?'x3'){5}|6(?'x3'){6}|7(?'x3'){7}|8(?'x3'){8}|9(?'x3'){9})?)
    (?>(?>0|1(?'x4')|2(?'x4'){2}|3(?'x4'){3}|4(?'x4'){4}|5(?'x4'){5}|6(?'x4'){6}|7(?'x4'){7}|8(?'x4'){8}|9(?'x4'){9})?)
    (?>(?>0|1(?'x5')|2(?'x5'){2}|3(?'x5'){3}|4(?'x5'){4}|5(?'x5'){5}|6(?'x5'){6}|7(?'x5'){7}|8(?'x5'){8}|9(?'x5'){9})?)
    (?>(?>0|1(?'x6')|2(?'x6'){2}|3(?'x6'){3}|4(?'x6'){4}|5(?'x6'){5}|6(?'x6'){6}|7(?'x6'){7}|8(?'x6'){8}|9(?'x6'){9})?)
)(?>,|$))+)", RegexOptions.Compiled);
    public int MinNumberOperations(int[] target) {
        if(target.Length <= 52066)
        {
            var mh = regex.Match(string.Join(",", target));
            return mh.Groups["z6"].Captures.Count + mh.Groups["z5"].Captures.Count * 10 +  mh.Groups["z4"].Captures.Count * 100
            + mh.Groups["z3"].Captures.Count * 1000 + mh.Groups["z2"].Captures.Count * 10000;
        }
        var n = target.Length;
        int pre = target[0];
        for(var i = 1; i < n; i++)
            if(target[i] > target[i-1])
                pre += target[i] - target[i-1];
        return pre;
    }
}

using System.Text.RegularExpressions;
public class Solution {
    //static Regex regex = new Regex(@"(?n)(?=(a(?'1')|b)+)((a((?'-2')|(?'-1'))|b(?'2')))+", RegexOptions.Compiled);
    static Regex regex = new Regex(@"(?>a(?>(?'-2')()|)|b())+", RegexOptions.Compiled);
    public int MinimumDeletions(string s) {
        return regex.Match(s).Groups[1].Captures.Count;
    }
}

using System.Text.RegularExpressions;
public class Solution {
    static Regex regex = new Regex(@"(?x)(?>(?(e)(?!))(?>
8(?(m8)|(?<=(?'r'\d))(?'m8')(?'m7')(?'m6')(?'m5')(?'m4')(?'m3')(?'m2')(?'m1'))|
7(?(m7)|(?<=(?'r'\d))(?'m7')(?'m6')(?'m5')(?'m4')(?'m3')(?'m2')(?'m1'))|
6(?(m6)|(?<=(?'r'\d))(?'m6')(?'m5')(?'m4')(?'m3')(?'m2')(?'m1'))|
5(?(m5)|(?<=(?'r'\d))(?'m5')(?'m4')(?'m3')(?'m2')(?'m1'))|
4(?(m4)|(?<=(?'r'\d))(?'m4')(?'m3')(?'m2')(?'m1'))|
3(?(m3)|(?<=(?'r'\d))(?'m3')(?'m2')(?'m1'))|
2(?(m2)|(?<=(?'r'\d))(?'m2')(?'m1'))|
1(?(m1)|(?<=(?'r'\d))(?'m1'))|
0
)|(?'r'9)(?'e'))*", RegexOptions.Compiled);
    public int MinPartitions(string n) {
        return int.Parse(regex.Match(n).Groups["r"].Value);
    }
}

using System.Text.RegularExpressions;
public class Solution {
    static Regex regex = new Regex(@"(?x)
(?>(?=\d)(?#此乃注释，下同。读取n，存入组n中)
    (?(n)(?#当组n存在捕获，则对组n的捕获放大10倍)
        (?#先将组n转存到组n1中)
        (?(n)(?>(?'-n')(?'n1')|){10}){10}(?#两层循环，减少循环空转的匹配次数)
        (?#相当于 n = n1 * 10。两层循环，减少循环空转的匹配次数)
        (?(n1)(?>(?'-n1')(?'n'){10}|){10}){10}
    )
    (?#将0->9，存入组#n)
    (?=[1469](?'n')|)(?=[27](?'n'){2}|)(?=[3489](?'n'){3}|)([56789](?'n'){5}|\d)
)+
(?'firstDay')(?#第一天要存的钱数)
(?#firstDay和firstDay2交替作为每天的存钱数)
(?>
    (?>(?>
            (?'-n')(?#减少一天)
            (?(firstDay)
                (?#当前是firstDay作为计数时，循环将当天的存钱数，压入组money的栈中)
                (?#两层循环，减少循环空转的匹配次数)
                (?(firstDay)((?'-firstDay')(?'firstDay2')(?'money')|){15}){10}
                (?'firstDay2')(?#每过一天，存钱数+1)
                |
                (?#当前是firstDay2作为计数时，循环将当天的存钱数，压入组money的栈中)
                (?#两层循环，减少循环空转的匹配次数)
                (?(firstDay2)((?'-firstDay2')(?'firstDay')(?'money')|){15}){10}
                (?'firstDay')(?#每过一天，存钱数+1)
            )
            |(?#剩下的天数不够一星期，则匹配空，循环空转)
    ){7})
    (?#firstDay或firstDay2减少6次，即星期天的存钱数 - 6，即为下周一的存钱数)
    (?(n)(?>(?'-firstDay'){6}|(?'-firstDay2'){6}))
){150}", RegexOptions.Compiled);
    public int TotalMoney(int n) {
        return regex.Match(n.ToString()).Groups["money"].Captures.Count;
    }
}

using System.Text.RegularExpressions;
public class Solution {
    public int CountGoodSubstrings(string s) {
        return Regex.Matches(s, @"(.)(?!\1)(?=(.).(?<!\1|\2))").Count;
    }
}

using System.Text.RegularExpressions;
public class Solution {
    public string MakeFancyString(string s) {
        return Regex.Replace(s, @"(.)\1*(?=\1{2})","");
    }
}

using System.Text.RegularExpressions;
public class Solution {
    public int MinimumMoves(string s) {
        return Regex.Matches(s, @"XOX|X{1,3}").Count;
    }
}

using System.Text.RegularExpressions;
public class Solution {
    static Regex regex = new Regex(@"(?x)^(?>(?>(1)|(2)|(3)|(4)|(5)|(6))+)$
(?>(?'-1')?)(?>(?'-2'){2}|)(?>(?'-3'){3}|)(?>(?'-4'){4}|)(?>(?'-5'){5}|)(?>(?'-6'){6}|)
(?!(?'-1'))(?!(?'-2'))(?!(?'-3'))(?!(?'-4'))(?!(?'-5'))(?!(?'-6'))", RegexOptions.Compiled);
    public int NextBeautifulNumber(int n) {
        while(n < int.MaxValue)
            if(regex.IsMatch((++n).ToString())) return n;
        return n;
    }
}

using System.Text.RegularExpressions;
public class Solution {
    static Regex regex = new Regex(@"(?X)
(?>
    (?>
        (?>
            (?'cur'1)|0
        )+
    )
    (?>,|$)
    (?(cur)
        (?<=
            (?(pre)
                (?(pre)
                    (?(pre)(?>(?'-pre')|){25}){20}
                    |
                    (?(pre1)(?>(?'-pre1')|){25}){20}
                )
                (?>
                    (?(pre)
                        (?(pre)(?>(?'ans')(?'pre1')(?'-pre')|){25}){20}
                        |
                        (?(pre1)(?>(?'ans')(?'pre')(?'-pre1')|){25}){20}
                    )
                    (?'last')(?'-cur').
                )+
                |
                (?(last)
                    (?(last)(?>(?'-last')|){25}){20}
                    |
                    (?(last1)(?>(?'-last1')|){25}){20}
                )
                (?>
                    (?(last)
                        (?(last)(?>(?'ans')(?'last1')(?'-last')|){25}){20}
                        |
                        (?(last1)(?>(?'ans')(?'last')(?'-last1')|){25}){20}
                    )
                    (?'pre')(?'-cur').
                )+
            )
        )
    )
)+", RegexOptions.Compiled);
    public int NumberOfBeams(string[] bank) {
        if(bank.Length * bank[0].Length < 160 * 1000)//规模太大，捕获组的数组会过大会导致内存溢出
            return regex.Match(string.Join(",",bank)).Groups["ans"].Captures.Count;
        int pre = 0, ans = 0;
        for(var i = 0; i < bank.Length; i++)
        {
            var s = bank[i];
            var cur = 0;
            for(var j = 0; j < s.Length; j++)
            {
                if(s[j] == '1') cur++;
            }
            if(cur == 0) continue;
            ans += cur * pre;
            pre = cur;
        }
        return ans;
    }
}

using System.Text.RegularExpressions;
public class Solution {
    public string CapitalizeTitle(string title) {
        return Regex.Replace(title.ToLower(), @"\b\w(?=\w{2,})", m => m.Value.ToUpper());
    }
}

using System.Text.RegularExpressions;
public class Solution {
    static Regex regex = new Regex(@"^P*(?>(?>SP*)(SP*))*(?>SP*)SP*$", RegexOptions.Compiled);
    public int NumberOfWays(string corridor) {
        var m = 1000000007;
        long ans = 1;
        var mh = regex.Match(corridor);
        if(!mh.Success) return 0;
        var cap = mh.Groups[1].Captures;
        for(var i = 0; i < cap.Count; i++)
            ans = ans * cap[i].Length % m;
        return (int)ans;
    }
}

using System.Text.RegularExpressions;
public class Solution {
    static Regex regex = new Regex(@"(?nx)
(?>(?>
    (?=\d)(?(k)(?>(?'-k')(?'2')|){10}){10}
    (?(2)(?>(?'-2')(?'k'){10}|){10}){10}
    (?=[147](?'k')|)(?=[258](?'k'){2}|)(?=[3459](?'k'){3}|)(?=[6789](?'k'){6}|)\d
)+),#读取original，存入组k
(
    (?>(?>#读取排好序的nums[i]，存入组k1
        (?=\d)(?(k1)(?>(?'-k1')(?'2')|){10}){10}
        (?(2)(?>(?'-2')(?'k1'){10}|){10}){10}
        (?=[147](?'k1')|)(?=[258](?'k1'){2}|)(?=[3459](?'k1'){3}|)(?=[6789](?'k1'){6}|)\d
    )+)
    (,|$)
    (?(k)#组k和组kk在nums[i]!=original时，交替用捕获计数表示original的值
        (?((?'-k')(?'-k1')(?'kk'))(?>(?'-k')(?'-k1')(?'kk')|){33}){31}#等价于k--;k1--;kk++;
        (#当组k和组k1都清空，表明nums[i]==k，令k = kk * 2
            (?!(?'-k'))(?!(?'-k1'))(?(kk)(?>(?'-kk')(?'k'){2}|){33}){31}
            |#否则将组k剩余计数转给组kk，清空组k1
            (?(k)(?>(?'-k')(?'kk')|){33}){31}(?(k1)(?>(?'-k1')|){33}){31}
        )
        |
        (?((?'-kk')(?'-k1')(?'k'))(?>(?'-kk')(?'-k1')(?'k')|){33}){31}#等价于kk--;k1--;k++;
        (#当组kk和组k1都清空，表明nums[i]==kk，令kk = k * 2
            (?!(?'-kk'))(?!(?'-k1'))(?(k)(?>(?'-k')(?'kk'){2}|){33}){31}
            |#否则将组kk剩余计数转给组k，清空组k1
            (?(kk)(?>(?'-kk')(?'k')|){33}){31}(?(k1)(?>(?'-k1')|){33}){31}
        )
    )
)+", RegexOptions.Compiled);
    public int FindFinalValue(int[] nums, int original) {
        Array.Sort(nums);
        var mh = regex.Match(original + "," + string.Join(",", nums));
        return mh.Groups["k"].Captures.Count + mh.Groups["kk"].Captures.Count;
    }
}

using System.Text.RegularExpressions;
public class Solution {
    static Regex regex = new Regex(@"(?x)
#此乃注释，下同。读取num1和num2的数值，存入组#num1和组#num2中#双重循环，减少循环空转次数
(?>(?=[1-9]\d*)(?>(?=\d)(?(num1)(?(num1)(?>(?'-num1')(?'n1')|){100}){100}
(?(n1)(?>(?'-n1')(?'num1'){10}|){100}){100})#读取低位数字，则需将高位数字 x 10，高位数字最高位100*100
(?=[1469](?'num1')|)(?=[27](?'num1'){2}|)(?=[3489](?'num1'){3}|)([56789](?'num1'){5}|\d))+),
(?>(?=[1-9]\d*)(?>(?=\d)(?(num2)(?(num2)(?>(?'-num2')(?'n1')|){100}){100}#逻辑同num1
(?(n1)(?>(?'-n1')(?'num2'){10}|){100}){100})# 相当于 num2 = (n1 = num2) x 10
(?=[1469](?'num2')|)(?=[27](?'num2'){2}|)(?=[3489](?'num2'){3}|)([56789](?'num2'){5}|\d))+)
#num1、num2、num3 三个数互相辗转相减
(?(?!(?!(?'-num1')(?'-num2')|(?'-num1')(?'-num3')|(?'-num2')(?'-num3')))
    (?(?!(?!(?'-num1')(?'-num2')|(?'-num1')(?'-num3')|(?'-num2')(?'-num3')))
        (?(?!(?!(?'-num1')(?'-num2')|(?'-num1')(?'-num3')|(?'-num2')(?'-num3')))
            (?((?'-num1')(?'-num2')(?'num3')(?'ans'))
                (?((?'-num1')(?'-num2')(?'num3'))(?((?'-num1')(?'-num2')(?'num3'))
                    (?>(?'-num1')(?'-num2')(?'num3')|){50}
                ){45}){45}#三重循环，减少循环空转次数
                |
                (?((?'-num1')(?'-num3')(?'num2')(?'ans'))
                    (?((?'-num1')(?'-num3')(?'num2'))(?((?'-num1')(?'-num3')(?'num2'))
                        (?>(?'-num1')(?'-num3')(?'num2')|){50}
                    ){45}){45}#三重循环，减少循环空转次数
                    |
                    (?((?'-num2')(?'-num3')(?'num1')(?'ans'))
                        (?((?'-num2')(?'-num3')(?'num1'))(?((?'-num2')(?'-num3')(?'num1'))
                            (?>(?'-num2')(?'-num3')(?'num1')|){50}
                        ){45}){45}#三重循环，减少循环空转次数
                    )
                )
            )
        ){50}
    ){45}
){45}", RegexOptions.Compiled);
    public int CountOperations(int num1, int num2) {
        return regex.Match($"{num1},{num2}").Groups["ans"].Captures.Count;
    }
}

using System.Text.RegularExpressions;
public class Solution {
    static Regex regex = new Regex(@"(?>R|(?'stop'S))(?>[RL]|(?'stop'S))*(?>L|(?'stop'S))", RegexOptions.Compiled);
    public int CountCollisions(string directions) {
        var mh = regex.Match(directions);
        if(mh.Success) return mh.Length - mh.Groups["stop"].Captures.Count;
        return 0;
    }
}

using System.Text.RegularExpressions;
public class Solution {
    static Regex regex = new Regex(@"(?xn)^(?=((?=[147](?'1')|)(?=[258](?'1'){2}|)
(?=[3459](?'1'){3}|)(?=[6789](?'1'){6}|)\d(?=,(?=[147](?'1')|)(?=[258](?'1'){2}|)
(?=[3459](?'1'){3}|)(?=[6789](?'1'){6}|)\d)?(?>((?<=\1)(?'-1')){10}|)(?'1',))+)
(?>(?'-1')(?>(?=\1)(?'-1')(?'2')|){9}(?=(?>(?'-1')\d(?>(?'-3')(?'2')|){9}(?>(?<=\1)
(?'-1')(?'2')(?'3')|){9}(?>((?<=\2)(?'-2')){10}|)(?'2',))+)(?>(?'-3')|){9}\d,|(?'-2')
(?>(?=\2)(?'-2')(?'1')|){9}(?=(?>(?'-2')\d(?>(?'-3')(?'1')|){9}(?>(?<=\2)(?'-2')(?'1')
(?'3')|){9}(?>((?<=\1)(?'-1')){10}|)(?'1',))+)(?>(?'-3')|){9}\d,|)+", RegexOptions.Compiled);
    public int TriangularSum(int[] nums) {
        if(nums.Length < 399)
        {
            var mh = regex.Match(string.Join(",", nums) + (nums.Length == 1?",":""));
            return mh.Groups[1].Captures.Count + mh.Groups[2].Captures.Count - 1;
        }
        var n = nums.Length;
        while(n-- > 0)
            for(var i = 0; i < n; i++)
                nums[i] = (nums[i] + nums[i + 1]) % 10;
        return nums[0];
    }
}

using System.Text.RegularExpressions;
public class Solution {
    static Regex regex = new Regex(@"(?x)(?<=(?=(?=(?'len'[a-z])+
(?>(?>[a-z]*),(?!(?!(?>(?>[a-z](?>(?'-len')|(?'len1')))+)(?!(?'-len'))
(?!(?'-len1'))))(?'kk'))*(?(kk)(?>(?'-kk')(?'k')|){10}){10})(?(k)|(?!))
(?>(?(kkk)(?!))(?>(?'-2')|){10}(?<!(?=(?>(?'-offset'.)*)(?=\1))
(?'-1'.(?'offset'))*?)([a-z])()(?=(?>\1(?'2')|[a-z])*)
(?=(?>(?>[a-z]*),(?!(?!(?>(?>\1(?>(?'-2')|(?'22'))|[a-z])+)
(?!(?'-2'))(?!(?'-22'))))(?'kk'))*(?(k)(?>(?'-kk')(?'-k')
(?'k1')|(?'-kk')|(?'-k')|){100}(?(k1)(?>(?'-k1')(?'k')|){10}){10})
(?(k)|(?'kkk'))))+)(?>[a-z]+)(?=,)(?!\G))(?>(?'-k'),[a-z]+)+", RegexOptions.Compiled);
    public IList<string> RemoveAnagrams(string[] words) {
        var input = string.Join(",", words);
        return regex.Replace(input, "").Split(",").ToList();
    }
}

using System.Text.RegularExpressions;
public class Solution {
    public bool StrongPasswordCheckerII(string password) {
        return Regex.IsMatch(password, @"^((([a-z])|([A-Z])|(\d)|([!@#$%^&*()\-+]))(?!\2)){8,}(?'-3')(?'-4')(?'-5')(?'-6')$");
        return Regex.IsMatch(password, @"^(?!.*(.)\1)(([a-z])|([A-Z])|(\d)|([!@#$%^&*()\-+])){8,}(?'-3')(?'-4')(?'-5')(?'-6')$");
    }
}

using System.Text.RegularExpressions;
public class Solution {
    static Regex regex = new Regex(@"(?x)
^(?=
(12(?'modIS12')|11(?'modIS11')|10(?'modIS10')|9(?'modIS9')|8(?'modIS8')|7(?'modIS7')|6(?'modIS6')|5(?'modIS5')|4(?'modIS4')|3(?'modIS3')|2(?'modIS2')|1(?'modIS1'))[#](?#<=确定模数大小)
(?>(?=-?\d)(?#<=提前探查还有数字没有匹配，避免无效的匹配时间浪费)
(?(modIS1)-?\d+,)(?#<=对1取余，余数永远是0)
(?(modIS2)(?'negative'-)?\d*(?=\d,)(?>[13579](?'mod')|\d),(?#<=对2取余，余数是1或0)
	    (?>(?'-negative')(?(mod)(?>(?!(?'-lock'))(?'-mod')|(?'mod')(?(lock)|(?'lock'))){2}(?'-lock'))|))(?#余数为负数则余数+2)
(?(modIS3)(?'negative'-)?(?>(?=[147](?'mod')|)([258](?'mod'){2}|\d)((?'-mod'){3}|))+,(?#对3取余)
	    (?>(?'-negative')(?(mod)(?>(?!(?'-lock'))(?'-mod')|(?'mod')(?(lock)|(?'lock'))){3}(?'-lock'))|))(?#余数为负数则余数+3)
(?(modIS4)(?'negative'-)?(?>(?=[13579](?'least')|)([2367](?'least'){2}|\d)(?(mod)((?'-mod')(?'least'){6}|){3})((?'-least'){4}|(?'mod-least')|){7})+,(?#对4取余)
	    (?>(?'-negative')(?(mod)(?>(?!(?'-lock'))(?'-mod')|(?'mod')(?(lock)|(?'lock'))){4}(?'-lock'))|))(?#余数为负数则余数+4)
(?(modIS5)(?'negative'-)?\d*(?=\d,)(?>[16](?'mod')|[27](?'mod'){2}|[38](?'mod'){3}|[49](?'mod'){4}|\d),(?#对5取余)
	    (?>(?'-negative')(?(mod)(?>(?!(?'-lock'))(?'-mod')|(?'mod')(?(lock)|(?'lock'))){5}(?'-lock'))|))(?#余数为负数则余数+5)
(?(modIS6)(?'negative'-)?(?>(?=[147](?'least')|)(?=[258](?'least'){2}|)([3459](?'least'){3}|\d)(?(mod)((?'-mod')(?'least'){4}|){5})((?'-least'){6}|(?'mod-least')|){8})+,(?#对6取余)
	    (?>(?'-negative')(?(mod)(?>(?!(?'-lock'))(?'-mod')|(?'mod')(?(lock)|(?'lock'))){6}(?'-lock'))|))(?#余数为负数则余数+6)
(?(modIS7)(?'negative'-)?(?>(?=[1468](?<least>)|)(?=[2569](?<least>){2}|)([3-6](?'mod')|\d)((?<-mod>)(?'least'){3}|){7}((?<-least>){7}|(?<mod-least>)|){9})+,(?#对取余)
	    (?>(?'-negative')(?(mod)(?>(?!(?'-lock'))(?'-mod')|(?'mod')(?(lock)|(?'lock'))){7}(?'-lock'))|))(?#余数为负数则余数+7)
(?(modIS8)(?'negative'-)?(?>(?=[13579](?'least')|)(?=[2367](?'least'){2}|)([4567](?'least'){4}|\d)(?(mod)((?'-mod')(?'least'){2}|){7})((?'-least'){8}|(?'mod-least')|){8})+,(?#对8取余)
	    (?>(?'-negative')(?(mod)(?>(?!(?'-lock'))(?'-mod')|(?'mod')(?(lock)|(?'lock'))){8}(?'-lock'))|))(?#余数为负数则余数+8)
(?(modIS9)(?'negative'-)?(?>(?=[1467](?'mod')|)(?=[2568](?'mod'){2}|)(?=[78](?'mod'){3}|)([3-8](?'mod'){3}|\d)((?'-mod'){9}|))+,(?#对9取余)
	    (?>(?'-negative')(?(mod)(?>(?!(?'-lock'))(?'-mod')|(?'mod')(?(lock)|(?'lock'))){9}(?'-lock'))|))(?#余数为负数则余数+9)
(?(modIS10)(?'negative'-)?\d*(?=\d,)(?>(?=[1469](?'mod')|)(?=[27](?'mod'){2}|)(?=[3489](?'mod'){3}|)([56789](?'mod'){5}|\d)),(?#对10取余)
	    (?>(?'-negative')(?(mod)(?>(?!(?'-lock'))(?'-mod')|(?'mod')(?(lock)|(?'lock'))){10}(?'-lock'))|))(?#余数为负数则余数+10)
(?(modIS11)(?'negative'-)?(?>(?=[1469](?'least')|)(?=[27](?'least'){2}|)(?=[3489](?'least'){3}|)([56789](?'least'){5}|\d)((?'-mod')(?'least'){10}|){10}((?'-least'){11}|(?'-least')(?'mod')|){19})+,(?#对11取余)
	    (?>(?'-negative')(?(mod)(?>(?!(?'-lock'))(?'-mod')|(?'mod')(?(lock)|(?'lock'))){11}(?'-lock'))|))(?#余数为负数则余数+11)
(?(modIS12)(?'negative'-)?(?>(?=[1469](?'least')|)(?=[27](?'least'){2}|)(?=[3489](?'least'){3}|)([56789](?'least'){5}|\d)((?'-mod')(?'least'){10}|){11}((?'-least'){12}|(?'-least')(?'mod')|){20})+,(?#对12取余)
	    (?>(?'-negative')(?(mod)(?>(?!(?'-lock'))(?'-mod')|(?'mod')(?(lock)|(?'lock'))){12}(?'-lock'))|))(?#余数为负数则余数+12)
(?#mod分组计算=>)(?#根据mod捕获数量作为余数，对m0...m11做填充=>)
(?>(?(modIS12)(?'-mod'){6}(?>(?'-mod'){5}(?'m11')|(?'-mod'){4}(?'m10')|(?'-mod'){3}(?'m9')|(?'-mod'){2}(?'m8')|(?'-mod')(?'m7')|(?'m6'))|(?!))|
(?(modIS11)(?'-mod'){6}(?>(?'-mod'){4}(?'m10')|(?'-mod'){3}(?'m9')|(?'-mod'){2}(?'m8')|(?'-mod')(?'m7')|(?'m6'))|(?!))|
(?(modIS10)(?'-mod'){6}(?>(?'-mod'){3}(?'m9')|(?'-mod'){2}(?'m8')|(?'-mod')(?'m7')|(?'m6'))|(?!))|(?(modIS9)(?'-mod'){6}(?>(?'-mod'){2}(?'m8')|(?'-mod')(?'m7')|(?'m6'))|(?!))|
(?(modIS8)(?'-mod'){6}(?>(?'-mod')(?'m7')|(?'m6'))|(?!))|(?(modIS7)(?'-mod'){6}(?'m6')|(?!))|(?'-mod'){5}(?'m5')|(?'-mod'){4}(?'m4')|(?'-mod'){3}(?'m3')|
(?'-mod'){2}(?'m2')|(?'-mod')(?'m1')|(?'m0'))
)+)(?#<=所有数字匹配完成，下面开始计算=>)(?#给所有小于模数的组解除锁定)
(?(modIS12)(?'modIS11'))(?(modIS11)(?'modIS10'))(?(modIS10)(?'modIS9'))(?(modIS9)(?'modIS8'))(?(modIS8)(?'modIS7'))(?(modIS7)(?'modIS6'))
(?(modIS6)(?'modIS5'))(?(modIS5)(?'modIS4'))(?(modIS4)(?'modIS3'))(?(modIS3)(?'modIS2'))(?(modIS2)(?'modIS1'))
(?#从m0到m11循环轮询是否有捕获，有则弹出一次，并且mex增加一个，直到某个捕获组m[i]为空=>)
(?=(?>(?!(?'-done')).(?(modIS1)((?'-m0')(?'mex')|(?'done'))|(?!))(?(done)|(?(modIS2)((?'-m1')(?'mex')|(?'done'))))
(?(done)|(?(modIS3)((?'-m2')(?'mex')|(?'done'))))(?(done)|(?(modIS4)((?'-m3')(?'mex')|(?'done'))))(?(done)|(?(modIS5)((?'-m4')(?'mex')|(?'done'))))
(?(done)|(?(modIS6)((?'-m5')(?'mex')|(?'done'))))(?(done)|(?(modIS7)((?'-m6')(?'mex')|(?'done'))))(?(done)|(?(modIS8)((?'-m7')(?'mex')|(?'done'))))
(?(done)|(?(modIS9)((?'-m8')(?'mex')|(?'done'))))(?(done)|(?(modIS10)((?'-m9')(?'mex')|(?'done'))))(?(done)|(?(modIS11)((?'-m10')(?'mex')|(?'done'))))
(?(done)|(?(modIS12)((?'-m11')(?'mex')|(?'done')))))+)", RegexOptions.Compiled);
    public int FindSmallestInteger(int[] nums, int value) {
        if(value <= 12)
        {
            var input = value + "#" + string.Join(",", nums) + ",";
            return regex.Match(input).Groups["mex"].Captures.Count;
        }
        int[] count = new int[value];
        for (var i = 0; i < nums.Length; i++) 
        {
            count[(nums[i] % value + value) % value]++;
        }
        int mex = 0;
        while (count[mex % value]-- > 0) 
        {
            mex++;
        }
        return mex;
    }
}

using System.Text.RegularExpressions;
public class Solution {
    public int MaxFrequencyElements(int[] nums) {
        return Regex.Match(new string('#',nums.Length) + string.Join(",",nums), @"^#+(?>(\d+(?'c')),?(?=(((?'1'\1(?'c'))|\d+)(,|$))*)(?<=(.(?'-1')(?'-max'))*)(?(1)(?<=(.(?'max')(?'sum')(?'-c'))+(?<=(?'-sum'.)*)(?<=(?'-1'.)+))|(?(max)(?<=(.(?'max')(?'-c'))+)|(?<=(.(?'max')(?'sum')(?'-c'))+))))+$").Groups["sum"].Captures.Count;

        Array.Sort(nums);
        var input = string.Join(",",nums);
        return Regex.Match(input, @"^(?>(\d+(?'c')),?((?'1'\1(?'c'))(,|$))*(?<=(.(?'-1')(?'-max'))*)(?(1)(?<=(.(?'max')(?'sum')(?'-c'))+(?<=(?'-sum'.)*)(?<=(?'-1'.)+))|(?(max)(?<=(.(?'max')(?'-c'))+)|(?<=(.(?'max')(?'sum')(?'-c'))+))))+$").Groups["sum"].Captures.Count;
    }
}

using System.Text.RegularExpressions;
public class Solution {
    static Regex regex = new Regex(@"(?xn)(?=^((?(1)(?>(?'-1')(?'-sum')(?'2')|){10}(?>(?'-2')
((?'1')(?'sum')){10}|){10})(?=[147](?'1')(?'sum')|)(?=[258]((?'1')(?'sum')){2}|)(?=[3459]
((?'1')(?'sum')){3}|)(?=[6789]((?'1')(?'sum')){6}|)\d)+,((?(2)(?>(?'-2')(?'3')|){10}
(?>(?'-3')(?'2'){10}|){10})(?=[147](?'2')|)(?=[258](?'2'){2}|)(?=[3459](?'2'){3}|)(?=[6789]
(?'2'){6}|)\d)+)(?(x)|(?(2)(?>(?'-2')(?'3')(?'-1')|){100}(?(2)(?'x')|(?'sum')(?'1')(?'3'))|(?(3)
(?>(?'-3')(?'2')(?'-1')|){100}(?(3)(?'x')|(?'sum')(?'1')(?'2'))))){15}", RegexOptions.Compiled);
    public int MaxBottlesDrunk(int numBottles, int numExchange) {
        return regex.Match(numBottles + "," + numExchange).Groups["sum"].Captures.Count;
    }
}

using System.Text.RegularExpressions;
public class Solution {
    public bool IsValid(string word) {
        return Regex.IsMatch(word, @"^(?i)(?>[aeiou]()|[a-z-[aeiou]]()|[0-9]){3,}$\1\2");
        return Regex.IsMatch(word, @"^(?>[aeiouAEIOU]()|[A-Za-z-[aeiouAEIOU]]()|[0-9]){3,}$\1\2");//更快
    }
}

using System.Text.RegularExpressions;
public class Solution {
    static Regex regex = new Regex(@"\b(?>(?>(?=[147]()|)([258](?'1'){2}|\d)((?'-1'){3}|))+)\b(?'-1')");
    public int MinimumOperations(int[] nums) {
        return regex.Matches(string.Join(",", nums)).Count;
    }
}

using System.Text.RegularExpressions;
public class Solution {
    static Regex regex = new Regex(@"(?x)
(?>
    1(?(count1)(?'count1')|(?'count'))
    |
    (?<=1)0
    (?(count)
        (?(count)(?>(?'-count')(?'ans')(?'count1')|){100}){100}
        |
        (?(count1)(?>(?'-count1')(?'ans')(?'count')|){100}){100}
    )
    |0
)+", RegexOptions.Compiled);
    public int MaxOperations(string s) {
        if(s.Length < 100 * 69) return regex.Match(s).Groups["ans"].Captures.Count;
        int ans = 0, num = 0;
        if(s[0] == '1') num++;
        for(var i = 1; i < s.Length; i++)
        {
            if(s[i] == '1')
            {
                if(s[i - 1] == '0') ans += num;
                num++;
            }
        }
        if(s[s.Length - 1] == '0') ans += num;
        return ans;
    }
}

using System.Text.RegularExpressions;
public class Solution {
    static Regex regex = new Regex(@"(?nx)(?>(?(y)|(?'1'\d+)
(?=((?(z)(?'-z')|,(?(\1(,|$))(?(x)(?'y'\d+)|(?'x'\d+))(?'z')|\d+))+)),))+", RegexOptions.Compiled);
    /*static Regex regex = new Regex(@"(?nx)(?(y)|((?<!(?=(?>(?'-offset'.)*)\1(?>,|$))(?'offset'.(?'-1'))*?)(?'1'\d+)|
(?(x)(?'y'\d+)|(?'x'\d+))),?)+", RegexOptions.Compiled);*/
    public int[] GetSneakyNumbers(int[] nums) {
        var mh = regex.Match(string.Join(",", nums));
        return new int[]{int.Parse(mh.Groups["x"].Value),int.Parse(mh.Groups["y"].Value)};
    }
}

using System.Text.RegularExpressions;
public class Solution {
    static Regex regex = new Regex(@"(?x)(?'pre')(?'max')(?>(?'c')(?>(?'x'0|1(?'x1')|2(?'x1'){2}|3
(?'x1'){3}|4(?'x1'){4}|5(?'x1'){5}|6(?'x1'){6}|7(?'x1'){7}|8(?'x1'){8}|9(?'x1'){9})?)(?>(?'x'0|1
(?'x2')|2(?'x2'){2}|3(?'x2'){3}|4(?'x2'){4}|5(?'x2'){5}|6(?'x2'){6}|7(?'x2'){7}|8(?'x2'){8}|9(?'x2'){9})?)
(?>(?'x'0|1(?'x3')|2(?'x3'){2}|3(?'x3'){3}|4(?'x3'){4}|5(?'x3'){5}|6(?'x3'){6}|7(?'x3'){7}|8(?'x3'){8}|9
(?'x3'){9})?)(?'x'0|1(?'x4')|2(?'x4'){2}|3(?'x4'){3}|4(?'x4'){4}|5(?'x4'){5}|6(?'x4'){6}|7(?'x4'){7}|8(?'x4'){8}|9
(?'x4'){9})?),(?>(?>(?'y'0|1(?'y1')|2(?'y1'){2}|3(?'y1'){3}|4(?'y1'){4}|5(?'y1'){5}|6(?'y1'){6}|7(?'y1'){7}|8
(?'y1'){8}|9(?'y1'){9})?)(?>(?'y'0|1(?'y2')|2(?'y2'){2}|3(?'y2'){3}|4(?'y2'){4}|5(?'y2'){5}|6(?'y2'){6}|7
(?'y2'){7}|8(?'y2'){8}|9(?'y2'){9})?)(?>(?'y'0|1(?'y3')|2(?'y3'){2}|3(?'y3'){3}|4(?'y3'){4}|5(?'y3'){5}|6
(?'y3'){6}|7(?'y3'){7}|8(?'y3'){8}|9(?'y3'){9})?)(?'y'0|1(?'y4')|2(?'y4'){2}|3(?'y4'){3}|4(?'y4'){4}|5(?'y4'){5}|6
(?'y4'){6}|7(?'y4'){7}|8(?'y4'){8}|9(?'y4'){9})?(?>(?'-y')(?'-x')|){4}(?(x)|(?(y)(?'more')|(?>(?'-y1')(?'-x1')|){9}
(?>(?!(?'-x1'))(?!(?'-y1'))(?>(?'-y2')(?'-x2')|){9}(?>(?!(?'-x2'))(?!(?'-y2'))(?>(?'-y3')(?'-x3')|){9}(?>(?!(?'-x3'))
(?!(?'-y3'))(?>(?'-y4')(?'-x4')|){9}(?>(?!(?'-x4'))(?!(?'-y4'))|(?'-x4')|(?'more'))|(?'-x3')|(?'more'))|(?'-x2')|
(?'more'))|(?'-x1')|(?'more'))))(?((?'-more'))(?'c')|(?(pre)(?(c)(?>(?'-pre')(?'-c')(?'t')(?'t1')|){10})){10}(?(max)
(?(t)(?>(?'-max')(?'-t')(?'tt')|){10})){10}(?(tt)(?>(?'-tt')(?'max')|){10}){10}(?(t)(?>(?'-t')(?'max')|){10}){10}(?(t1)
(?>(?'-t1')(?'pre')(?'c')|){10}){10}(?<=(?(div)(?'-div'(?'half'(?'-c'.)(?'h1')))|(?'div'(?'-c'.(?'h1'))))+)(?>(?'-div')|)
(?(h1)(?>(?'-h1')(?'c')|){10}){5}(?(max)(?(half)(?>(?'-max')(?'-half')(?'t')|){10})){10}(?(t)(?>(?'-t')(?'max')|){10}){10}
(?(half)(?>(?'-half')(?'max')|){10}){10}(?(pre)(?>(?'-pre')|){10}){10}(?(c)(?>(?'-c')(?'pre')|){10}){10}(?'c'))(?>(?'-x')|){3}
(?>(?'-x1')|){9}(?>(?'-x2')|){9}(?>(?'-x3')|){9}(?>(?'-x4')|){9}(?>(?'-y')|){3}(?>(?'-y1')|){9}(?>(?'-y2')|){9}(?>(?'-y3')|){9}
(?>(?'-y4')|){9}(?<=(?=(?>(?'x'0|1(?'x1')|2(?'x1'){2}|3(?'x1'){3}|4(?'x1'){4}|5(?'x1'){5}|6(?'x1'){6}|7(?'x1'){7}|8(?'x1'){8}|9
(?'x1'){9})?)(?>(?'x'0|1(?'x2')|2(?'x2'){2}|3(?'x2'){3}|4(?'x2'){4}|5(?'x2'){5}|6(?'x2'){6}|7(?'x2'){7}|8(?'x2'){8}|9(?'x2'){9})?)
(?>(?'x'0|1(?'x3')|2(?'x3'){2}|3(?'x3'){3}|4(?'x3'){4}|5(?'x3'){5}|6(?'x3'){6}|7(?'x3'){7}|8(?'x3'){8}|9(?'x3'){9})?)
(?'x'0|1(?'x4')|2(?'x4'){2}|3(?'x4'){3}|4(?'x4'){4}|5(?'x4'){5}|6(?'x4'){6}|7(?'x4'){7}|8(?'x4'){8}|9(?'x4'){9})?)(?>\d+))
(?>,|$))+(?(pre)(?(c)(?>(?'-pre')(?'-c')(?'t')(?'t1')|){10})){10}(?(max)(?(t)(?>(?'-max')(?'-t')(?'tt')|){10})){10}(?(tt)
(?>(?'-tt')(?'max')|){10}){10}(?(t)(?>(?'-t')(?'max')|){10}){10}(?(t1)(?>(?'-t1')(?'c')|){10}){10}(?<=(?(div)
(?'-div'(?'half'(?'-c'.)))|(?'div'(?'-c'.)))+)(?(max)(?(half)(?>(?'-max')(?'-half')(?'t')|){10})){10}
(?(t)(?>(?'-t')(?'max')|){10}){10}(?(half)(?>(?'-half')(?'max')|){10}){10}", RegexOptions.Compiled);
    public bool HasIncreasingSubarrays(IList<int> nums, int k) {
        for (var i = 0; i < nums.Count; i++) nums[i] += 1000;//全部转换成正数，便于匹配比较
        return regex.Match(string.Join(",",nums)).Groups["max"].Captures.Count >= k;
    }
}

using System.Text.RegularExpressions;
public class Solution {
    static Regex regex_3000_ = new Regex(@"(?x)(?'pre')(?'max')(?>(?'c')(?>(?'x'0|1(?'x1')|2(?'x1'){2}|3(?'x1'){3}|4(?'x1'){4}|5(?'x1'){5}|6
(?'x1'){6}|7(?'x1'){7}|8(?'x1'){8}|9(?'x1'){9})?)(?>(?'x'0|1(?'x2')|2(?'x2'){2}|3(?'x2'){3}|4(?'x2'){4}|5(?'x2'){5}|6(?'x2'){6}|7(?'x2'){7}|8
(?'x2'){8}|9(?'x2'){9})?)(?>(?'x'0|1(?'x3')|2(?'x3'){2}|3(?'x3'){3}|4(?'x3'){4}|5(?'x3'){5}|6(?'x3'){6}|7(?'x3'){7}|8(?'x3'){8}|9(?'x3'){9})?)
(?>(?'x'0|1(?'x4')|2(?'x4'){2}|3(?'x4'){3}|4(?'x4'){4}|5(?'x4'){5}|6(?'x4'){6}|7(?'x4'){7}|8(?'x4'){8}|9(?'x4'){9})?)(?>(?'x'0|1(?'x5')|2
(?'x5'){2}|3(?'x5'){3}|4(?'x5'){4}|5(?'x5'){5}|6(?'x5'){6}|7(?'x5'){7}|8(?'x5'){8}|9(?'x5'){9})?)(?>(?'x'0|1(?'x6')|2(?'x6'){2}|3
(?'x6'){3}|4(?'x6'){4}|5(?'x6'){5}|6(?'x6'){6}|7(?'x6'){7}|8(?'x6'){8}|9(?'x6'){9})?)(?>(?'x'0|1(?'x7')|2(?'x7'){2}|3
(?'x7'){3}|4(?'x7'){4}|5(?'x7'){5}|6(?'x7'){6}|7(?'x7'){7}|8(?'x7'){8}|9(?'x7'){9})?)(?>(?'x'0|1(?'x8')|2(?'x8'){2}|3
(?'x8'){3}|4(?'x8'){4}|5(?'x8'){5}|6(?'x8'){6}|7(?'x8'){7}|8(?'x8'){8}|9(?'x8'){9})?)(?>(?'x'0|1(?'x9')|2(?'x9'){2}|3
(?'x9'){3}|4(?'x9'){4}|5(?'x9'){5}|6(?'x9'){6}|7(?'x9'){7}|8(?'x9'){8}|9(?'x9'){9})?)(?'x'0|1(?'x10')|2(?'x10'){2}|3
(?'x10'){3}|4(?'x10'){4}|5(?'x10'){5}|6(?'x10'){6}|7(?'x10'){7}|8(?'x10'){8}|9(?'x10'){9})?),(?>(?>(?'y'0|1(?'y1')|2(?'y1'){2}|3
(?'y1'){3}|4(?'y1'){4}|5(?'y1'){5}|6(?'y1'){6}|7(?'y1'){7}|8(?'y1'){8}|9(?'y1'){9})?)(?>(?'y'0|1(?'y2')|2(?'y2'){2}|3
(?'y2'){3}|4(?'y2'){4}|5(?'y2'){5}|6(?'y2'){6}|7(?'y2'){7}|8(?'y2'){8}|9(?'y2'){9})?)(?>(?'y'0|1(?'y3')|2(?'y3'){2}|3
(?'y3'){3}|4(?'y3'){4}|5(?'y3'){5}|6(?'y3'){6}|7(?'y3'){7}|8(?'y3'){8}|9(?'y3'){9})?)(?>(?'y'0|1(?'y4')|2(?'y4'){2}|3
(?'y4'){3}|4(?'y4'){4}|5(?'y4'){5}|6(?'y4'){6}|7(?'y4'){7}|8(?'y4'){8}|9(?'y4'){9})?)(?>(?'y'0|1(?'y5')|2(?'y5'){2}|3
(?'y5'){3}|4(?'y5'){4}|5(?'y5'){5}|6(?'y5'){6}|7(?'y5'){7}|8(?'y5'){8}|9(?'y5'){9})?)(?>(?'y'0|1(?'y6')|2(?'y6'){2}|3
(?'y6'){3}|4(?'y6'){4}|5(?'y6'){5}|6(?'y6'){6}|7(?'y6'){7}|8(?'y6'){8}|9(?'y6'){9})?)(?>(?'y'0|1(?'y7')|2(?'y7'){2}|3
(?'y7'){3}|4(?'y7'){4}|5(?'y7'){5}|6(?'y7'){6}|7(?'y7'){7}|8(?'y7'){8}|9(?'y7'){9})?)(?>(?'y'0|1(?'y8')|2(?'y8'){2}|3
(?'y8'){3}|4(?'y8'){4}|5(?'y8'){5}|6(?'y8'){6}|7(?'y8'){7}|8(?'y8'){8}|9(?'y8'){9})?)(?>(?'y'0|1(?'y9')|2(?'y9'){2}|3
(?'y9'){3}|4(?'y9'){4}|5(?'y9'){5}|6(?'y9'){6}|7(?'y9'){7}|8(?'y9'){8}|9(?'y9'){9})?)(?'y'0|1(?'y10')|2(?'y10'){2}|3
(?'y10'){3}|4(?'y10'){4}|5(?'y10'){5}|6(?'y10'){6}|7(?'y10'){7}|8(?'y10'){8}|9(?'y10'){9})?(?>(?'-y')(?'-x')|){10}(?(x)|(?(y)(?'more')|
(?>(?'-y1')(?'-x1')|){9}(?>(?!(?'-x1'))(?!(?'-y1'))(?>(?'-y2')(?'-x2')|){9}(?>(?!(?'-x2'))(?!(?'-y2'))(?>(?'-y3')(?'-x3')|){9}
(?>(?!(?'-x3'))(?!(?'-y3'))(?>(?'-y4')(?'-x4')|){9}(?>(?!(?'-x4'))(?!(?'-y4'))(?>(?'-y5')(?'-x5')|){9}(?>(?!(?'-x5'))(?!(?'-y5'))
(?>(?'-y6')(?'-x6')|){9}(?>(?!(?'-x6'))(?!(?'-y6'))(?>(?'-y7')(?'-x7')|){9}(?>(?!(?'-x7'))(?!(?'-y7'))(?>(?'-y8')(?'-x8')|){9}
(?>(?!(?'-x8'))(?!(?'-y8'))(?>(?'-y9')(?'-x9')|){9}(?>(?!(?'-x9'))(?!(?'-y9'))(?>(?'-y10')(?'-x10')|){9}(?>(?!(?'-x10'))(?!(?'-y10'))|
(?'-x10')|(?'more'))|(?'-x9')|(?'more'))|(?'-x8')|(?'more'))|(?'-x7')|(?'more'))|(?'-x6')|(?'more'))|(?'-x5')|(?'more'))|(?'-x4')|
(?'more'))|(?'-x3')|(?'more'))|(?'-x2')|(?'more'))|(?'-x1')|(?'more'))))(?((?'-more'))(?'c')|(?(pre)(?(c)(?(pre)(?(c)(?(pre)(?(c)
(?(pre)(?(c)(?>(?'-pre')(?'-c')(?'t')(?'t1')|){6})){6})){6})){6})){6}(?(max)(?(t)(?(max)(?(t)(?(max)(?(t)(?(max)(?(t)(?>(?'-max')(?'-t')
(?'tt')|){6})){6})){6})){6})){6}(?(tt)(?(tt)(?(tt)(?(tt)(?>(?'-tt')(?'max')|){6}){6}){6}){6}){6}(?(t)(?(t)(?(t)(?(t)(?>(?'-t')
(?'max')|){6}){6}){6}){6}){6}(?(t1)(?(t1)(?(t1)(?(t1)(?>(?'-t1')(?'pre')(?'c')|){6}){6}){6}){6}){6}(?<=(?(div)(?'-div'(?'half'(?'-c'.)
(?'h1')))|(?'div'(?'-c'.(?'h1'))))+)(?>(?'-div')|)(?(h1)(?(h1)(?(h1)(?(h1)(?>(?'-h1')(?'c')|){6}){6}){6}){6}){6}(?(max)(?(half)
(?(max)(?(half)(?(max)(?(half)(?(max)(?(half)(?>(?'-max')(?'-half')(?'t')|){6})){6})){6})){6})){6}(?(t)(?(t)(?(t)(?(t)(?>(?'-t')
(?'max')|){6}){6}){6}){6}){6}(?(half)(?(half)(?(half)(?(half)(?>(?'-half')(?'max')|){6}){6}){6}){6}){6}(?(pre)(?(pre)(?(pre)(?(pre)
(?>(?'-pre')|){6}){6}){6}){6}){6}(?(c)(?(c)(?(c)(?(c)(?>(?'-c')(?'pre')|){6}){6}){6}){6}){6}(?'c'))(?>(?'-x')|){10}(?>(?'-x1')|){9}
(?>(?'-x2')|){9}(?>(?'-x3')|){9}(?>(?'-x4')|){9}(?>(?'-x5')|){9}(?>(?'-x6')|){9}(?>(?'-x7')|){9}(?>(?'-x8')|){9}(?>(?'-x9')|){9}
(?>(?'-x10')|){9}(?>(?'-y')|){10}(?>(?'-y1')|){9}(?>(?'-y2')|){9}(?>(?'-y3')|){9}(?>(?'-y4')|){9}(?>(?'-y5')|){9}(?>(?'-y6')|){9}
(?>(?'-y7')|){9}(?>(?'-y8')|){9}(?>(?'-y9')|){9}(?>(?'-y10')|){9}(?<=(?=(?>(?'x'0|1(?'x1')|2(?'x1'){2}|3(?'x1'){3}|4(?'x1'){4}|5
(?'x1'){5}|6(?'x1'){6}|7(?'x1'){7}|8(?'x1'){8}|9(?'x1'){9})?)(?>(?'x'0|1(?'x2')|2(?'x2'){2}|3(?'x2'){3}|4(?'x2'){4}|5(?'x2'){5}|6
(?'x2'){6}|7(?'x2'){7}|8(?'x2'){8}|9(?'x2'){9})?)(?>(?'x'0|1(?'x3')|2(?'x3'){2}|3(?'x3'){3}|4(?'x3'){4}|5(?'x3'){5}|6(?'x3'){6}|7
(?'x3'){7}|8(?'x3'){8}|9(?'x3'){9})?)(?>(?'x'0|1(?'x4')|2(?'x4'){2}|3(?'x4'){3}|4(?'x4'){4}|5(?'x4'){5}|6(?'x4'){6}|7(?'x4'){7}|8(?'x4'){8}|9
(?'x4'){9})?)(?>(?'x'0|1(?'x5')|2(?'x5'){2}|3(?'x5'){3}|4(?'x5'){4}|5(?'x5'){5}|6(?'x5'){6}|7(?'x5'){7}|8(?'x5'){8}|9(?'x5'){9})?)
(?>(?'x'0|1(?'x6')|2(?'x6'){2}|3(?'x6'){3}|4(?'x6'){4}|5(?'x6'){5}|6(?'x6'){6}|7(?'x6'){7}|8(?'x6'){8}|9(?'x6'){9})?)(?>(?'x'0|1
(?'x7')|2(?'x7'){2}|3(?'x7'){3}|4(?'x7'){4}|5(?'x7'){5}|6(?'x7'){6}|7(?'x7'){7}|8(?'x7'){8}|9(?'x7'){9})?)(?>(?'x'0|1(?'x8')|2(?'x8'){2}|3
(?'x8'){3}|4(?'x8'){4}|5(?'x8'){5}|6(?'x8'){6}|7(?'x8'){7}|8(?'x8'){8}|9(?'x8'){9})?)(?>(?'x'0|1(?'x9')|2(?'x9'){2}|3
(?'x9'){3}|4(?'x9'){4}|5(?'x9'){5}|6(?'x9'){6}|7(?'x9'){7}|8(?'x9'){8}|9(?'x9'){9})?)(?'x'0|1(?'x10')|2(?'x10'){2}|3
(?'x10'){3}|4(?'x10'){4}|5(?'x10'){5}|6(?'x10'){6}|7(?'x10'){7}|8(?'x10'){8}|9(?'x10'){9})?)(?>\d+))(?>,|$))+(?(pre)(?(c)(?(pre)
(?(c)(?(pre)(?(c)(?(pre)(?(c)(?>(?'-pre')(?'-c')(?'t')(?'t1')|){6})){6})){6})){6})){6}(?(max)(?(t)(?(max)(?(t)(?(max)(?(t)(?(max)(?(t)
(?>(?'-max')(?'-t')(?'tt')|){6})){6})){6})){6})){6}(?(tt)(?(tt)(?(tt)(?(tt)(?>(?'-tt')(?'max')|){6}){6}){6}){6}){6}(?(t)(?(t)(?(t)(?(t)
(?>(?'-t')(?'max')|){6}){6}){6}){6}){6}(?(t1)(?(t1)(?(t1)(?(t1)(?>(?'-t1')(?'c')|){6}){6}){6}){6}){6}(?<=(?(div)(?'-div'(?'half'(?'-c'.)))|
(?'div'(?'-c'.)))+)(?(max)(?(half)(?(max)(?(half)(?(max)(?(half)(?(max)(?(half)(?>(?'-max')(?'-half')(?'t')|){6})){6})){6})){6})){6}
(?(t)(?(t)(?(t)(?(t)(?>(?'-t')(?'max')|){6}){6}){6}){6}){6}(?(half)(?(half)(?(half)(?(half)(?>(?'-half')(?'max')|){6}){6}){6}){6}){6}", RegexOptions.Compiled);
    static Regex regex_100_3000 = new Regex(@"(?x)(?'pre')(?'max')(?=(?>\d+)(?<=(?'c')(?>(?<=(?'x1',)\d*)(?'x'0|(?'x1')1|(?'x1'){2}2|
(?'x1'){3}3|(?'x1'){4}4|(?'x1'){5}5|(?'x1'){6}6|(?'x1'){7}7|(?'x1'){8}8|(?'x1'){9}9))+))(?>\d+),(?>(?=(?>\d+)(?<=(?>(?<=(?'y1',)\d*)(?'y'0|(?'y1')1|(?'y1'){2}2|
(?'y1'){3}3|(?'y1'){4}4|(?'y1'){5}5|(?'y1'){6}6|(?'y1'){7}7|(?'y1'){8}8|(?'y1'){9}9))+))(?>\d+)(?>(?'-y')(?'-x')|){10}(?(x)|(?(y)(?'more')|(?>(?!(?'-finishCompare'))
(?>(?>(?'-x1')(?'-y1'))?)(?>(?<=\k'x1')(?'-x1')(?'x2')|){9}(?>(?<=\k'y1')(?'-y1')(?'y2')|){9}(?>(?'-x2')(?'-y2')|){9}(?>(?!(?'-x2'))
(?!(?'-y2'))|(?'-x2')(?'finishCompare')(?>(?'-x2')|){9}|(?'more')(?'finishCompare')(?>(?'-y2')|){9})|){10}(?>(?'-finishCompare')|)))(?((?'-more'))(?'c')|
(?(pre)(?(c)(?(pre)(?(c)(?(pre)(?(c)(?(pre)(?(c)(?>(?'-pre')(?'-c')(?'t')(?'t1')|){5})){5})){5})){5})){5}(?(max)(?(t)(?(max)(?(t)(?(max)(?(t)(?(max)(?(t)
(?>(?'-max')(?'-t')(?'tt')|){5})){5})){5})){5})){5}(?(tt)(?(tt)(?(tt)(?(tt)(?>(?'-tt')(?'max')|){5}){5}){5}){5}){5}(?(t)(?(t)(?(t)(?(t)(?>(?'-t')
(?'max')|){5}){5}){5}){5}){5}(?(t1)(?(t1)(?(t1)(?(t1)(?>(?'-t1')(?'pre')(?'c')|){5}){5}){5}){5}){5}(?<=(?(div)(?'-div'(?'half'(?'-c'.)(?'h1')))|
(?'div'(?'-c'.(?'h1'))))+)(?>(?'-div')|)(?(h1)(?(h1)(?(h1)(?(h1)(?>(?'-h1')(?'c')|){5}){5}){5}){5}){5}(?(max)(?(half)(?(max)(?(half)(?(max)(?(half)(?(max)
(?(half)(?>(?'-max')(?'-half')(?'t')|){5})){5})){5})){5})){5}(?(t)(?(t)(?(t)(?(t)(?>(?'-t')(?'max')|){5}){5}){5}){5}){5}(?(half)(?(half)(?(half)(?(half)
(?>(?'-half')(?'max')|){5}){5}){5}){5}){5}(?(pre)(?(pre)(?(pre)(?(pre)(?>(?'-pre')|){5}){5}){5}){5}){5}(?(c)(?(c)(?(c)(?(c)(?>(?'-c')(?'pre')|){5}){5}){5}){5}){5}
(?'c'))(?>(?'-x')|){11}(?(x1)(?>(?'-x1')|){10}){10}(?>(?'-y')|){11}(?(y1)(?>(?'-y1')|){10}){10}(?<=(?>(?<=(?'x1',)\d*)(?'x'0|(?'x1')1|(?'x1'){2}2|
(?'x1'){3}3|(?'x1'){4}4|(?'x1'){5}5|(?'x1'){6}6|(?'x1'){7}7|(?'x1'){8}8|(?'x1'){9}9))+)(?>,|$))+(?(pre)(?(c)(?(pre)(?(c)(?(pre)(?(c)(?(pre)(?(c)(?>(?'-pre')
(?'-c')(?'t')(?'t1')|){5})){5})){5})){5})){5}(?(max)(?(t)(?(max)(?(t)(?(max)(?(t)(?(max)(?(t)(?>(?'-max')(?'-t')(?'tt')|){5})){5})){5})){5})){5}(?(tt)(?(tt)
(?(tt)(?(tt)(?>(?'-tt')(?'max')|){5}){5}){5}){5}){5}(?(t)(?(t)(?(t)(?(t)(?>(?'-t')(?'max')|){5}){5}){5}){5}){5}(?(t1)(?(t1)(?(t1)(?(t1)(?>(?'-t1')
(?'c')|){5}){5}){5}){5}){5}(?<=(?(div)(?'-div'(?'half'(?'-c'.)))|(?'div'(?'-c'.)))+)(?(max)(?(half)(?(max)(?(half)(?(max)(?(half)(?(max)(?(half)(?>(?'-max')
(?'-half')(?'t')|){5})){5})){5})){5})){5}(?(t)(?(t)(?(t)(?(t)(?>(?'-t')(?'max')|){5}){5}){5}){5}){5}(?(half)(?(half)(?(half)(?(half)(?>(?'-half')
(?'max')|){5}){5}){5}){5}){5}", RegexOptions.Compiled);
    static Regex regex_100 = new Regex(@"(?x)(?'pre')(?'max')(?=(?>\d+)(?<=(?'c')(?>(?<=(?'x1',)\d*)(?'x'0|(?'x1')1|(?'x1'){2}2|
(?'x1'){3}3|(?'x1'){4}4|(?'x1'){5}5|(?'x1'){6}6|(?'x1'){7}7|(?'x1'){8}8|(?'x1'){9}9))+))(?>\d+),(?>(?=(?>\d+)(?<=(?>(?<=(?'y1',)\d*)(?'y'0|(?'y1')1|
(?'y1'){2}2|(?'y1'){3}3|(?'y1'){4}4|(?'y1'){5}5|(?'y1'){6}6|(?'y1'){7}7|(?'y1'){8}8|(?'y1'){9}9))+))(?>\d+)(?>(?'-y')(?'-x')|){20}(?(x)|(?(y)(?'more')|
(?>(?!(?'-finishCompare'))(?>(?>(?'-x1')(?'-y1'))?)(?>(?<=\k'x1')(?'-x1')(?'x2')|){9}(?>(?<=\k'y1')(?'-y1')(?'y2')|){9}(?>(?'-x2')(?'-y2')|){9}
(?>(?!(?'-x2'))(?!(?'-y2'))|(?'-x2')(?'finishCompare')(?>(?'-x2')|){9}|(?'more')(?'finishCompare')(?>(?'-y2')|){9})|){20}(?>(?'-finishCompare')|)))
(?((?'-more'))(?'c')|(?(pre)(?(c)(?>(?'-pre')(?'-c')(?'t')(?'t1')|){10})){10}(?(max)(?(t)(?>(?'-max')(?'-t')(?'tt')|){10})){10}(?(tt)(?>(?'-tt')
(?'max')|){10}){10}(?(t)(?>(?'-t')(?'max')|){10}){10}(?(t1)(?>(?'-t1')(?'pre')(?'c')|){10}){10}(?<=(?(div)(?'-div'(?'half'(?'-c'.)(?'h1')))|
(?'div'(?'-c'.(?'h1'))))+)(?>(?'-div')|)(?(h1)(?>(?'-h1')(?'c')|){10}){5}(?(max)(?(half)(?>(?'-max')(?'-half')(?'t')|){10})){10}(?(t)(?>(?'-t')
(?'max')|){10}){10}(?(half)(?>(?'-half')(?'max')|){10}){10}(?(pre)(?>(?'-pre')|){10}){10}(?(c)(?>(?'-c')(?'pre')|){10}){10}(?'c'))(?>(?'-x')|){11}(?(x1)
(?>(?'-x1')|){10}){10}(?>(?'-y')|){11}(?(y1)(?>(?'-y1')|){10}){10}(?<=(?>(?<=(?'x1',)\d*)(?'x'0|(?'x1')1|(?'x1'){2}2|(?'x1'){3}3|(?'x1'){4}4|(?'x1'){5}5|
(?'x1'){6}6|(?'x1'){7}7|(?'x1'){8}8|(?'x1'){9}9))+)(?>,|$))+(?(pre)(?(c)(?>(?'-pre')(?'-c')(?'t')(?'t1')|){10})){10}(?(max)(?(t)(?>(?'-max')(?'-t')(?'tt')|){10})){10}
(?(tt)(?>(?'-tt')(?'max')|){10}){10}(?(t)(?>(?'-t')(?'max')|){10}){10}(?(t1)(?>(?'-t1')(?'c')|){10}){10}(?<=(?(div)(?'-div'(?'half'(?'-c'.)))|(?'div'(?'-c'.)))+)
(?(max)(?(half)(?>(?'-max')(?'-half')(?'t')|){10})){10}(?(t)(?>(?'-t')(?'max')|){10}){10}(?(half)(?>(?'-half')(?'max')|){10}){10}", RegexOptions.Compiled);
    public int MaxIncreasingSubarrays(IList<int> nums) {
        if(nums.Count <= 5278)  for (var i = 0; i < nums.Count; i++) nums[i] += 1000000000;//全部转换成正数，便于匹配比较
        if(nums.Count <= 100) return regex_100.Match(","+string.Join(",",nums)).Groups["max"].Captures.Count;
        if(nums.Count <= 3000) return regex_100_3000.Match(","+string.Join(",",nums)).Groups["max"].Captures.Count;
        if(nums.Count <= 5278) return regex_3000_.Match(string.Join(",",nums)).Groups["max"].Captures.Count;
        int n = nums.Count;
        int c = 1, pre = 1, result = 1;
        for (int i = 1; i < n; i++) {
            if (nums[i] > nums[i - 1]) {
                c++;
            } else {
                result = Math.Max(result, Math.Min(pre, c));
                result = Math.Max(result, c / 2);
                pre = c;
                c = 1;
            }
        }
        result = Math.Max(result, Math.Min(pre, c));
        result = Math.Max(result, c / 2);
        return result;
    }
}

using System.Text.RegularExpressions;
public class Solution {
    static Regex regex = new Regex(@"(?x)
(?#此乃注释，下同。将数组所有元素和，压入组#right的栈中)
(?=(?>(?>(?=[1-9]\d*)(?>(?=\d)
    (?(n)(?(n)(?>(?'-n')(?'n1')|){10}){10}(?>(?'-n1')(?'n'){10}|){10})
    (?=[1469](?'n')|)(?=[27](?'n'){2}|)(?=[3489](?'n'){3}|)([56789](?'n'){5}|\d)
)+(?(n)(?>(?'-n')(?'right')|){10}){10}(,|$)|0(,|$))*))
(?#遇到大于0的数，就对组#right减少这个数的两倍)
(?#遇到0，则判断当前位置是否有效。是，则连续匹配0，并加上对应次数的方案数)
(?>(?(end)|(?>
    (?>(?!(?'-n'))(?=[1-9]\d*)(?>(?>
        (?=\d)(?(n)(?(n)(?>(?'-n')(?'n1')|){10}){10}(?>(?'-n1')(?'n'){10}|){10})
        (?=[1469](?'n')|)(?=[27](?'n'){2}|)(?=[3489](?'n'){3}|)([56789](?'n'){5}|\d)
    )+)(?(n)(?>(?'-n')(?'-right'){2}|){10}){10}(,|$))+|0(,|$)
    (?(n)(?((?!(?!(?'-n')(?!(?'-n')))))
            (?'-n')(?'-right')(?'left')
            (?((?'-left'))(?(left)|(?'sum')(?>(0(?'sum')(,|$))*))(?'end')|(?'_right'))
    )|(?'_right'))
    (?((?'-_right'))(?(right)
        (?(?!(?!(?'-right')(?!(?'-right'))))(?'sum')(?>(0(?'sum')(,|$))*))
        |(?'sum'){2}(?'end')(?>(0(?'sum'){2}(,|$))*)
    ))
))*)", RegexOptions.Compiled);
    public int CountValidSelections(int[] nums) {
        return regex.Match(string.Join(",", nums)).Groups["sum"].Captures.Count;
    }
}

using System.Text.RegularExpressions;
public class Solution {
    static Regex regex = new Regex(@"(?X)
(?#此乃注释，下同。读取数字，存入组#n中)
(?>(?>(?=\d)
    (?(n)(?(n)(?>(?'-n')(?'m')|){10}){10}(?(m)(?>(?'-m')(?'n'){10}|){10}){10})
    (?=[1469](?'n')|)(?=[27](?'n'){2}|)(?=[3489](?'n'){3}|)([56789](?'n'){5}|\d)
)+)
(?>
    (?#用组#n和组#m交替存放n/2后的商。当n或m大于0时，令r = r x 2 + 1)
    (?((?!(?!(?'-n')|(?'-m'))))(?#双重否定表示肯定) #等价于 !(!(n>0||m>0))
        (?(r)(?>(?'-r')(?'rr')|){23}){23}
        (?(rr)(?>(?'-rr')(?'r'){2}|){23}){23}(?'r')
    )
    (?#当n > 0时，令m = n / 2; 当m > 0时，令n = m / 2)
    (?(n)    (?#当组#n有捕获，则执行下一行表达式)
        (?(n)(?(n)(?(nn)(?'-nn')(?'-n')(?'m')|(?'nn')(?'-n')(?'n2'))){33}){31}(?'-nn')?
        |    (?#当组#n无捕获，则执行下一行表达式)
        (?(m)(?(m)(?(nn)(?'-nn')(?'-m')(?'n')|(?'nn')(?'-m')(?'n2'))){23}){23}(?'-nn')?
    )
|){10}", RegexOptions.Compiled);
    public int SmallestNumber(int n) {
        return regex.Match(n.ToString()).Groups["r"].Captures.Count;
    }
}

using System.Text.RegularExpressions;
public class Solution {
    static Regex regex = new Regex(@"^(?nx)(?=((?=\d{2})(?=[147](?'1')|)
(?=[258](?'1'){2}|)(?=[3459](?'1'){3}|)(?=[6789](?'1'){6}|)(?=\d(?=[147](?'1')|)
(?=[258](?'1'){2}|)(?=[3459](?'1'){3}|)(?=[6789](?'1'){6}|))
(?>((?<=\1(?>.*))(?'-1')){10}|)(?'1'\d))+)(?>(?>(?'-1')
(?>(?=(?>.*)\1)(?'-1')(?'2')|){9}(?=(?>(?'-1')(?>(?'-3')(?'2')|){9}
(?>(?<=\1(?>.*))(?'-1')(?'2')(?'3')|){9}(?>((?<=\2(?>.*))(?'-2')){10}|)
(?'2'\d)){2,})(?>(?'-3')|){9}\d|(?'-2')(?>(?=(?>.*)\2)(?'-2')(?'1')|){9}
(?=(?>(?'-2')(?>(?'-3')(?'1')|){9}(?>(?<=\2(?>.*))(?'-2')(?'1')(?'3')|){9}
(?>((?<=\1(?>.*))(?'-1')){10}|)(?'1'\d)){2,})(?>(?'-3')|){9}\d|)+)
(?>.+)(?>(?'-1')(?'2')(?>(?=\1)(?'-1')(?'2')|){9}|(?'-2')(?'1')(?>(?=\2)(?'-2')(?'1')|){9})
(?>(?'-1')(?'-2')|){10}(?!(?'-1'))(?!(?'-2'))", RegexOptions.Compiled);
    public bool HasSameDigits(string s) {
        return regex.IsMatch(s);
    }
}

using System.Text.RegularExpressions;
public class Solution {
    public int SumDivisibleByK(int[] nums, int k) {
        var pattern = @"(?x)(?'k'){"
        + k +
@"}(?>(?<!(?=(?>(?'-offset'.)*)(?=\2\b))(?'-2'.(?'offset'))*?)(?=(?'2'\d+))
(?>(?=\d)(?(1)(?>(?'-1')(?'3')|){10}(?>(?'-3')(?'1'){10}|){10})(?=[147](?'1')|)
(?=[258](?'1'){2}|)(?=[3459](?'1'){3}|)(?=[6789](?'1'){6}|)\d)+(?'c')(?(1)
(?>(?'-1')(?'11')(?'3')|){10}){10}(?>,|$)(?=(?>(?>\2\b(?'c')(?(1)(?(1)
(?>(?'-1')(?'11')(?'3')|){10}){10}|(?(11)(?>(?'-11')(?'1')(?'3')|){10}){10})|\d+)
(?>,|$))*)(?!(?(c)(?(c)(?(k)(?(k)(?>(?'-k')(?'-c')(?'k1')|){10}){10}|(?(k1)
(?>(?'-k1')(?'-c')(?'k')|){10}){10})){10}){10}(?'-k')(?'-k1'))(?(3)
(?>(?'-3')(?'sum')|){100}){100}(?(1)(?>(?'-1')|){100}|(?>(?'-11')|){100})
(?>(?'-c')|){100}|(?>(?<!(?=(?>(?'-offset'.)*)(?=\2\b))(?'-2'.(?'offset'))*?)(?'2'\d+)|\d+)(?>,|$))+";
        return Regex.Match(string.Join(",", nums), pattern).Groups["sum"].Captures.Count;
    }
}

using System.Text.RegularExpressions;
public class Solution {
    static Regex regex = new Regex(@"(?x)
    (?>\w(?'word')|\W)
    (?<=(?(word)(?>(\w)|\W)*|(?>(?'1'\W)|\w)*).)
    (?=(?(word).*(\w)(?>(?'-1'\w)|\W)*|.*(?'2'\W)(?>(?'-1'\W)|\w)*)(?!(?'-1'))$)
|
    (?>\w(?'word')|\W)
    (?=(?(word)(?>(\w)|\W)*|(?>(?'3'\W)|\w)*))
    (?<=^(?!(?'-3'))(?(word)(?>(?'-3'\w)|\W)*(?'2'\w).*|(?>(?'-3'\W)|\w)*(?'2'\W).*))"
, RegexOptions.Compiled);
    public string ReverseByType(string s) {
        return regex.Replace(s,"${2}");
    }
}

using System.Text.RegularExpressions;
public class Solution {
    public bool IsPalindrome(string s) {
        return Regex.IsMatch(s,@"^(?ni)((?'1'[a-z0-9])|[^a-z0-9])*((?'2'[a-z0-9])|[^a-z0-9])\2?((?'-1'\1)|[^a-z0-9])*(?!(?'-1'))$");
    }
}