Adding Numbers with Regex
.NET flavor, score:2
Regex        Modifiers  Replacement  Repeat?
&lt;empty&gt;      &lt;none&gt;     9876543210   No
&lt;see below&gt;  x          &lt;empty&gt;      No

I'm not bothered to golf it yet, and x is just for ignoring whitespaces.
It firstly insert 9876543210 at each position, then delete the original characters and the characters those are not the current digit of the sum.
The big regex (1346 bytes without whitespaces and comments):
# If the length of the left number &lt;= right number, delete every digit on the left.
.(?=.*,(?&lt;=^(?&lt;len&gt;.)*,)(?&lt;-len&gt;.)*(?(len)(?!)))|

# Do the opposite if it is not the case.
.(?&lt;=(?(len)(?!))(?&lt;-len&gt;.)*(?=(?&lt;len&gt;.)*$),.*)|

# Remove leading zeros.
(?&lt;=(^|,).{9})0|

# Delete everything that is not the current digit of the sum.
.(?!
    # For digits in the left part:
    (?&lt;cur&gt;.){0,9}               # cur = the matched digit
    (?=(.{11})*,)                # and find the position before the next digit.
    (?&lt;first&gt;)                   # first = true
    (                            # Loop on the less significant digits:
        (?&lt;cur&gt;){10}             # cur += 10
        (?&lt;=                     # cur -= the current digit in this number.
            (
                0|^|
                1(?&lt;-cur&gt;)|
                2(?&lt;-cur&gt;){2}|
                3(?&lt;-cur&gt;){3}|
                4(?&lt;-cur&gt;){4}|
                5(?&lt;-cur&gt;){5}|
                6(?&lt;-cur&gt;){6}|
                7(?&lt;-cur&gt;){7}|
                8(?&lt;-cur&gt;){8}|
                9(?&lt;-cur&gt;){9}
            )
            .{10}
        )
        (?=
            (?&lt;pos&gt;.{11})*,      # pos = which digit it is.
            .*$(?&lt;=              # cur -= the current digit in the other number.
                (
                    0|,|
                    1(?&lt;-cur&gt;)|
                    2(?&lt;-cur&gt;){2}|
                    3(?&lt;-cur&gt;){3}|
                    4(?&lt;-cur&gt;){4}|
                    5(?&lt;-cur&gt;){5}|
                    6(?&lt;-cur&gt;){6}|
                    7(?&lt;-cur&gt;){7}|
                    8(?&lt;-cur&gt;){8}|
                    9(?&lt;-cur&gt;){9}
                )
                .{10}
                (?(pos)(?!))     # Assert pos = 0.
                                 # Skip pos input digits from the end.
                                 # But stop and set pos = 0 if the comma is encountered.
                ((?&lt;-pos&gt;\d{11})|(?&lt;=(?&gt;(?&lt;-pos&gt;.)*),.{10}))*
            )
        )
        (?(first)                # If first:
            (?&gt;((?&lt;-cur&gt;){10})?) #  cur -= 10 in case there is no carry.
                                 #  Assert cur = 0 or 1, and if cur = 1, set cur = 10 as carry.
            (?(cur)(?&lt;-cur&gt;)(?(cur)(?!))(?&lt;cur&gt;){10})
            (?&lt;-first&gt;)          #  first = false
        |                        # Else:
                                 #  cur is 10 or 20 at the beginning of an iteration.
                                 #  It must be 1 to 11 to make the equation satisfiable.
            (?&lt;-cur&gt;)            #  cur -= 1
            (?(cur)              #  If cur &gt; 0:
                                 #   cur -= max(cur, 9)
                (?(cur)(?&lt;-cur&gt;)){9}
                (?(cur)          #   If cur &gt; 0:
                                 #    Assert cur = 1 (was 11) and set cur = 10.
                    (?&lt;-cur&gt;)(?(cur)(?!))(?&lt;cur&gt;){10}
                |                #   Else:
                    .*(?=,)      #    cur was 2 to 10, break from the loop.
                )
            )                    #  Else cur is 0 (was 1) and do nothing.
        )
        (.{11}|,)                # Jump to the next digit.
    )*(?&lt;=,)(?(cur)(?!))         # End the loop if it is the last digit, and assert cur = 0.
|
    # Do the same to the right part. So the sum will be calculated two times.
    # Both are truncated to the original length of the number on that side + 1.
    # Only the sum on the longer side will be preserved in the result.
    (?&lt;cur&gt;\d){0,9}
    (?=(\d{11})*$)
    (?&lt;first&gt;)
    (
        (?&lt;cur&gt;){10}
        (?&lt;=
            (
                0|,|
                1(?&lt;-cur&gt;)|
                2(?&lt;-cur&gt;){2}|
                3(?&lt;-cur&gt;){3}|
                4(?&lt;-cur&gt;){4}|
                5(?&lt;-cur&gt;){5}|
                6(?&lt;-cur&gt;){6}|
                7(?&lt;-cur&gt;){7}|
                8(?&lt;-cur&gt;){8}|
                9(?&lt;-cur&gt;){9}
            )
            .{10}
        )
        (?=
            (?&lt;pos&gt;.{11})*$
            (?&lt;=
                (
                    0|^|
                    1(?&lt;-cur&gt;)|
                    2(?&lt;-cur&gt;){2}|
                    3(?&lt;-cur&gt;){3}|
                    4(?&lt;-cur&gt;){4}|
                    5(?&lt;-cur&gt;){5}|
                    6(?&lt;-cur&gt;){6}|
                    7(?&lt;-cur&gt;){7}|
                    8(?&lt;-cur&gt;){8}|
                    9(?&lt;-cur&gt;){9}
                )
                .{10}
                (?(pos)(?!))
                ((?&lt;-pos&gt;\d{11})|(?&lt;=^.{10})(?=(?&gt;(?&lt;-pos&gt;.)*)))*
                ,.*
            )
        )
        (?(first)
            (?&gt;((?&lt;-cur&gt;){10})?)
            (?(cur)(?&lt;-cur&gt;)(?(cur)(?!))(?&lt;cur&gt;){10})
            (?&lt;-first&gt;)
        |
            (?&lt;-cur&gt;)
            (?(cur)
                (?(cur)(?&lt;-cur&gt;)){9}
                (?(cur)
                    (?&lt;-cur&gt;)(?(cur)(?!))(?&lt;cur&gt;){10}
                |
                    .*$(?&lt;end&gt;)
                )
            )
        )
        (.{11}|$(?&lt;end&gt;))
    )*(?&lt;-end&gt;)(?(cur)(?!))
)

This made me think of the final level of Manufactoria... But I think .NET regex, which is obviously no longer &quot;regular&quot;, can solve any problems in PH. And this is just an algorithm in L.