L'arrière-plan

Les gens parlaient de la factorisation principale dans le chat et nous nous sommes retrouvés à parler de remboursements. Les répétitions sont un sous-ensemble des nombres appelés repdigits, qui sont des nombres constitués uniquement de chiffres répétitifs, comme 222ou 4444444444444444, mais les répétitions ne sont constituées que de 1.

Les premiers repunits couple sont donc 1, 11, 111, etc. Ceux - ci sont désignés par R _n , de sorte que R ₁ = 1, R ₂ = 11, etc., et sont générés par la formule R(n) = (10^n - 1)/9, avec n > 0.

La factorisation en nombre premier de ces nombres de répétitions suit la séquence A102380 dans l'OEIS. Par exemple:

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

Le défi

Écrivez un programme ou une fonction qui, lorsqu'il reçoit un entier d'entrée n avec n >= 2via STDIN ou équivalent , génère ou renvoie les nouveaux facteurs premiers pour R _n , dans n'importe quel format pratique. "Nouveaux facteurs premiers" signifie ici tout xoù xest un facteur premier de R _n , mais xn'est pas un facteur premier pour tout R _k précédent , avec 1 <= k < n(c'est-à-dire, si nous écrivons les facteurs premiers pour tous les R dans l'ordre, nous n'avons pas vu xavant).

Les exemples

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)

Les extras:

• Votre code peut faire n'importe quoi ou rien si n < 2.
• Vous pouvez supposer une limite supérieure « raisonnable » pour nfins de test et d' exécution - votre code ne sera pas prévu de sortie pour n = 10000000, par exemple, mais votre algorithme doit travailler pour un tel cas , si la puissance de calcul illimitée donnée et le temps.
• Voici un site dédié aux factorisations des remboursements pour référence.
• Je ne suis pas passé par les mathématiques, mais je propose une hypothèse selon laquelle chaque n a un résultat distinct pour cet algorithme - c'est-à-dire qu'aucun n n'existe tel que R _n n'a pas de nouveaux facteurs. J'offrirai une prime de 250 points si quelqu'un le prouve ou le réfute dans sa réponse. Thomas Kwa a proposé une preuve élégante et j'ai attribué la prime.

Pyth, 16 14 13 octets

-F_m{P/^Td9SQ

Autant que je sache, 19 prend une éternité.

-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

Essayez-le ici .

Preuve que chaque remboursement a un nouveau facteur premier

En utilisant le théorème de Zsigmondy , la preuve est simple. De Wikipédia:

En théorie des nombres, le théorème de Zsigmondy, nommé d'après Karl Zsigmondy, déclare que si a> b> 0 sont des entiers premiers , alors pour tout entier n ≥ 1 , il y a un nombre premier p (appelé diviseur premier primitif) qui divise un ⁿ - b ⁿ et ne divise pas a ^k - b ^k pour tout entier positif k <n , avec les exceptions suivantes: [choses qui ne s'appliquent pas ici].

Considérez les temps de remboursements 9: c'est-à-dire 10 ⁿ -1 . Par le théorème de Zsigmondy avec a = 10 , b = 1 , il y a un premier p | 10 ⁿ -1 qui ne divise aucun 10 ^k -1 , k <n .

• Puisque p est premier et 10 ⁿ -1 = 9 · R _n , il doit diviser 9 ou R _n .

• p ne peut pas diviser 9 , car 9 = 10 ¹ -1 .

• Par conséquent, p divise R _n .

• p ne peut diviser aucun R _k , car il ne divise pas 10 ^k -1 = 9 · R _k .

Par conséquent, le p du théorème de Zsigmondy est un nouveau facteur premier de tout R _n , n ≥ 2 . ∎

Un exemple d'un nouveau facteur premier répété

Le nombre premier 487 est un facteur premier répété de R ₄₈₆ :

Par le théorème de Fermat-Euler, 10 ^487-1 ≡ 1 (mod 487) . L'ordre de 10 487 mod, qui est la plus petite puissance de 10 qui est de 1 487 mod, doit donc être un diviseur de 486. En fait, l'ordre est égal à 486. Il arrive aussi que non seulement 10 ⁴⁸⁶ ≡ 1 (mod 487) , c'est aussi 1 (mod 487 ² ) .

Voyez ici que l'ordre de 10 mod 487 est 486; c'est-à-dire qu'aucun 10 ^k -1 plus petit n'est divisible par 487. Évidemment, 487 ne divise pas 9, il doit donc diviser R ₄₈₆ .

CJam, 18 octets

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

Testez-le ici.

À partir de 19 (le premier prime de repu après 2), cela prendra un temps assez long.

Explication

Il s'agit d'un bloc sans nom (l'équivalent de CJam d'une fonction), qui attend le numéro d'entrée nsur la pile et laisse une liste de facteurs premiers à la place:

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

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

Exemple d'utilisation: f 8-> [73,137].

Prend beaucoup de temps et de mémoire pour les grands n.

La mise en œuvre directe de la définition: prendre tous les facteurs premiers xde ce Rnqui ne se présentent pas avant ( f=<<[1..n-1]sont tous les facteurs premiers R1 ... R(n-1)).

Mathematica 82 74 63 octets

Avec 11 octets enregistrés grâce à l'alephalpha.

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

Facteurs premiers de 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}}

Nouveaux facteurs premiers du R70

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

{4147571, 265212793249617641}

MATL , 25 octets

Cela fonctionne pour l'entrée jusqu'à 16:

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

La version suivante utilise 31 octets et fonctionne jusqu'à 18. Car 19il nécessite environ 4 Go de mémoire (je n'ai pas pu l'exécuter).

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

Exemple

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

Explication

Tenez compte de la saisie du concret 6. D'abord, les diviseurs premiers de 111111sont calculés; dans ce cas , les résultats sont 3, 7, 11, 13, 37. Ensuite , l'opération modulo (reste de la division) est calculé pour toutes les combinaisons de nombres 1, 11, ... 111111et les diviseurs calculés. Ceci exploite l'expansion implicite singleton de MATL. Le résultat est dans ce cas une matrice 6x 5, chaque colonne correspondant à l'un des diviseurs. Les diviseurs (colonnes) acceptés sont ceux pour lesquels seule la 1valeur (à savoir la dernière) donne zéro reste.

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

(*) Supprimé dans la version courte

Julia, 103 octets

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

Il s'agit d'une fonction sans nom qui appelle une fonction d'assistance R. Pour l'appeler, donnez un nom à la fonction principale, par exemple f=n->....

Non 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 primitives LabVIEW

19 prend une éternité ...

Travaillez en enregistrant tous les amorces et en supprimant les éléments du dernier ensemble lorsqu'ils se trouvent dans l'autre tableau.

J, 24 octets

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

Attend une précision numérique étendue après 6 (par exemple 19xau lieu de 19).

Essayez-le en ligne!

Il existe probablement un moyen plus court de générer les remboursements, ce qui évite également les plafonds.

Explication

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

Comment ça marche, visuellement

Je pense que ce genre d'explications visuelles est plus facile à digérer pour ceux qui ne connaissent pas J. Ce sont des résultats du 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