_{Redivosite是一个portmanteau单词，仅是本次挑战的目的。它是归约，除法和复合的混合。}

定义

给定整数N> 6：

• 如果N为质数，则N不是重新定义的数字。
• 如果N是复合的：
  • 重复计算N'= N / d + d + 1直到N'为素数，其中d是N大于1 的最小除数
  • Ñ是Redivosite数当且仅当的最终值N”是的除数Ñ

下面是100个第一个Redivosite编号（发布时没有OEIS条目）：

14,42,44,49,66,70,143,153,168,169,176,195,204,260,287,294,322,350,414,462,518,553,572,575,592,629,651,702,726,735,775,806,850,869,889,891,913,950,1014,1023,1027,1071,1118,1173,1177,1197,1221,1235,1254,1260,1302,1364,1403,1430,1441,1554,1598,1610,1615,1628,1650,1673,1683,1687,1690,1703,1710,1736,1771,1840,1957,1974,2046,2067,2139,2196,2231,2254,2257,2288,2310,2318,2353,2392,2409,2432,2480,2522,2544,2635,2640,2650,2652,2684,2717,2758,2760,2784,2822,2835

例子

• N = 13：13是质数，因此13不是Redivosite数字
• N = 32：32/2 + 3 = 19；19不是除数或32，因此32不是Redivosite数字
• N = 260：260/2 + 3 = 133，133 / 7 + 8 = 27，27 / 3 + 4 = 13；13是除数或260，因此260是Redivosite数字

你的任务

• 给定整数N，如果它是Redivosite Number，则返回真实值，否则返回假值。（您也可以输出任意两个不同的值，只要它们是一致的即可。）
• 确保输入大于6。
• 这是代码高尔夫球，因此最短答案以字节为单位！

Haskell，91 85 83 80 75 74字节

n#m=([n#(div m d+d+1)|d<-[2..m-1],mod m d<1]++[mod n m<1&&m<n])!!0
f x=x#x

在线尝试！

f x=x#x                           -- call # with x for both parameters
n#m               
         |d<-[2..m-1],mod m d<1   -- for all divisors d of m
    [n#(div m d+d+1)           ]  -- make a list of recursive calls to #,
                                  -- but with m set to m/d+d+1
   ++ [mod n m<1&&m<n]            -- append the Redivosite-ness of n (m divides n,
                                  -- but is not equal to n)
                           !!0    -- pick the last element of the list
                                  -- -> if there's no d, i.e. m is prime, the
                                  --    Redivosite value is picked, else the
                                  --    result of the call to # with the smallest d

编辑：感谢@ BMO，-2字节，感谢@ H.PWiz，-3字节，感谢@ØrjanJohansen，-5 -6字节

外壳，14个字节

?¬Ṡ¦ΩṗoΓ~+→Πpṗ

在线尝试！

-3感谢H.PWiz。

C（gcc），94 89字节

m,n;o(k){for(m=1;m++<k;)if(k%m<1)return m;}
F(N){for(n=N;m=o(n),m-n;n=n/m-~m);N=m<N>N%n;}

在线尝试！

说明

m,n;                  // two global integers
o(k){                 // determine k's smallest divisor
 for(m=1;m++<k;)      // loop through integers 2 to n (inclusive)
  if(k%m<1)return m;} // return found divisor
F(N){                 // determine N's redivosity
 for(n=N;             // save N's initial value
  m=o(n),             // calculate n's smallest divisor (no name clash regarding m)
  m-n;                // loop while o(n)!=n, meaning n is not prime
                      //  (if N was prime, the loop will never be entered)
  n=n/m-~m);          // redivosite procedure, empty loop body
 N=m<N>N%n;}          // m<N evaluates to 0 or 1 depending on N being prime,
                      //  N%n==0 determines whether or not N is divisible by n,
                      //  meaning N could be redivosite => m<N&&N%n==0
                      //  <=> m<N&&N%n<1 <=> m<N&&1>N%n <=> (m<N)>N%n <=> m<N>N%n

果冻，14字节

ÆḌḊ
Ç.ịS‘µÇ¿eÇ

在线尝试！

怎么运行的

ÆḌḊ         Helper link. Argument: k

ÆḌ          Yield k's proper (including 1, but not k) divisors.
  Ḋ         Dequeue; remove the first element (1).


Ç.ịS‘µÇ¿eÇ  Main link. Argument: n

     µ      Combine the links to the left into a chain.
      Ç¿    While the helper link, called with argument n, returns a truthy result,
            i.e., while n is composite, call the chain to the left and update n.
Ç             Call the helper link.
 .ị           At-index 0.5; return the elements at indices 0 (last) and 1 (first).
              This yields [n/d, d].
   S          Take the sum.
    ‘         Increment.
        Ç   Call the helper link on the original value of n.
       e    Test if the result of the while loop belongs to the proper divisors.

Python 2中，97个 91字节

r=0;e=d=i=input()
while r-e:e=i;r=[j for j in range(2,i+1)if i%j<1][0];i=i/r-~r
d%e<1<d/e<q

在线尝试！

通过退出代码输出。

取消高尔夫：

r = 0                             # r is the lowest divisor of the current number,
                                  # initialized to 0 for the while loop condition.
e = d = i = input()               # d remains unchanged, e is the current number
                                  # and i is the next number.
while r != e:                     # If the number is equal to its lowest divisor,
                                  # it is prime and we need to end the loop.
    e = i                         # current number := next number
    r = [j for j in range(2, i+1) # List all divisors of the number in the range [2; number + 1)
         if i%j < 1][0]           # and take the first (lowest) one.
    i = i/r+r+1                   # Calculate the next number.
                                  # We now arrived at a prime number.
print d%e == 0 and d != e         # Print True if our current number divides the input
                                  # and is distinct from the input.
                                  # If our current number is equal to the input,
                                  # the input is prime.

在线尝试！

05AB1E，17 16字节

[Dp#Òć©sP+>]Ö®p*

在线尝试！

说明

[                  # start loop
 Dp#               # break if current value is prime
    Ò              # get prime factors of current value
     ć©            # extract the smallest (d) and store a copy in register
       sP          # take the product of the rest of the factors
         +>        # add the smallest (d) and increment
           ]       # end loop
            Ö      # check if the input is divisible by the resulting prime
             ®p    # check if the last (d) is prime (true for all composite input)
               *   # multiply

Pyth，20个字节

<P_QiI.WtPHh+/ZKhPZK

在这里尝试！

怎么运行的

iI.WtPHh + / ZKhPZK || 完整程序。

  .W || 功能片刻。它使用两个函数作为参数A和B。
                 || 当A（值）为真时，将值转换为B（值）。的
                 || 起始值为输入。
    tPH || 第一个函数A。只有一个参数H。
     PH || .. H的主要因素。
    t || ..尾巴（删除第一个元素）。虽然真实（H是合成的）：
       h + / ZKhPZK || 第二个函数B。只有一个参数Z：
         / Z || ..用Z除以：
           KhP || ..它的最低素数，并将其分配给K。   
       h || .. 增量。
        + K || 并添加K。
我|| 检查结果（最后一个值）是否除以输入。

前4个字节（<P_Q）仅检查输入是否为素数。

在Emigna的帮助下，我设法节省了3个字节。

Python 3，149字节

def f(N):
	n=N;s=[0]*-~N
	for p in range(2,N):
		if s[p]<1:
			for q in range(p*p,N+1,p):s[q]=s[q]or p
	while s[n]:n=n//s[n]-~s[n]
	return s[N]>1>N%n

在线尝试！

使用筛子的方法。O(N log log N)即使很大N（也应该将O(N)整数存储在内存中），还是应该快（= Eratosthenes筛子的时间复杂度）

注意：

• 可以证明，的所有中间值n均不超过N，并且for N > 7 p可以位于range(2,N)而不是range(2,N+1)用于筛分。
• ///由于列表索引不起作用，必须使用。
• range不幸的是，存储到另一个变量中并没有帮助。

说明：

• -~N== N+1。
• 首先，将数组s初始化N+1为零（Python为0索引，因此索引为0..N）
• 初始化后，s[n]期望0if n是素数，p对于p除nif n是复合素的最小素数。s[0]和s[1]值并不重要。

• 对于p范围内的每个[2 .. N-1]：

  • 如果s[p] < 1（即s[p] == 0），然后p是一个素数，并且对于每个q被的倍数p和s[q] == 0，分配s[q] = p。

• 最后两行很简单，除了n//s[n]-~s[n]== (n // s[n]) + s[n] + 1。

Python 3，118字节

def f(N):
	n=N;s=[0]*-~N
	for p in range(N,1,-1):s[2*p::p]=(N-p)//p*[p]
	while s[n]:n=n//s[n]-~s[n]
	return s[N]>1>N%n

在线尝试！

以性能稍差为代价。（这需要O(N log N)时间复杂度，并假设Python切片的合理实现）

等效的完整程序为117个字节。

Haskell，110字节

f n|mod(product[1..n-1]^2)n>0=1<0|1>0=n`mod`u n<1
u n|d<-[i|i<-[2..],n`mod`i<1]!!0=last$n:[u$n`div`d+d+1|d/=n]

在线尝试！

不太开心...

八度，92字节

function r=f(n)k=n;while~isprime(k)l=2:k;d=l(~mod(k,l))(1);k=k/d+d+1;end;r=~mod(n,k)&k<n;end

在线尝试！

APL（Dyalog），50字节

{(0=n|⍵)∧⍵>n←{⍬≢k←o/⍨0=⍵|⍨o←2↓⍳⍵:∇1+d+⍵÷d←⌊/k⋄⍵}⍵}

在线尝试！

Japt，25个 24字节

我担心这可能会朝错误的方向发展，但是我已经没有时间去尝试其他方法了。

输出0为false或1true。

j ?V©vU :ßU/(U=k g)+°UNg

试试吧

Perl 5，291 + 1（-a）= 292字节

Darn Perl没有本地检查程序。

use POSIX;&r($_,$_);
sub p{$n=shift;if($n<=1){return;}if($n==2||$n==3){return 1;}if($n%2==0||$n%3==0){return;}for(5..ceil($n/2)){if($n%$_==0){return;}}return 1;}
sub r{$n=shift;$o=shift;if(&p($n)){print $o%$n==0&&$n!=$o?1:0;last;}for(2..ceil($n/2)){if($n%$_==0){&r(($n/$_)+$_+1, $o);last;}}}

非高尔夫版本，

use POSIX;
&r($_,$_);
sub p{
    my $n=shift;
    if($n<=1){
        return;
    }
    if($n==2||$n==3){
        return 1;
    }
    if($n%2==0||$n%3==0){
        return;
    }
    for(5..ceil($n/2)){
        if($n%$_==0){
            return;
        }
    }
    return 1;
}
sub r{
    my $n=shift;
    my $o=shift;
    if(&p($n)){
        print $o%$n==0&&$n!=$o ? 1 : 0;
        last;
    }
    for(2..ceil($n/2)){
        if($n%$_==0){
            &r(($n/$_)+$_+1, $o);
            last;
        }
    }
}

在线尝试！

Wolfram语言（Mathematica），64字节

使用递归模式替换的直接实现

（将“ \ [Divides]”替换为“]”符号可节省7个字节）

(g=!PrimeQ@#&)@#&&(#//.x_/;g@x:>x/(c=Divisors[x][[2]])+c+1)\[Divides]#&

在线尝试！

干净，128个 117 114字节

import StdEnv
@n#v=hd[p\\p<-[2..]|and[gcd p i<2\\i<-[2..p-1]]&&n rem p<1]
|v<n= @(n/v+v+1)=n
?n= @n<n&&n rem(@n)<1

在线尝试！

J，35个字节

(~:*0=|~)(1+d+]%d=.0{q:)^:(0&p:)^:_

在线尝试！

最小除数是第一个主要因素，它是从@Dennis的Jelly解决方案中偷走的（以前我在使用<./@q:）。

应该有更好的方法来进行迭代，但是我似乎找不到它。我曾想避免进行素数测试（^:(0&p:)），而是使用negative，但这似乎会更长一些，因为您需要a _2{和一些更改，而这些更改可能不会带来净减少。

我真的觉得必须也有一种方法可以避免对素数检查的宽恕。

说明（扩展）

(~: * 0 = |~)(1 + d + ] % d =. 0 { q:) ^: (0&p:) ^:_ Input: N
             (1 + d + ] % d =. 0 { q:) ^: (0&p:) ^:_ Find the final N'
                                       ^:        ^:_  Do while
                                           0&p:       N is not prime
                                   q:                 Get prime factors (in order)
                               0 {                    Take first (smallest divisor)
                          d =.                        Assign this value to d
             1 + d + ] %  d                           Compute (N/d) + 1 + d
(~: * 0 = |~)                                        Is it redivosite?
      0 = |~                                          N = 0 (mod N'), i.e. N'|N
    *                                                 And
 ~:                                                   N =/= N', i.e. N is not prime

APL NARS，43个字符，85个字节

{(⍵≤6)∨0π⍵:0⋄⍵{1=⍴t←π⍵:0=⍵|⍺⋄⍺∇1+↑t+⍵÷↑t}⍵}

（希望对于所有> 6的数字都收敛）测试：

h←{(⍵≤6)∨0π⍵:0⋄⍵{1=⍴t←π⍵:0=⍵|⍺⋄⍺∇1+↑t+⍵÷↑t}⍵}
v←⍳100     
v,¨h¨v
   1 0  2 0  3 0  4 0  5 0  6 0  7 0  8 0  9 0  10 0  11 0
   12 0  13 0  14 1  15 0  16 0  17 0  18 0  19 0  20 0  
   21 0  22 0  23 0  24 0  25 0  26 0  27 0  28 0  29 0  
   30 0  31 0  32 0  33 0  34 0  35 0  36 0  37 0  38 0  
   39 0  40 0  41 0  42 1  43 0  44 1  45 0  46 0  47 0  
   48 0  49 1  50 0  51 0  52 0  53 0  54 0  55 0  56 0  
   57 0  58 0  59 0  60 0  61 0  62 0  63 0  64 0  65 0  
   66 1  67 0  68 0  69 0  70 1  71 0  72 0  73 0  74 0  
   75 0  76 0  77 0  78 0  79 0  80 0  81 0  82 0  83 0  
   84 0  85 0  86 0  87 0  88 0  89 0  90 0  91 0  92 0  
   93 0  94 0  95 0  96 0  97 0  98 0  99 0  100 0  

我使用其他2个Apl解决方案的想法使用了2个匿名函数。

 {(⍵≤60)∨π⍵:0⋄ -- if arg ⍵ is prime or <=6 return 0
  ⍵{1=⍴t←π⍵:0=⍵|⍺⋄ -- if list of factors ⍵ has length 1 (it is prime)
                    -- then return ⍺mod⍵==0
  ⍺∇1+↑t+⍵÷↑t}⍵}   -- else recall this function with args ⍺ and 1+↑t+⍵÷↑t

Pyt，44 字节

←⁻0`ŕ⁺ĐĐϼ↓Đ3Ș⇹÷+⁺Đṗ¬⇹⁻⇹łŕáĐ0⦋Đ↔ĐŁ⁻⦋⁺|¬⇹ṗ⇹3Ș⊽

请参阅下面的代码以获取解释-唯一的区别是（1）在循环开始之前将N递减以说明增量，以及（2）使用NOR而不是OR。

在线尝试！

在重新阅读问题之前，我先做了这个，然后注意到它只想要是非题。

Pyt，52个字节

60`ŕ⁺ĐĐϼ↓Đ3Ș⇹÷+⁺Đṗ¬⇹⁻⇹łŕáĐ0⦋Đ↔ĐŁ⁻⦋⁺|¬⇹Đṗ⇹3Ș∨ł⇹Đƥ⇹ŕ1ł

打印无限个Redivosite数字列表。

说明：

6                                                            Push 6
 0                                                           Push unused character
  `                   ł                     ł      ł         Return point for all three loops
   ŕ                                                         Remove top of stack
    ⁺                                                        Increment top of stack (n)
     ĐĐ                                                      Triplicate top of stack (n)
       ϼ↓                                                    Get smallest prime factor of n (returns 1 if n is prime) 
         Đ                                                   Duplicate top of stack
          3Ș⇹                                                Manipulate stack so that the top is (in descending order): [d,(N,N'),d]
             ÷+⁺                                             Calculates N'=(N,N')/d+d+1
                Đṗ¬                                          Is N' not prime?
                   ⇹⁻⇹                                       Decrement N' (so the increment at the beginning doesn't change the value), and keep the boolean on top - end of innermost loop (it loops if top of stack is true)
                       ŕ                                     Remove top of stack
                        á                                    Convert stack to array
                         Đ                                   Duplicate array
                          0⦋Đ                                Get the first element (N)
                             ↔ĐŁ⁻⦋                           Get the last element ((final N')-1)
                                  ⁺                          Increment to get (final N')
                                   |¬                        Does N' not divide N?
                                     ⇹Đṗ                     Is N prime?
                                        ⇹3Ș∨                 Is N prime or does N' not divide N? - end of second loop (loops if top of stack is true)
                                             ⇹Đƥ⇹ŕ           Print N, and reduce stack to [N]
                                                  1          Push garbage (pushes 1 so that the outermost loop does not terminate)

在线尝试！