背景

人々はチャットで素因数分解について話していましたが、私たちはレプユニットについて話していました。Repunitsはrepdigitsとして知られる数字のサブセットです。これは、222またはなどの繰り返し数字のみで構成される数字ですが、repunitsはのみで4444444444444444構成されます1。

最初のカップルrepunits従ってあり1、11、111など、これらによって参照されるR _Nので、R ₁ = 1、R ₂ = 11、等、及び式によって生成されるR(n) = (10^n - 1)/9と、n > 0。

これらのレプユニット番号の素因数分解は、OEISのシーケンスA102380に従います。例えば：

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

チャレンジ

整数入力が与えられると、プログラムまたは機能書き込みNを有するn >= 2介しSTDINまたは同等の、出力または戻り新規のための素因数R _nは任意の便利な形式では、。「小説素因数」ここにすべてを意味xどこxの素因数であるRは、_nは、しかし、x以前の主要要因ではないRの_K、と1 <= k < n私たちはすべてのための素因数を書く場合（すなわち、Rの順序で、私たちは見ていませんでしたx前）。

例

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)

エクストラ：

• の場合、コードは何でも何もできませんn < 2。
• nテストと実行の目的で「合理的な」上限を想定できます。たとえば、コードの出力は期待されませんがn = 10000000、計算能力と時間に制限がない場合、アルゴリズムはそのような場合に機能するはずです。
• 参照用のレプユニットの因数分解に特化したサイトはこちらです。
• 私は数学を経ていませんでしたが、私はすべてのことを仮説を提案nは、このアルゴリズムのための明確な結果がある-いや、あるn個あるように存在するR _nは何の小説の要素を持っていませんが。誰かが答えでそれを証明または反証した場合、250ポイントの報奨金を提供します。Thomas Kwaがエレガントな証拠を提案し、私は賞金を授与しました。

Pyth、16 14 13バイト

-F_m{P/^Td9SQ

私が知る限り、19は永遠にかかります。

-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

ここで試してみてください。

すべてのレプユニットに新しい素因数があることの証明

Zsigmondyの定理を使用すると、証明は簡単です。ウィキペディアから：

カール・ズシグモンディーにちなんで名付けられた数論、ジグモンディの定理、場合、その状態ではA> B> 0が互いに素あり、その後、任意の整数のためのn≥1 、素数が存在したp分割（プリミティブプライム除数と呼ばれる）^のnは - B ^Nと分割しない^K - B ^kの任意の正の整数のためのk <nは、以下の例外を除いて、[ここには適用されない事を]。

repunitsの9倍、つまり10 ⁿ -1を考えます。a = 10、b = 1の Zsigmondyの定理により、いくつかの素数p | 10 ^N -1任意に分割しない10 ^kは -1、K <N 。

• 以来、pは素数であり10 ^N -1 = 9・R _Nは、いずれかの分割しなければならない9又はR _N。

• 9 = 10 ¹ -1であるため、 pは 9を除算できません。

• したがって、pはR _nを分割します。

• pは 10 ^k -1 = 9・R _kを分割しないため、 R _kを分割できません。

したがって、Zsigmondyの定理からのpは、R _n、n≥2の新しい素因数です。∎

繰り返される新しい素因数の例

素数487は、R _486の反復素因数です：

フェルマー・オイラーの定理、10 ^487-1≡1（mod 487）によります。1つのMOD 487で10の最小パワーで10 MOD 487の順序は、従って、実際には486の約数である必要があり、順序はそれだけではないことが起こり486に等しい10 ⁴⁸⁶ ≡1 （mod 487）、それも1（mod 487 ²）です。

参照してくださいここで 10のmod 487の順序が486であること。つまり、より小さな10 ^k -1は487で割り切れません。明らかに、487は9を分割しないため、R _486を分割する必要があります。

CJam、18バイト

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

ここでテストしてください。

19（2の後の最初のレプユニットプライム）から開始すると、かなり長い時間がかかります。

説明

これは名前のないブロック（CJamの関数に相当）でありn、スタック上の入力番号を予期し、代わりに素因数のリストを残します。

{      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バイト

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

使用例：f 8-> [73,137]。

ビッグには多くの時間と記憶が必要nです。

定義の直接実装：すべての素因数取るxのRn（前に表示されません。これはf=<<[1..n-1]、すべての素因数ですR1 ... R(n-1)）を。

Mathematica 82 74 63バイト

alephalphaのおかげで11バイト節約されました。

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

R70の主な要因

（10 ^ 70-1）/ 9 = 1111111111111111111111111111111111111111111111111111111111111111111111111

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

R70の新しい素因数

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

{4147571、265212793249617641}

MATL、25バイト

これは以下の入力に対して機能します16。

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

次のバージョンは31バイトを使用し、最大で動作し18ます。その19ため、約4 GBのメモリが必要です（実行できませんでした）。

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

例

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

説明

具体的な入力を考慮してください6。最初にの素因数111111が計算されます。この場合には結果は3、7、11、13、37。次いでモジュロ演算（除算の余り）は数字の全ての組み合わせについて計算され1、11、... 111111と計算除数。これは、MATLの暗黙的なシングルトン拡張を活用します。この場合、結果は6x 5行列になり、各列は約数の1つに対応します。受け入れられる除数（列）は、1値（つまり、最後の値）のみが剰余ゼロを与えるものです。

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

（*）ショートバージョンで削除

ジュリア、103バイト

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

これは、ヘルパー関数を呼び出す名前のない関数ですR。呼び出すには、メイン関数に名前を付けf=n->...ます。

ゴルフをしていない：

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プリミティブ

19永遠に...

すべての素数を保存し、他の配列で見つかった最後の要素を削除して作業します。

J、24バイト

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

6の後の拡張精度数値を期待します（例：の19x代わりに19）。

オンラインでお試しください！

おそらく、キャップを回避する繰り返し単位を生成するより短い方法もあります。

説明

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

仕組み、視覚的に

この種の視覚的な説明は、Jを知らない人にとっては簡単に理解できると思います。これらは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