배경

사람들은 채팅 에서 주요 인수 분해를 이야기 하고 있었고, 우리는 자신이 상환에 대해 이야기하고 있음을 발견했습니다. Repunits 는 repdigits 로 알려진 숫자의 하위 집합으로, 222or 와 같은 반복 숫자만으로 구성되는 숫자 4444444444444444이지만, repunits는으로 만 구성됩니다 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
...

도전

STDIN 을 통해 입력 정수 n 또는 이와 동등한 값이 주어지면 R _n에 대한 새로운 소수 인자를 편리한 형식으로 출력하거나 반환 하는 프로그램 또는 함수를 작성하십시오 . "소설의 주요 요인"여기에 모든 의미 곳 의 주요 요인이다 R _{, N} , 그러나 이전의 주요 요인이 아니다 R의 _K 와 함께, 우리 모두의 소인수 작성하는 경우 (즉, R 순서를, 우리가 본 적이 없다 전에).n >= 2xxx1 <= k < nx

실시 예

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 포인트 현상금을 제공합니다 . 토마스 콰는 우아한 증거를 제안 했고, 현상금을 수여했습니다.

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

여기에서 시도 하십시오 .

모든 repunit이 새로운 주요 요소를 가지고 있다는 증거

Zsigmondy의 정리를 사용 하면 증거는 간단합니다. Wikipedia에서 :

만약 그 번호 이론, Zsigmondy 정리는 칼 즈 시그 몬디 후 상태라는 A> B> 0는 서로 소이며, 다음 어떤 정수 N ≥ 1 , 소수의 존재 (P) 이 (a 프리미티브 프라임 제수 불리는)이 분할 된 ^N - B ^{, N} 및 나누지 ^K - B의 ^K를 임의의 양의 정수에 대한 N K < 다음의 예외를 제외하고, [여기서 적용되지 않은 것].

회수 시간 9, 즉 10 ⁿ -1을 고려하십시오 . 와 Zsigmondy의 정리함으로써 = 10 , B = 1 , 일부 소수가 페이지 | 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를.

따라서 지그 몬디 정리 p 는 모든 R _n , n ≥ 2 의 새로운 주요 요소입니다. ∎

반복되는 새로운 주요 요인의 예

소수 487 은 R ₄₈₆ 의 반복 소수입니다 .

Fermat-Euler 정리에 의해 10 ^487-1 ≡ 1 (mod 487) . 10 mod 487의 차수, 즉 1 mod 487 인 10의 최소 제곱은 486의 제수 여야합니다. 실제로 차수는 486과 같습니다. 또한 10 ⁴⁸⁶ ≡ 1 일뿐입니다. (mod 487) 이고, 또한 1 (mod 487 ² ) 입니다.

참조 여기에 10 모드 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).

하스켈 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 = 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}}

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값 (즉, 마지막) 만 나머지를 0으로하는 것입니다.

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