# No anchor needed, because \2 cannot be initially captured if # matching is started anywhere besides the beginning. # Sum as many divisors of N as we can (using the current position as the sum), # without skipping any of them: ( ( \2x+? # \2 = the smallest number larger than the previous value of \2 # for which the following is true; add \2 to the running total # sum of divisors. | ^x # This must always be the first step. Add 1 to the sum of # divisors, thus setting \2 = 1 so the next iteration can keep # going. \B # Exclude 1 as a divisor if N == 1. We don't have to do this for # N > 1, because this loop will never be able to add N to the # already summed divisors (as 1 will always be one of them). ) (?^=\2+$) # Assert that \2 is a divisor of N )++ # Iterate the above at least once, with a possessive quantifier # to lock in the match (i.e. prevent any iteration from being # backtracked into). $ # Require that the sum equal N exactly. If this fails, the loop # won't be able to find a match by backtracking, because # everything inside the loop is done atomically. # Assert that there are no more proper divisors of N that haven't already been summed: (?^! # Assert that the following, evaluated right-to-left, is not true: (\2x+) # \3 = any number greater than \2 \3+$ # Assert \3 is a proper divisor of N ) 

 # No anchor needed, because \1 cannot be initially captured if # matching is started anywhere besides the beginning. # Sum as many divisors of N as we can (using the current position as the sum), # without skipping any of them: ( (?= # Atomic lookahead: .*(\1x+$) # \2 = the smallest number larger than the previous value of \1 # (which is identical to the previous value of \2) for which the # following is true. We can avoid using "x+?" because the ".*" # before this implicitly forces values to be tested in increasing # order from the smallest. (?<=^\2+) # Assert that \2 is a divisor of N ) \2 # Add \2 to the running total sum of divisors | ^x # This must always be the first step. Add 1 to the sum of divisors, # thus setting \1 = 1 so the next iteration can keep going \B # Exclude 1 as a divisor if N == 1. We don't have to do this for # N > 1, because this loop will never be able to add N to the # already summed divisors (as 1 will always be one of them). )+$ # Require that the sum equal N exactly. If this fails, the loop # won't be able to find a match by backtracking, because everything # inside the loop is done atomically. # Assert that there are no more proper divisors of N that haven't already been summed: (?<! # Assert that the following, evaluated right-to-left, is not true: ^\3+ # [Step 2] is a proper divisor of N (x+\2) # [Step 1] Any value of \3 > \2 ) 

 # No anchor needed, because \2 cannot be initially captured if # matching is started anywhere besides the beginning. # Sum as many divisors of N as we can (using the current position as the sum), # without skipping any of them: ( ( \2x+? # \2 = the smallest number larger than the previous value of \2 # for which the following is true; add \2 to the running total # sum of divisors. | ^x # This must always be the first step. Add 1 to the sum of # divisors, thus setting \2 = 1 so the next iteration can keep # going. \B # Exclude 1 as a divisor if N == 1. We don't have to do this for # N > 1, because this loop will never be able to add N to the # already summed divisors (as 1 will always be one of them). ) (?^=\2+$) # Assert that \2 is a divisor of N )++ # Iterate the above at least once, with a possessive quantifier # to lock in the match (i.e. prevent any iteration from being # backtracked into). $ # Require that the sum equal N exactly. If this fails, the loop # won't be able to find a match by backtracking, because # everything inside the loop is done atomically. # Assert that there are no more proper divisors of N that haven't already been summed: (?^! # Lookinto – Assert that the following cannot match: (\2x+) # \3 = any number greater than \2 \3+$ # Assert \3 is a proper divisor of N ) 

 # No anchor needed, because \1 cannot be initially captured if # matching is started anywhere besides the beginning. # Sum as many divisors of N as we can (using the current position as the sum), # without skipping any of them: ( (?= # Atomic lookahead: .*(\1x+$) # \2 = the smallest number larger than the previous value of \1 # (which is identical to the previous value of \2) for which the # following is true. We can avoid using "x+?" because the ".*" # before this implicitly forces values to be tested in increasing # order from the smallest. (?<=^\2+) # Assert that \2 is a divisor of N ) \2 # Add \2 to the running total sum of divisors | ^x # This must always be the first step. Add 1 to the sum of divisors, # thus setting \1 = 1 so the next iteration can keep going \B # Exclude 1 as a divisor if N == 1. We don't have to do this for # N > 1, because this loop will never be able to add N to the # already summed divisors (as 1 will always be one of them). )+$ # Require that the sum equal N exactly. If this fails, the loop # won't be able to find a match by backtracking, because everything # inside the loop is done atomically. # Assert that there are no more proper divisors of N that haven't already been summed: (?<! # Assert that the following, evaluated right-to-left, cannot match: ^\3+ # [Step 2] is a proper divisor of N (x+\2) # [Step 1] Any value of \3 > \2 ) 

Regex (Perl/PCRE+(?^=)^RME), 44 bytes

((?>(\1x+?)(?^=\2+$))|^x\B)+$(?^!(\2x+)\3+$) 

This is a port of my 48 byte .NET regex below, using lookinto instead of variable-length lookbehind. This makes it far faster, and able to scan all numbers from 0 to 9000 in about 7 seconds on my PC.

 # No anchor needed, because \1 cannot be initially captured if # matching is started anywhere besides the beginning. # Sum as many divisors of N as we can (using the current position as the sum), # without skipping any of them: ( (?> # Atomic group – once this finishes matching, lock in the match   # and prevent it from being backtracked into.  (\1x+?) # \2 = the smallest number larger than the previous value of \1 # (which is identical to the previous value of \2) for which the  # following is true; add \2 to the running total sum of divisors.  (?^=\2+$) # Assert that \2 is a divisor of N ) | ^x # This must always be the first step. Add 1 to the sum of divisors, # thus setting \1 = 1 so the next iteration can keep going \B # Exclude 1 as a divisor if N == 1. We don't have to do this for # N > 1, because this loop will never be able to add N to the # already summed divisors (as 1 will always be one of them). )+$ # Require that the sum equal N exactly. If this fails, the loop # won't be able to find a match by backtracking, because everything # inside the loop is done atomically. # Assert that there are no more proper divisors of N that haven't already been summed: (?^! # Assert that the following, evaluated right-to-left, is not true: (\2x+) # \3 = any number greater than \2 \3+$ # Assert \3 is a proper divisor of N ) 

Regex (PCRE2 _^v10.35+), 64 60 bytes

This is a port of the 48 byte .NET regex, emulating variable-length lookbehind using a recursive subroutine call.

(?=((?>(\1x+?)((?<=(?=^\2+$|(?3)).)))|^x\B)+$)(?!(\1x+)\4+$) 

Attempt This Online!

(?= ( (?> # Atomic group (\1x+?) ((?<= # (?3) calls this   (?= # Circumvent the constant-width limitation of lookbehinds   # in PCRE by using a lookahead inside the lookbehind   ^\2+$ # This is the payload of the emulated variable-length   # lookbehind, same as the one in the .NET regex   |   (?3) # Recursive call - this is the only alternative that can   # match until we reach the beginning of the string   )   . # Go back one character at a time, trying the above   # lookahead for a match each time )) ) | ^x \B )+$ ) (?! (\1x+) \4+$ ) 

Regex (Perl/PCRE+(?^=)^RME), _⁴⁴ 41 bytes

((\2x+?|^x\B)(?^=\2+$))++$(?^!(\2x+)\3+$) 

This was a port of my 48 byte .NET regex below, using lookinto instead of variable-length lookbehind. This makes it far faster, and able to scan all numbers from 0 to 9000 in about 7 seconds on my PC. It also enables somes golfs that aren't possible in the .NET version.

 # No anchor needed, because \2 cannot be initially captured if # matching is started anywhere besides the beginning. # Sum as many divisors of N as we can (using the current position as the sum), # without skipping any of them: ( ( \2x+? # \2 = the smallest number larger than the previous value of \2 # for which the following is true; add \2 to the running total   # sum of divisors. | ^x # This must always be the first step. Add 1 to the sum of # divisors, thus setting \2 = 1 so the next iteration can keep  # going. \B # Exclude 1 as a divisor if N == 1. We don't have to do this for # N > 1, because this loop will never be able to add N to the # already summed divisors (as 1 will always be one of them).  ) (?^=\2+$) # Assert that \2 is a divisor of N )++  # Iterate the above at least once, with a possessive quantifier  # to lock in the match (i.e. prevent any iteration from being # backtracked into). $ # Require that the sum equal N exactly. If this fails, the loop # won't be able to find a match by backtracking, because # everything inside the loop is done atomically. # Assert that there are no more proper divisors of N that haven't already been summed: (?^! # Assert that the following, evaluated right-to-left, is not true: (\2x+) # \3 = any number greater than \2 \3+$ # Assert \3 is a proper divisor of N ) 

Regex (Perl / PCRE2 _^v10.35+), _{^{64 60}} 57 bytes

This is a port of the 41 byte regex, emulating variable-length lookbehind using a recursive subroutine call.

(?=((\2x+?|^x\B)((?<=(?=^\2+$|(?3)).)))++$)(?!(\2x+)\4+$) 

Try it online! - Perl
Attempt This Online! - PCRE2 v10.40+

 # No anchor needed, because \2 cannot be initially captured if # matching is started anywhere besides the beginning. (?=  # Sum as many divisors of N as we can (using the current position as the sum), # without skipping any of them: ( ( \2x+? # \2 = the smallest number larger than the previous value of \2  # for which the following is true; add \2 to the running total   # sum of divisors.  | ^x # This must always be the first step. Add 1 to the sum of # divisors, thus setting \2 = 1 so the next iteration can keep # going. \B # Exclude 1 as a divisor if N == 1. We don't have to do this for # N > 1, because this loop will never be able to add N to the # already summed divisors (as 1 will always be one of them).   )  ((?<= # Define subroutine (?3); lookbehind (?= # Circumvent the constant-width limitation of lookbehinds # in PCRE by using a lookahead inside the lookbehind ^\2+$ # This is the payload of the emulated variable-length # lookbehind: Assert that \2 is a divisor of N | (?3) # Recursive call - this is the only alternative that can # match until we reach the beginning of the string ) . # Go back one character at a time, trying the above # lookahead for a match each time ))  )++ # Iterate the above at least once, with a possessive quantifier  # to lock in the match (i.e. prevent any iteration from being  # backtracked into).   $  # Require that the sum equal N exactly. If this fails, the loop  # won't be able to find a match by backtracking, because  # everything inside the loop is done atomically. ) # Assert that there are no more proper divisors of N that haven't already been summed: (?! # Assert that the following cannot match: (\2x+) # \4 = any number greater than \2 \4+$ # Assert \4 is a proper divisor of N ) 

Regex (PCRE2), 64 bytes

This is a direct port of the 48 byte .NET regex, emulating variable-length lookbehind using a recursive subroutine call.

(?=((?=.*(\1x+$)((?<=(?=^\2+$|(?3)).)))\2|^x\B)+$)(?!(\1x+)\4+$) 

Try it on regex101

(?= ( (?= .*(\1x+$) ((?<= # (?3) calls this (?= # Circumvent the constant-width limitation of lookbehinds # in PCRE by using a lookahead inside the lookbehind ^\2+$ # This is the payload of the emulated variable-length # lookbehind, same as the one in the .NET regex | (?3) # Recursive call - this is the only alternative that can # match until we reach the beginning of the string ) . # Go back one character at a time, trying the above # lookahead for a match each time )) ) \2 | ^x \B )+$ ) (?! (\1x+) \4+$ ) 

It isn't possible to directly port the 47 byte regex to PCRE, because it changes the value of a capture group inside the lookbehind, and upon the return of any subroutine in PCRE, all capture groups are reset to the values they had upon entering the subroutine.

Regex (PCRE2 _^v10.35+), 64 60 bytes

This is a port of the 48 byte .NET regex, emulating variable-length lookbehind using a recursive subroutine call.

(?=((?>(\1x+?)((?<=(?=^\2+$|(?3)).)))|^x\B)+$)(?!(\1x+)\4+$) 

Attempt This Online!

(?= ( (?> # Atomic group (\1x+?) ((?<= # (?3) calls this (?= # Circumvent the constant-width limitation of lookbehinds # in PCRE by using a lookahead inside the lookbehind ^\2+$ # This is the payload of the emulated variable-length # lookbehind, same as the one in the .NET regex | (?3) # Recursive call - this is the only alternative that can # match until we reach the beginning of the string ) . # Go back one character at a time, trying the above # lookahead for a match each time )) ) | ^x \B )+$ ) (?! (\1x+) \4+$ ) 

It isn't practical to directly port the 47 byte regex to PCRE, because it changes the value of a capture group inside the lookbehind, and upon the return of any subroutine in PCRE, all capture groups are reset to the values they had upon entering the subroutine. It is possible, however, and I did this for the corresponding Abundant numbers regex by changing the main loop from iteration into recursion.