Lo sfondo

La gente parlava di fattorizzazione in chat e ci siamo ritrovati a parlare di rimpatrio. I repunits sono un sottoinsieme dei numeri noti come repdigits, che sono numeri costituiti solo da cifre ripetute, come 222o 4444444444444444, ma le ricompense sono costituite solo da 1.

I primi due sono quindi repunits 1, 11, 111, ecc Questi sono indicati con R _n , così R ₁ = 1, R ₂ = 11, ecc, e sono generati dalla formula R(n) = (10^n - 1)/9, con n > 0.

La scomposizione in fattori primi di questi numeri di repunit segue la sequenza A102380 nell'OEIS. Per esempio:

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

La sfida

Scrivere un programma o funzione che, quando somministrato un ingresso intero n con n >= 2via STDIN o equivalente , uscite o ritorni i nuovi fattori principali per R _n , in qualsiasi formato conveniente. "Nuovi fattori primi" qui significa tutto xdove xè un fattore primo di R _n , ma xnon è un fattore primo per qualsiasi R _k precedente , con 1 <= k < n(cioè, se scriviamo i fattori primi per tutti R in sequenza, non abbiamo visto xprima).

Gli esempi

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)

Gli extra:

• Il tuo codice può fare qualsiasi cosa o niente se n < 2.
• Puoi assumere un limite superiore "ragionevole" per nscopi di test ed esecuzione - ad esempio, non ti aspettiamo che il tuo codice venga emesso n = 10000000, ma il tuo algoritmo dovrebbe funzionare in tal caso se ti danno potenza e tempo di calcolo illimitati.
• Ecco un sito dedicato alle fattorizzazioni dei rimborsi per riferimento.
• Non ho analizzato la matematica, ma propongo un'ipotesi che ogni n abbia un risultato distinto per questo algoritmo - cioè, n non esiste in modo tale che R _n non abbia nuovi fattori. Offrirò una taglia di 250 punti se qualcuno lo dimostra o smentisce nella loro risposta. Thomas Kwa ha proposto una prova elegante e io ho assegnato la generosità.

Pyth, 16 14 13 byte

-F_m{P/^Td9SQ

Come meglio posso dire, 19 impiega per sempre.

-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

Provalo qui .

Prova che ogni repunit ha un nuovo fattore primo

utilizzando il Teorema di Zsigmondy , la dimostrazione è semplice. Da Wikipedia:

Nella teoria dei numeri, il teorema di Zsigmondy, che prende il nome da Karl Zsigmondy, afferma che se a> b> 0 sono interi coprimi, quindi per qualsiasi numero intero n ≥ 1 , esiste un numero primo p (chiamato divisore primitivo primitivo) che divide un ⁿ - b ⁿ e non divide un ^k - b ^k per nessun numero intero positivo k <n , con le seguenti eccezioni: [cose che non si applicano qui].

Considera i tempi di ricompensa 9: cioè 10 ⁿ -1 . Secondo il teorema di Zsigmondy con a = 10 , b = 1 , c'è qualche primo p | 10 ⁿ -1 che non divide 10 ^k -1 , k <n .

• Poiché p è primo e 10 ⁿ -1 = 9 · R _n , deve dividere 9 o R _n .

• p non può dividere 9 , poiché 9 = 10 ¹ -1 .

• Pertanto p divide R _n .

• p non può dividere alcun R _k , poiché non divide 10 ^k -1 = 9 · R _k .

Pertanto la p del teorema di Zsigmondy è un nuovo fattore primo di qualsiasi R _n , n ≥ 2 . ∎

Un esempio di un nuovo fattore primo romanzo ripetuto

Il primo 487 è un fattore primo ripetuto di R ₄₈₆ :

Dal teorema di Fermat-Euler, 10 ^487-1 ≡ 1 (mod 487) . L'ordine di 10 mod 487, ovvero il potere più piccolo di 10 ovvero 1 mod 487, deve quindi essere un divisore di 486. In realtà, l'ordine è uguale a 486. Succede anche che non solo 10 ⁴⁸⁶ ≡ 1 (mod 487) , è anche 1 (mod 487 ² ) .

Vedi qui che l'ordine di 10 mod 487 è 486; cioè che 10 ^k -1 non più piccolo è divisibile per 487. Ovviamente, 487 non divide 9, quindi deve dividere R ₄₈₆ .

CJam, 18 byte

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

Provalo qui.

A partire da 19 (il primo numero di repunit dopo 2) ci vorrà un tempo abbastanza lungo.

Spiegazione

Questo è un blocco senza nome (l'equivalente di una funzione di CJam), che si aspetta il numero di input nnello stack e lascia invece un elenco di fattori primi:

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

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

Esempio di utilizzo: f 8-> [73,137].

Richiede molto tempo e memoria alla grande n.

Implementazione diretta della definizione: prendere tutti i fattori primi xdi Rncui non si presentano prima ( f=<<[1..n-1]sono tutti i fattori primi di R1 ... R(n-1)).

Mathematica 82 74 63 byte

Con 11 byte salvati grazie ad alephalpha.

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

Fattori primi di R70

(10 ^ 70-1) / 9 = 111111111111111111111111111111111111111111111111111111111111111111111111

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

Nuovi fattori primi di R70

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

{4147571, 265212793249617641}

MATL , 25 byte

Funziona con input fino a 16:

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

La seguente versione utilizza 31 byte e funziona fino a 18. Perché 19richiede circa 4 GB di memoria (non sono stato in grado di eseguirlo).

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

Esempio

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

Spiegazione

Considerare l'input di concretezza 6. Innanzitutto 111111vengono calcolati i primi divisori di ; in questo caso i risultati sono 3, 7, 11, 13, 37. L'operazione di modulo (resto della divisione) viene calcolato per tutte le combinazioni di numeri 1, 11, ... 111111ei divisori calcolate. Questo sfrutta l'espansione singleton implicita di MATL. Il risultato è in questo caso una matrice 6x 5, con ogni colonna corrispondente a uno dei divisori. I divisori (colonne) accettati sono quelli per i quali solo il 1valore (vale a dire l'ultimo) fornisce zero 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

(*) Rimosso nella versione breve

Julia, 103 byte

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

Questa è una funzione senza nome che chiama una funzione di supporto R. Per chiamarlo, assegnare un nome alla funzione principale, ad es 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 LabVIEW Primitives

19 ci vuole per sempre ...

Lavora salvando tutti i Primes ed eliminando gli elementi dall'ultimo set quando vengono trovati nell'altro array.

J, 24 byte

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

Si aspetta valori numerici di precisione estesa dopo 6 (ad es. 19xAnziché 19).

Provalo online!

C'è probabilmente un modo più breve per generare i rimborsi che evita anche i limiti.

Spiegazione

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

Come funziona, visivamente

Penso che questo tipo di spiegazioni visive sia più facile da digerire per coloro che non conoscono J. Questi sono i risultati 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