Regex (sabor PCRE), 66 (65🐌) bytes
Inspirado al ver que tanto Martin Ender como Jaytea , dos genios de expresiones regulares, escribieron soluciones de expresiones regulares para este código de golf, escribí la mía desde cero. La famosa expresión regular de verificación principal no aparece en ninguna parte de mi solución.
No leas esto si no quieres que te estropeen un poco de magia regex unaria. Si desea intentar descubrir esta magia usted mismo, le recomiendo comenzar resolviendo algunos problemas en ECMAScript regex:
- Haga coincidir los números primos (si aún no está familiarizado con hacer esto en expresiones regulares)
- Combina poderes de 2 (si aún no lo has hecho). O simplemente trabaje en Regex Golf , que incluye Prime y Powers. Asegúrese de hacer los conjuntos de problemas Clásico y Teukon.
Encuentre la forma más corta de hacer coincidir las potencias de N donde N es algo constante (es decir, especificado en la expresión regular, no en la entrada) que puede ser compuesto (pero no es obligatorio que lo sea). Por ejemplo, empareja potencias de 6.
Encuentre una forma de hacer coincidir las enésimas potencias, donde N es una constante> = 2. Por ejemplo, combina cuadrados perfectos. (Para un calentamiento, combina poderes primarios ).
Une las declaraciones de multiplicación correctas. Empareja números triangulares.
Haga coincidir los números de Fibonacci (si está tan loco como yo), o si desea apegarse a algo más corto, haga coincidir las declaraciones correctas de exponenciación (para un calentamiento, regrese como un logaritmo en la base 2 de una potencia de 2) bono, haga lo mismo para cualquier número, redondeándolo como desee), o números factoriales (para un calentamiento, iguale los números primarios ).
Une números abundantes (si estás tan loco como yo)
Calcule un número irracional con la precisión solicitada (por ejemplo, divida la entrada por la raíz cuadrada de 2, devolviendo el resultado redondeado como una coincidencia)
(El motor de expresiones regulares que escribí puede ser de ayuda, ya que es muy rápido en expresiones regulares matemáticas simples e incluye un modo numérico unario que puede probar rangos de números naturales (pero también tiene un modo de cadenas que puede evaluar expresiones regulares no unitarias o unarias). con delimitadores). De manera predeterminada, es compatible con ECMAScript, pero tiene extensiones opcionales (que pueden agregar selectivamente subconjuntos de PCRE, o incluso anticipación molecular, algo que ningún otro motor de expresiones regulares tiene).
De lo contrario, siga leyendo y también lea este GitHub Gist (advertencia, muchos spoilers) que narra el viaje de empujar la expresión regular ECMAScript para abordar las funciones de números naturales de dificultad creciente (comenzando con el conjunto de acertijos de teukon, no todos matemáticos, lo que provocó esto viaje).
Al igual que con las otras soluciones de expresiones regulares para este problema, la entrada se da como dos números en bijetivo unario, separados por una coma, que representan un rango inclusivo. Solo se devuelve un número. La expresión regular podría modificarse para devolver todos los números que comparten el mismo factor primo más grande más pequeño, como coincidencias separadas, pero eso requeriría mirar hacia atrás de longitud variable y poner \Kuna anticipación o devolver el resultado como una captura en lugar de una coincidencia.
La técnica utilizada aquí de división implícita repetida por el factor primo más pequeño es idéntica a la utilizada en las cadenas Match cuya longitud es una cuarta respuesta de potencia que publiqué hace un tiempo.
Sin más preámbulos:
((.+).*),(?!.*(?=\1)(((?=(..+)(\5+$))\6)*)(?!\2)).*(?=\1)\K(?3)\2$
Puedes probarlo aquí.
Y la versión de espacio libre, con comentarios:
# No ^ anchor needed, because this algorithm always returns a
# match for valid input (in which the first number is less than
# or equal to the second number), and even in /g mode only one
# match can be returned. You can add an anchor to make it reject
# invalid ranges.
((.+).*), # \1 = low end of range; \2 = conjectured number that is the
# smallest number in the set of the largest prime factor of each
# number in the range; note, it is only in subsequent tests that
# this is implicitly confined to being prime.
# We shall do the rest of our work inside the "high end of range"
# number.
(?! # Assert that there is no number in the range whose largest prime
# factor is smaller than \2.
.*(?=\1) # Cycle tail through all numbers in the range, starting with \1.
( # Subroutine (?3):
# Find the largest prime factor of tail, and leave it in tail.
# It will both be evaluated here as-is, and later as an atomic
# subroutine call. As used here, it is not wrapped in an atomic
# group. Thus after the return from group 3, backtracking back
# into it can increase the value of tail – but this won't mess
# with the final result, because only making tail smaller could
# change a non-match into a match.
( # Repeatedly divide tail by its smallest prime factor, leaving
# only the largest prime factor at the end.
(?=(..+)(\5+$)) # \6 = tool to make tail = \5 = largest nontrivial factor of
# current tail, which is implicitly the result of dividing it
# by its smallest prime factor.
\6 # tail = \5
)*
)
(?!\2) # matches iff tail < \ 2
)
# now, pick a number in the range whose largest prime factor is \2
.*(?=\1) # Cycle tail through all numbers in the range, starting with \1.
\K # Set us up to return tail as the match.
(?3) # tail = largest prime factor of tail
\2$ # Match iff tail == \2, then return the number whose largest
# prime factor is \2 as the match.
El algoritmo se puede portar fácilmente a ECMAScript reemplazando la llamada de subrutina con una copia de la subrutina y devolviendo la coincidencia como un grupo de captura en lugar de usar \ K. El resultado es 80 bytes de longitud:
((x+)x*),(?!.*(?=\1)((?=(xx+)(\4+$))\5)*(?!\2)).*(?=\1)(((?=(xx+)(\8+$))\9)*\2$)
Pruébalo en línea!
Tenga en cuenta que ((.+).*)se puede cambiar a ((.+)+), bajando el tamaño en 1 byte (de 66 a 65 bytes ) sin pérdida de la funcionalidad correcta, pero la expresión regular explota exponencialmente en la lentitud.
Pruébalo en línea! (Versión de desaceleración exponencial ECMAScript de 79 bytes)