Repunits的新颖主要因素

20

背景

人们在聊天中谈论素分解，我们发现自己在谈论repunits。Repunits是称为repdigits的数字的子集，repdigits仅由重复数字组成，例如222或4444444444444444，但是repunits仅由组成1。

因此，第一耦合repunits是1，11，111等。这些可通过称为[R Ñ，所以ř 1 = 1，- [R 2 = 11，等，和由下式产生R(n) = (10^n - 1)/9，与n > 0。

这些重复单元编号的素数分解遵循OEIS中的序列A102380。例如：

R 1 = 1
R 2 = 11
R 3 = 111 = 3 * 37
R 4 = 1111 = 11 * 101
R 5 = 11111 = 41 * 271
R 6 = 111111 = 3 * 7 * 11 * 13 * 37
R 7 = 1111111 = 239 * 4649
...

挑战

编写一个程序或函数，当通过STDIN或等效函数给定输入整数n时，以任何方便的格式输出或返回R n的新颖素数。“小说主要因素”在这里是指所有的地方是一个主要因素[R ñ，而不是以前的任何一个主要因素[R ķ，用（例如，如果我们写的所有的主要因素[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，例如，而是你的算法应该工作，如果给予无限的计算能力和时间，这样的情况下。
  • 这是一个专门针对repunits分解的站点，以供参考。
  • 我没有通过数学了，但我提出了一个假设，即每ñ有这个算法不同的结果-也就是说，没有ñ存在，使得[R ñ没有新的因素。如果有人在回答中证明或反对，我将提供250分的奖励。托马斯·夸（Thomas Kwa）提出了一个优雅的证明，我授予了赏金。
code-golf  math  number-theory  primes  factoring 
— AdmBorkBork
source
内置的素数检查和分解是公平的游戏吗？
— 马丁·恩德
@MartinBüttner没有限制。
— AdmBorkBork 2015年
— alephalpha
@alephalpha因为当然有了OEIS链接;-)谢谢！
— AdmBorkBork 2015年

Answers:

5

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

在这里尝试。

— 小鱼
source
如果从命令行运行它并安装了SymPy，则19秒之内即可完成。第一个接管2秒是输入38
— isaacg
12

证明每个重复单元都有一个新的素数因子

使用Zsigmondy定理，证明很简单。从维基百科：

在数论，席格蒙迪定理，卡尔·席格蒙迪命名，指出，如果A> B> 0是互质，则对于任何整数Ñ≥1 ，有一个素数p（称为原始素因子），其将一个ñ - b ñ和不划分一个ķ - b ķ为任意正整数ķ<N ，有以下例外：[不适用于此的东西。

考虑repunits乘以9：即10 n -1。根据Zsigmondy定理，a = 10，b = 1，存在一些质数p |。 10 n -1不除任何10 k -1，k <n。

  • 由于p为质数且10 n -1 = 9·R n，因此必须除以9或R n。

  • p不能除以 9，因为 9 = 10 1 -1。

  • 因此p除以R n。

  • p不能除以任何 R k，因为它不除以 10 k -1 = 9·R k。

因此，齐格蒙第定理中的p是任何R n，n≥2的新素数。∎

重复的新素数的一个例子

质数487是R 486的重复质数：

根据Fermat-Euler定理，10 487-1≡1（mod 487）。10 MOD 487，即，10是1个模487的最小功率的顺序，因此必须是486.事实上一个除数，顺序是等于486.这也恰好不仅是10 486 ≡1 （mod 487），它也是1（mod 487 2）。

见这里是10 MOD 487的顺序是486; 也就是说，487可以整除不小于10 k -1。显然，487不除9，因此必须除以R 486。

— 小鱼
source
6

CJam，18个字节

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

在这里测试。

从19（2之后的第一个repunit素数）开始，将花费相当长的时间。

说明

这是一个未命名的块（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).
— 马丁·恩德
source
3
...您是否认真地在过去三分钟内只打了20到16球？>。>
— AdmBorkBork 2015年
@TimmyD之类的...我现在不得不再次上升到18，因为事实证明我的代码是基于我现在无法证明或反驳的假设。
— 马丁·恩德
噢，那是一个有趣的例子-重复新颖的因素。不错的收获。
— AdmBorkBork 2015年
4

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)）。

— 妮米
source
3

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}

— 戴维
source
Complement@@Reverse@FactorInteger[(10^Range@#-1)/9][[;;,;;,1]]&
— alephalpha
请解释[[;;,;;,1]]或的含义[[1 ;; All, 1 ;; All, 1]]。我很困惑！
— DavidC 2015年
@DavidCarraher它接受列表中每个元素的每个元素的第一个元素。
— LegionMammal978 2015年
@DavidCarraher [[;;,;;,1]]与相同[[All,All,1]]。
— alephalpha 2015年
现在这很有意义。顺便说一句，您的重新安置Range非常聪明。
— DavidC
2

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值（即最后一个）给出零余数的除数。

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

（*）简短版本中删除

— 路易斯·门多
source
这是一种聪明的方法。
— AdmBorkBork 2015年
2

朱莉娅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。要调用它，请给main函数起一个名字，例如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
— 亚历克斯·A
source
2

LabVIEW，33个LabVIEW原语

19需要永远...

通过保存所有素数并在另一个数组中找到它们时从上一组删除元素来工作。

— 尤梅尔
source
1

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
— 油菜
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.