El fondo

La gente hablaba de factorización principal en el chat y nos encontramos hablando de repunidades. Las repunidades son un subconjunto de los números conocidos como repdigits, que son números que consisten solo en dígitos repetidos, como 222o 4444444444444444, pero que consisten solo en repunits 1.

El primer par de repunits son, por tanto 1, 11, 111, etc. Estos se conocen por R _n , por lo que R ₁ = 1, R ₂ = 11, etc., y son generados por la fórmula R(n) = (10^n - 1)/9, con n > 0.

La factorización prima de estos números de repunidad sigue la secuencia A102380 en el OEIS. Por ejemplo:

R ₁ = 1
R ₂ = 11
R ₃ = 111 = 3 * 37
R ₄ = 1111 = 11 * 101
R ₅ = 11111 = 41 * 271
R ₆ = 111111 = 3 * 7 * 11 * 13 * 37
R ₇ = 1111111 = 239 * 4649
...

El reto

Escriba un programa o función que, cuando se le da un número entero de entrada n a n >= 2través de STDIN o equivalente , genera o devuelve los factores primos novedosos para R _n , en cualquier formato conveniente. "Novel factores primos" aquí se refiere a todos x, donde xes un factor primordial de R _n , pero xno es un factor primordial para cualquier anterior R _k , con 1 <= k < n(es decir, si escribimos los factores primos para todos R en la secuencia, hemos visto que no xantes de).

Los ejemplos

Input: 6
Output: 7, 13
(because 3, 11, and 37 are factors of a smaller R_k)

Input: 19
Output: 1111111111111111111
(because R_19 is prime, so no other factors)

Input: 24
Output: 99990001
(because 3, 7, 11, 13, 37, 73, 101, 137, 9901 are factors of a smaller R_k)

Input: 29
Output: 3191, 16763, 43037, 62003, 77843839397
(because no factors of R_29 are also factors of a smaller R_k)

Los extras:

• Su código puede hacer cualquier cosa o nada si n < 2.
• Puede suponer un límite superior "razonable" para nfines de prueba y ejecución: no se esperará que su código salga n = 10000000, por ejemplo, pero su algoritmo debería funcionar para tal caso si se le da una potencia y tiempo de cómputo ilimitados.
• Aquí hay un sitio dedicado a las factorizaciones de repunidades como referencia.
• No he pasado por las matemáticas, pero propongo una hipótesis de que cada n tiene un resultado distinto para este algoritmo, es decir, no existe n tal que R _n no tenga factores novedosos. Ofreceré una recompensa de 250 puntos si alguien prueba o refuta eso en su respuesta. Thomas Kwa propuso una prueba elegante , y le otorgué la recompensa.

Pyth, 16 14 13 bytes

-F_m{P/^Td9SQ

Lo mejor que puedo decir, 19 lleva una eternidad.

-F_m{P/^Td9SQ      Implicit: Q = input
           SQ      Inclusive range 1 to Q
                        Implicit lambda d:
    {P                  unique primes dividing
       ^Td              10**d
      /   9                  //9
   m               map lambda over the range
   m{P/^Td9SQ      Unique prime factors of all repunits up to the Qth
  _                Reverse the list
-F                 Reduce by set difference

Pruébalo aquí .

Prueba de que cada repunidad tiene un factor primo novedoso

Usando el Teorema de Zsigmondy , la prueba es simple. De Wikipedia:

En teoría de números, el teorema de Zsigmondy, llamado así por Karl Zsigmondy, establece que si a> b> 0 son enteros coprimos, entonces para cualquier número entero n ≥ 1 , hay un número primo p (llamado divisor primitivo primitivo) que divide un ⁿ - b ⁿ y no divide a ^k - b ^k para cualquier entero positivo k <n , con las siguientes excepciones: [cosas que no se aplican aquí].

Considere las repeticiones multiplicadas por 9: es decir, 10 ⁿ -1 . Según el teorema de Zsigmondy con a = 10 , b = 1 , hay algunos p principales | 10 ⁿ -1 que no divide 10 ^k -1 , k <n .

• Como p es primo y 10 ⁿ -1 = 9 · R _n , debe dividir 9 o R _n .

• p no puede dividir 9 , ya que 9 = 10 ¹ -1 .

• Por lo tanto, p divide a R _n .

• p no puede dividir ningún R _k , ya que no divide 10 ^k -1 = 9 · R _k .

Por lo tanto, la p del Teorema de Zsigmondy es un factor primo novedoso de cualquier R _n , n ≥ 2 . ∎

Un ejemplo de un factor primo novedoso repetido

El primo 487 es un factor primo repetido de R ₄₈₆ :

Según el teorema de Fermat-Euler, 10 ^487-1 ≡ 1 (mod 487) . El orden de 10 mod 487, es decir, la potencia más pequeña de 10 que es 1 mod 487, por lo tanto, debe ser un divisor de 486. De hecho, el orden es igual a 486. También sucede que no solo es 10 ⁴⁸⁶ ≡ 1 (mod 487) , también es 1 (mod 487 ² ) .

Vea aquí que el orden de 10 mod 487 es 486; es decir, que no menos de 10 ^k -1 es divisible por 487. Obviamente, 487 no divide 9, por lo que debe dividir R ₄₈₆ .

CJam, 18 bytes

{{)'1*imf}%W%:-_&}

Pruébalo aquí.

Comenzando en 19 (el primer repunit prime después de 2) tomará bastante tiempo.

Explicación

Este es un bloque sin nombre (el equivalente de CJam de una función), que espera el número de entrada nen la pila y deja una lista de factores primos en su lugar:

{      e# Map this block over [0 1 ... n-1]...
  )'1* e#   Increment and create a string of that many 1s.
  i    e#   Convert to integer.
  mf   e#   Get its prime factors.
}%
W%     e# Reverse the list.
:-     e# Fold set difference onto the list, removing from the first list the elements of
       e# all other lists.
_&     e# Remove duplicates. Unfortunately, this necessary. Thomas Kwa found that the 486th
       e# repunit contains 487^2 (where 487 is a novel prime factor).

Haskell 86 bytes

import Data.Numbers.Primes
f n=[x|x<-primeFactors$div(10^n-1)9,notElem x$f=<<[1..n-1]]

Ejemplo de uso: f 8-> [73,137].

Toma mucho tiempo y memoria para lo grande n.

Implementación directa de la definición: tome todos los factores primos xde los Rncuales no aparecen antes ( f=<<[1..n-1]son todos factores primos de R1 ... R(n-1)).

Mathematica 82 74 63 bytes

Con 11 bytes guardados gracias a alephalpha.

Complement@@Reverse@FactorInteger[(10^Range@#-1)/9][[;;,;;,1]]&

Factores primos de R70

(10 ^ 70 - 1) / 9 = 1111111111111111111111111111111111111111111111111111111111111111111111

FactorInteger[(10^70 - 1)/9]

{{11, 1}, {41, 1}, {71, 1}, {239, 1}, {271, 1}, {4649, 1}, {9091, 1}, {123551, 1}, { 909091, 1}, {4147571, 1}, {102598800232111471, 1}, {265212793249617641, 1}}

Factores primos novedosos de R70

Complement@@Reverse@FactorInteger[(10^Range@#-1)/9][[;;,;;,1]]&[70]

{4147571, 265212793249617641}

MATL , 25 bytes

Esto funciona para entradas de hasta 16:

10,i:^9/Y[t0)Yftb!w\~s1=)

La siguiente versión usa 31 bytes y funciona hasta 18. Para 19ello requiere aproximadamente 4 GB de memoria (no he podido ejecutarlo).

10,i:^9/Y[t0)5X2Y%Yfotb!w\~s1=)

Ejemplo

>> matl
 > 10,i:^1-,9/t0)5X2Y%Yfotb!w\~s1=)
 > 
> 6
7 13

Explicación

Considere la entrada de concreción 6. Primero 111111se calculan los divisores primos de ; en este caso los resultados son 3, 7, 11, 13, 37. A continuación, se calcula la operación de módulo (división con resto) para todas las combinaciones de números 1, 11, ... 111111y los divisores computados. Esto explota la expansión singleton implícita de MATL. El resultado es en este caso una matriz 6x 5, con cada columna correspondiente a uno de los divisores. Los divisores (columnas) aceptados son aquellos para los que solo el 1valor (es decir, el último) da cero resto.

10,i:^9/Y[   % generate vector with `1`, `11`, ... depending on input number, say "n"
t0)          % pick the last element: `111...1` (n ones)
5X2Y%        % * convert to uint64, so that larger numbers can be handled
Yf           % prime factors                                             
o            % * convert to double precision, so that modulus can be done
t            % duplicate                                                 
b            % bubble up element in stack                                
!            % transpose                                                 
w            % swap elements in stack                                    
\            % modulus after division (element-wise, singleton expansion)
~s           % number of zero values in each column
1=           % is equal to 1? (element-wise, singleton expansion)
)            % index divisors with that logical index

(*) Eliminado en versión corta

Julia, 103 bytes

R(n)=[keys(factor((10^n-1)÷9))...]
n->(r=R(n);isprime(r)?r:setdiff(r,reduce(vcat,[R(i)for i=1:n-1])))

Esta es una función sin nombre que llama a una función auxiliar R. Para llamarlo, asigne un nombre a la función principal, p f=n->.... Ej .

Sin golf:

function R(n::Integer)
    collect(keys(factor((10^n - 1) ÷ 9)))
end

function f(n::Integer)
    r = R(n)
    if isprime(r)
        r
    else
        setdiff(r, reduce(vcat, [R(i) for i = 1:n-1]))
    end
end

LabVIEW, 33 primitivas de LabVIEW

19 toma para siempre ...

Trabaje guardando todos los Primes y eliminando elementos del último conjunto cuando se encuentren en la otra matriz.

J, 24 bytes

[:({:-.}:)@:q:[:+/\10^i.

Espera números de precisión extendida después de 6 (por ejemplo, en 19xlugar de 19).

Pruébalo en línea!

Probablemente haya una forma más corta de generar las repunidades que también evite las mayúsculas.

Explicación

[: ({: -. }:) @: q: [: +/\ 10 ^ i.
                                i. Range [0, input)
                           10 ^    10 raised to the power of the range
                       +/\         Running sum of this list (list of repunits)
                 q:                Prime factors of the repunits
              @:                   Composed with
   ({: -. }:)                      Unique prime factors of last repunit
    {:                              Factors of last repunit (tail of matrix)
       -.                           Set subtraction with
          }:                        Rest of the matrix (curtail)

Cómo funciona visualmente

Creo que este tipo de explicaciones visuales son más fáciles de soportar para aquellos que no conocen J. Estos son resultados del REPL.

   10 ^ i.6
1 10 100 1000 10000 100000

   +/\ 10 ^ i. 6
1 11 111 1111 11111 111111

   q: +/\ 10 ^ i. 6
 0   0  0  0  0
11   0  0  0  0
 3  37  0  0  0
11 101  0  0  0
41 271  0  0  0
 3   7 11 13 37

   ({: -. }:) q: +/\ 10 ^ i. 6
7 13