Der Hintergrund

Die Leute sprachen im Chat über die Hauptfaktorisierung und wir sprachen über Repunits. Repunits sind eine Untermenge der als repdigits bezeichneten Zahlen, bei denen es sich um Zahlen handelt, die nur aus sich wiederholenden Ziffern wie 222oder bestehen 4444444444444444, aber nur aus Repunits 1.

Die ersten paar Repunit - Zahlen sind daher 1, 11, 111usw. Diese sind bezeichnet durch R _n , so R ₁ = 1, R ₂ = 11usw. und werden durch die Formel erzeugt wird R(n) = (10^n - 1)/9, mit n > 0.

Die Primfaktorisierung dieser Repunit-Nummern folgt der Sequenz A102380 im OEIS. Beispielsweise:

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

Die Herausforderung

Schreiben Sie ein Programm oder eine Funktion, die, wenn sie eine Eingabe-Ganzzahl n mit n >= 2über STDIN oder ein Äquivalent erhalten , die neuen Primfaktoren für R _n in einem beliebigen geeigneten Format ausgibt oder zurückgibt . "Neue Primfaktoren" bedeutet hier alles, xwo xein Primfaktor von R _{n ist} , aber xkein Primfaktor für irgendein vorheriges R _{k ist} , mit 1 <= k < n(dh, wenn wir die Primfaktoren für alle R nacheinander schreiben , haben wir nicht gesehen xVor).

Die Beispiele

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)

Die Extras:

• Ihr Code kann alles oder nichts, wenn n < 2.
• Sie können nfür Test- und Ausführungszwecke von einer "angemessenen" Obergrenze ausgehen. Es wird beispielsweise nicht erwartet , dass Ihr Code ausgegeben n = 10000000wird, aber Ihr Algorithmus sollte in einem solchen Fall funktionieren, wenn unbegrenzte Rechenleistung und Zeit zur Verfügung stehen.
• Hier finden Sie eine Website, die sich mit der Aufteilung von Repunits befasst.
• Ich habe die Mathematik nicht durchgearbeitet, aber ich schlage eine Hypothese vor, dass jedes n ein bestimmtes Ergebnis für diesen Algorithmus hat - das heißt, kein n existiert so, dass R _n keine neuen Faktoren hat. Ich biete ein Kopfgeld von 250 Punkten an, wenn jemand dies in seiner Antwort beweist oder widerlegt. Thomas Kwa schlug einen eleganten Beweis vor , und ich verlieh das Kopfgeld.

Pyth, 16 14 13 Bytes

-F_m{P/^Td9SQ

Wie ich am besten beurteilen kann, dauert 19 ewig.

-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

Probieren Sie es hier aus .

Beweis, dass jede Repunit einen neuartigen Primfaktor hat

Mit dem Satz von Zsigmondy ist der Beweis einfach. Aus Wikipedia:

In der Zahlentheorie besagt der nach Karl Zsigmondy benannte Satz von Zsigmondy, dass es für jede ganze Zahl n ≥ 1 eine Primzahl p gibt , die ein ⁿ - teilt , wenn a> b> 0 ganze Zahlen sind. b ⁿ und dividiert kein ^k - b ^k für eine positive ganze Zahl k <n mit den folgenden Ausnahmen: [Dinge, die hier nicht zutreffen].

Betrachten Sie die Wiederholungen mal 9, dh 10 ⁿ -1 . Nach dem Satz von Zsigmondy mit a = 10 , b = 1 gibt es einige Primzahlen p | 10 ⁿ -1 , das keine 10 ^k -1 teilt , k <n .

• Da p eine Primzahl ist und 10 ⁿ –1 = 9 · R _n , muss es entweder 9 oder R _n dividieren .

• p kann 9 nicht teilen, da 9 = 10 ¹ -1 .

• Daher dividiert p R _n .

• p kann kein R _k teilen, da es nicht 10 ^k -1 = 9 · R _k teilt.

Daher ist das p aus dem Satz von Zsigmondy ein neuartiger Primfaktor für R _n , n ≥ 2 . ∎

Ein Beispiel für einen wiederholten neuartigen Primfaktor

Die Primzahl 487 ist ein wiederholter Primfaktor von R ₄₈₆ :

Nach dem Fermat-Euler-Theorem 10 ^487-1 ≡ 1 (mod 487) . Die Ordnung von 10 mod 487, dh die kleinste Potenz von 10, die 1 mod 487 ist, muss daher ein Teiler von ^{486 sein.} Tatsächlich ist die Ordnung gleich 486. Es kommt auch vor, dass nicht nur 10 ⁴⁸⁶ ≡ 1 ist (mod 487) , es ist auch 1 (mod 487 ² ) .

Sehen Sie hier, dass die Reihenfolge von 10 mod 487 486 ist; das heißt, dass keine kleineren 10 ^k -1 durch 487 teilbar sind. Offensichtlich teilt 487 nicht 9, also muss es R ₄₈₆ teilen .

CJam, 18 Bytes

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

Teste es hier.

Ab 19 (die erste Wiederauflage nach 2) wird es ziemlich lange dauern.

Erläuterung

Dies ist ein unbenannter Block (CJams Äquivalent zu einer Funktion), der die Eingangsnummer nauf dem Stapel erwartet und stattdessen eine Liste von Primfaktoren hinterlässt:

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

Anwendungsbeispiel: f 8-> [73,137].

Braucht viel Zeit und Gedächtnis für groß n.

Direkte Umsetzung der Definition: Nehmen Sie alle Primfaktoren xvon Rndenen sich nicht zeigen vor ( f=<<[1..n-1]alle Primfaktoren R1 ... R(n-1)).

Mathematica 82 74 63 Bytes

Mit 11 Bytes dank Alephalpha gespart.

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

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

Neue Primfaktoren von R70

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

{4147571, 265212793249617641}

MATL , 25 Bytes

Dies funktioniert für Eingaben bis zu 16:

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

Die folgende Version verwendet 31 Bytes und funktioniert bis zu 18. Dafür 19werden ca. 4 GB Arbeitsspeicher benötigt (ich konnte es nicht ausführen).

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

Beispiel

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

Erläuterung

Bei der Eingabe der Konkretheit berücksichtigen 6. Zuerst werden die Hauptteiler von 111111berechnet; in diesem Fall sind die Ergebnisse 3, 7, 11, 13, 37. Dann wird die Modulo - Operation (Divisionsrest) wird für alle Kombinationen von Zahlen berechnet 1, 11... 111111und die berechneten Teilern. Dies nutzt die implizite Singleton-Erweiterung von MATL. Das Ergebnis ist in diesem Fall eine 6x- 5Matrix, wobei jede Spalte einem der Teiler entspricht. Akzeptierte Teiler (Spalten) sind diejenigen, für die nur der 1Wert (nämlich der letzte) den Rest Null ergibt.

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

(*) In Kurzfassung entfernt

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

Dies ist eine unbenannte Funktion, die eine Hilfsfunktion aufruft R. Um es aufzurufen, geben Sie der Hauptfunktion einen Namen, z 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-Grundelemente

19 dauert ewig ...

Speichern Sie alle Primzahlen und löschen Sie Elemente aus der letzten Gruppe, wenn sie im anderen Array gefunden wurden.

J, 24 Bytes

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

Erwartet Zahlen mit erweiterter Genauigkeit nach 6 (z . B. 19xstatt 19).

Probieren Sie es online!

Es gibt wahrscheinlich einen kürzeren Weg, um die Repunits zu generieren, der auch die Caps vermeidet.

Erläuterung

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

Wie es funktioniert, visuell

Ich denke, dass solche visuellen Erklärungen für diejenigen, die J nicht kennen, leichter zu ertragen sind. Dies sind Ergebnisse der 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