O fundo

O pessoal estava falando sobre fatoração privilegiada no bate - papo e nos encontramos falando sobre repunits. Repunits são um subconjunto dos números conhecidos como repdigits, que são números que consistem apenas em dígitos repetidos, como 222ou 4444444444444444, mas as repunits consistem apenas em 1.

Os primeiros repunits par são, portanto 1, 11, 111, etc. Estes são referidos por R _n , então R ₁ = 1, R ₂ = 11, etc, e são geradas pela fórmula R(n) = (10^n - 1)/9, com n > 0.

A fatoração primária desses números de repunit segue a sequência A102380 no OEIS. Por exemplo:

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
...

O desafio

Escreva um programa ou função que, quando recebe um número inteiro de entrada n com n >= 2via STDIN ou equivalente , gera ou retorna os novos fatores primos para R _n , em qualquer formato conveniente. "Novos fatores primos" aqui significa tudo xonde xé um fator primo de R _n , mas xnão é um fator primo para qualquer R _k anterior , com 1 <= k < n(ou seja, se escrevermos os fatores primos para todo R em sequência, não vimos xantes).

Os exemplos

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)

Os extras:

• Seu código pode fazer qualquer coisa ou nada se n < 2.
• Você pode assumir um limite superior "razoável" para nfins de teste e execução - não se espera que seu código seja gerado n = 10000000, por exemplo, mas seu algoritmo deve funcionar nesse caso se houver tempo e capacidade computacionais ilimitados.
• Aqui está um site dedicado às fatorações de repunits para referência.
• Eu não tenho ido através da matemática, mas eu propor uma hipótese que cada n tem um resultado distinto para este algoritmo - isto é, sem n existe tal que R _n não tem fatores novos. Oferecerei uma recompensa de 250 pontos se alguém provar ou refutar isso em sua resposta. Thomas Kwa propôs uma prova elegante e eu concedi a recompensa.

Pitão, 16 14 13 bytes

-F_m{P/^Td9SQ

Pelo melhor que posso dizer, 19 leva uma eternidade.

-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

Experimente aqui .

Prova de que toda repunit possui um novo fator primo

Usando o Teorema de Zsigmondy , a prova é simples. Da Wikipedia:

Em teoria dos números, o teorema de Zsigmondy, em homenagem a Karl Zsigmondy, estados que, se a> b> 0 são coprimos inteiros, em seguida, para qualquer inteiro n ≥ 1 , existe um número primo p (chamado de divisor primo primitiva) que divide um ⁿ - b ⁿ e não divide a ^k - b ^k para qualquer número inteiro positivo k <n , com as seguintes exceções: [coisas que não se aplicam aqui].

Considere os repunits vezes 9: ou seja, 10 ⁿ -1 . Pelo teorema de Zsigmondy com a = 10 , b = 1 , há alguns p primos | 10 ⁿ -1 que não divide 10 ^k -1 , k <n .

• Como p é primo e 10 ⁿ -1 = 9 · R _n , ele deve dividir 9 ou R _n .

• p não pode dividir 9 , pois 9 = 10 ¹ -1 .

• Portanto, p divide R _n .

• p não pode dividir nenhum R _k , pois não divide 10 ^k -1 = 9 · R _k .

Portanto, p do teorema de Zsigmondy é um novo fator primo de qualquer R _n , n ≥ 2 . ∎

Um exemplo de um novo fator primo repetido

O número primo 487 é um fator primo repetido de R ₄₈₆ :

Pelo teorema de Fermat-Euler, 10 ^487-1 ≡ 1 (mod 487) . A ordem de 10 mod 487, ou seja, a menor potência de 10 que é 1 mod 487, deve, portanto, ser um divisor de 486. De fato, a ordem é igual a 486. Também acontece que não só é 10 ⁴⁸⁶ ≡ 1 (mod 487) , também é 1 (mod 487 ² ) .

Veja aqui que a ordem de 10 mod 487 é 486; ou seja, 10 ^k -1 menores não são divisíveis por 487. Obviamente, 487 não divide 9, portanto deve dividir R ₄₈₆ .

CJam, 18 bytes

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

Teste aqui.

A partir dos 19 (o primeiro repunit prime após 2), levará um tempo bastante longo.

Explicação

Este é um bloco sem nome (o equivalente a uma função do CJam), que espera o número de entrada nna pilha e deixa uma lista de fatores primos:

{      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]]

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

Leva muito tempo e memória para grande n.

Implementação direta da definição: pegue todos os fatores primários xdos Rnquais não aparecem antes ( f=<<[1..n-1]todos são fatores primários de R1 ... R(n-1)).

Mathematica 82 74 63 bytes

Com 11 bytes salvos graças ao alephalpha.

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

Fatores primos de R70

(10 ^ 70 - 1) / 9 = 11111111111111111111111111111111111111111111111111111111111111111111

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}}

Novos fatores primos do R70

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

{4147571, 265212793249617641}

MATL , 25 bytes

Isso funciona para entrada até 16:

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

A versão a seguir usa 31 bytes e funciona até 18. Para 19isso, requer cerca de 4 GB de memória (não consegui executá-lo).

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

Exemplo

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

Explicação

Considere a entrada de concretude 6. Primeiro, os principais divisores de 111111são calculados; neste caso, os resultados são 3, 7, 11, 13, 37. Em seguida, a operação de módulo (resto de divisão) é calculado para todas as combinações de números 1, 11, ... 111111e os divisores computados. Isso explora a expansão implícita de singleton do MATL. O resultado é, neste caso, uma matriz 6x 5, com cada coluna correspondendo a um dos divisores. Divisores aceitos (colunas) são aqueles para os quais apenas o 1valor (ou seja, o último) fornece zero restante.

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

(*) Removido na versão curta

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 é uma função sem nome que chama uma função auxiliar R. Para chamá-lo, dê um nome à função principal, por exemplo f=n->....

Ungolfed:

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 do LabVIEW

19 leva uma eternidade ...

Trabalhe salvando todos os Primes e excluindo elementos do último conjunto quando eles forem encontrados na outra matriz.

J, 24 bytes

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

Espera valores numéricos de precisão estendida após 6 (por exemplo, em 19xvez de 19).

Experimente online!

Provavelmente existe uma maneira mais curta de gerar as repunições, o que evita os limites também.

Explicação

[: ({: -. }:) @: 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)

Como funciona, visualmente

Penso que este tipo de explicação visual é mais fácil de suportar para quem não conhece J. Estes são resultados do 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