Mrrl

Я использую лямбда-выражения в двух случаях:
- когда это действительно "выражение", т.е. всё вычисление укладывается в одну формулу;
- когда для вычислений нужно использовать значения переменных текущего метода.
При этом я помню, что "под ковром" компилятор создаст для каждого контекста с лямбда-выражением отдельный класс, и захваченные переменные будут полями этого класса (а само лямбда-выражение - его методом). Причём они будут использоваться, как поля, не только для кода, вычисляющего это выражение, но и для всей работы с этими переменными. Так что, если в конкретном месте приходится думать об эффективности, то надо всё взвесить.

Как-нибудь так. Не очень эффективно, правда. И без скобок.

static string FindReg(string src,string ptrn) {
            int LP=ptrn.Length,LS=src.Length;
            for(int i=0;i<LS;i++) {
                int k=i;
                bool ok=true;
                for(int j=0;ok && j<LP;) {
                    int m=1;
                    bool plus=false;
                    char cur=ptrn[j++];
                    for(;j<LP;j++) {
                        if(ptrn[j]=='+') plus=true;
                        else if(ptrn[j]==cur) m++;
                        else break;
                    }
                    int s=0;
                    while(k+s<LS && src[k+s]==cur) s++;
                    if(s<m) {
                        ok=false; break;
                    } else if(plus) k+=s;
                    else k+=m;
                }
                if(ok) return src.Substring(i,k-i);
            }
            return null;
        }

Но вообще, конечный автомат понадобится очень быстро. Уже для какого-нибудь a*b*ac без него трудно будет обойтись (если не писать страшную рекурсию).

static int sstep;
       static void FindAll(int N,int sum,int step,bool ord){
            sstep=step;
            sum/=step;
            fill(new int[N],N,sum,sum-N+1,ord);
        }
        static void output(int[] A){
              Console.Write("{0}",A[0]*sstep);
              for(int i=1;i<A.Length;i++) Console.Write("/{0}",A[i]*sstep);
              Console.WriteLine();
        }

        static void fill(int[] A,int N,int sum,int smax,bool ord) {
            if(N==0 && sum==0) {
                output(A);
                return;
            }
            if(N==0 || sum<N) return;
            int smin=ord ? 1 : (sum-1)/N+1;
            N--;
            for(A[N]=smin;A[N]<=smax;A[N]++) {
                fill(A,N,sum-A[N],ord ? sum-N+1 : A[N],ord);
            }
        }

Задаётся A=new int[N], и вызывается fill(A,N,sum,sum-N+1,ord), где N=6, sum=300, ord - true, если с учётом порядка и false, если без учёта. Я проверял для N=5, sum=10 - там число вариантов приемлемо. Насколько я понимаю, для (6,300,true) будет примерно 21 миллиард комбинаций (Comb(299,5)), а для (6,300,false) - не меньше 30 миллионов.