Фон

Люди говорили о факторизации в чате, и мы говорили о встречах. Повторные объединения представляют собой подмножество чисел, известных как повторные обозначения, которые представляют собой числа, состоящие только из повторяющихся цифр, таких как 222или 4444444444444444, но повторные соединения состоят только из 1.

Первая пара repunits, следовательно 1, 11, 111и т.д. Они называются по R _п , так что R ₁ = 1, R ₂ = 11, и т.д., и генерируются по формуле R(n) = (10^n - 1)/9, с n > 0.

Первичная факторизация этих чисел повторения объединяет последовательность A102380 в OEIS. Например:

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 баллов, если кто-то докажет или опровергнет это в своем ответе. Томас Ква предложил элегантное доказательство , и я наградил награду.

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

Попробуй это здесь .

Доказательство того, что каждое воссоединение имеет новый главный фактор

Используя теорему Зигмонди , доказательство простое. Из Википедии:

В теории чисел, теорема Жигмонды, названный в честь Карла Зигмонди, утверждает , что если а> Ь> 0 взаимно простые целые числа, то для любого целого п ≥ 1 , существует простое число р ( так называемый примитивный простой делитель) , который делит ^п - b ⁿ и не делит a ^k - b ^k для любого положительного целого числа k <n со следующими исключениями: [вещи, которые здесь не применяются].

Рассмотрим 9 повторений: то есть 10 ^н -1 . По теореме Зигмонди с a = 10 , b = 1 существует некоторое простое число p | 10 ⁿ -1 , который не делит любые 10 ^k -1 , k <n .

• Поскольку p простое и 10 ⁿ -1 = 9 · R _n , оно должно делиться либо на 9, либо на R _n .

• р не может делить 9 , так как 9 = 10 ¹ -1 .

• Следовательно, p делит R _n .

• p не может делить R _k , поскольку он не делит 10 ^k -1 = 9 · R _k .

Поэтому p из теоремы Жигмонди является новым простым множителем любого R _n , n ≥ 2 . ∎

Пример повторного романа простого фактора

Простое 487 является повторным простым множителем R ₄₈₆ :

По теореме Ферма-Эйлера, 10 ^487-1 (1 (mod 487) . Порядок 10 mod 487, то есть наименьшая степень 10, то есть 1 mod 487, следовательно, должен быть делителем 486. Фактически, порядок равен 486. Также бывает, что не только 10 ⁴⁸⁶ ≡ 1 (мод 487) , это также 1 (мод 487 ² ) .

Смотрите здесь, что порядок 10 мод 487 486; то есть, что не меньше 10 ^k -1 делится на 487. Очевидно, 487 не делит 9, поэтому он должен делить R ₄₈₆ .

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 байта

С 11 байтами, сохраненными благодаря alephalpha.

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

Основные факторы R70

(10 ^ 70 - 1) / 9 = 11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111

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 ГБ памяти (я не смог его запустить).

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значение (а именно последнее) дает нулевой остаток.

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

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

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