_{Redivổng là một từ portmanteau được phát minh cho mục đích duy nhất của thách thức này. Đó là sự pha trộn của Giảm, Phân chia và Kết hợp.}

Định nghĩa

Cho một số nguyên N> 6 :

• Nếu N là số nguyên tố, N không phải là Số Redivozit.
• Nếu N là hợp số:
  • lặp đi lặp lại tính N '= N / d + d + 1 cho đến khi N' là số nguyên tố, trong đó d là ước số nhỏ nhất của N lớn hơn 1
  • N là số Redivozit khi và chỉ khi giá trị cuối cùng của N ' là ước của N

Dưới đây là 100 số Redivosite đầu tiên (không có mục OEIS tại thời điểm đăng):

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

Ví dụ

• N = 13 : 13 là số nguyên tố, vì vậy 13 không phải là Số quay lại
• N = 32 : 32/2 + 3 = 19; 19 không phải là số chia hay 32, vì vậy 32 không phải là số Redivosite
• N = 260 : 260/2 + 3 = 133, 133/7 + 8 = 27, 27/3 + 4 = 13; 13 là số chia hoặc 260, vì vậy 260 là số Redivosite

Nhiệm vụ của bạn

• Cho một số nguyên N , trả về giá trị trung thực nếu đó là Số Redivozit hoặc giá trị giả. (Bạn cũng có thể xuất bất kỳ hai giá trị riêng biệt nào, miễn là chúng phù hợp.)
• Đầu vào được đảm bảo lớn hơn 6 .
• Đây là môn đánh gôn , vì vậy câu trả lời ngắn nhất bằng byte sẽ thắng!

Haskell, 91 85 83 80 75 74 byte

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

Hãy thử trực tuyến!

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

Chỉnh sửa: -2 byte nhờ @BMO, -3 byte nhờ @ H.PWiz và -5 -6 byte nhờ @ rjan Johansen

Husk , 14 byte

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

Hãy thử trực tuyến!

-3 cảm ơn H.PWiz .

C (gcc) , 94 89 byte

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

Hãy thử trực tuyến!

Giải trình

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

Thạch , 14 byte

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

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

ÆḌḊ         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 byte

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

Hãy thử trực tuyến!

Đầu ra thông qua mã thoát.

Ung dung:

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.

Hãy thử trực tuyến!

05AB1E , 17 16 byte

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

Hãy thử trực tuyến!

Giải trình

[                  # 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

Bình thường , 20 byte

<P_QiI.WtPHh+/ZKhPZK

Hãy thử nó ở đây!

Làm thế nào nó hoạt động

iI.WtPHh + / ZKhPZK | | Chương trình đầy đủ.

  .W | | Chức năng trong khi. Nó có hai chức năng là đối số, A và B.
                 | | Trong khi A (giá trị) là trung thực, biến giá trị thành B (giá trị). Các
                 | | giá trị bắt đầu là đầu vào.
    tPH | | Hàm đầu tiên, A. Đưa ra một đối số duy nhất, H.
     PH | | .. Các yếu tố chính của H.
    t | | .. Đuôi (loại bỏ yếu tố đầu tiên). Trong khi sự thật (H là hợp chất):
       h + / ZKhPZK | | Hàm thứ hai, B. Đưa ra một đối số duy nhất, Z:
         / Z | | .. Chia Z, cho:
           KhP | | .. Hệ số nguyên tố thấp nhất của nó và gán nó cho K.   
       h | | .. Tăng.
        + K | | Và thêm K.
tôi | | Kiểm tra xem kết quả (giá trị cuối cùng) chia đầu vào.

Và 4 byte đầu tiên ( <P_Q) chỉ cần kiểm tra xem đầu vào không phải là số nguyên tố.

Với sự giúp đỡ từ Emigna , tôi đã quản lý để tiết kiệm 3 byte.

Python 3 , 149 byte

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

Hãy thử trực tuyến!

Sử dụng phương pháp sàng. Phải nhanh ( O(N log log N)= độ phức tạp thời gian của sàng Eratosthenes) ngay cả với số lượng lớn N(nhưng lưu trữ O(N)số nguyên trong bộ nhớ)

Chú thích:

• Có thể chứng minh rằng tất cả các giá trị trung gian nkhông vượt quá N, và N > 7 pcó thể range(2,N)thay vì range(2,N+1)sàng.
• /không hoạt động, //phải được sử dụng, vì chỉ mục danh sách.
• Lưu trữ rangevào một biến khác không giúp đỡ, thật không may.

Giải trình:

• -~N== N+1.
• Lúc đầu, mảng sđược khởi tạo bằng N+10 (Python là 0-index, vì vậy các chỉ số là 0..N)
• Sau khi khởi tạo, s[n]dự kiến ​​là 0if nlà một số nguyên tố và pđối với psố nguyên tố tối thiểu sẽ chia nnếu nlà một tổng hợp. s[0]và s[1]các giá trị không quan trọng.

• Đối với mỗi ptrong phạm vi [2 .. N-1]:

  • Nếu s[p] < 1(đó là, s[p] == 0), thì plà một số nguyên tố và với mỗi số qlà bội số của pvà s[q] == 0, gán s[q] = p.

• 2 dòng cuối cùng là đơn giản, ngoại trừ đó n//s[n]-~s[n]== (n // s[n]) + s[n] + 1.

Python 3 , 118 byte

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

Hãy thử trực tuyến!

Với chi phí hiệu suất kém hơn một chút. (Cái này chạy trong O(N log N)độ phức tạp thời gian, giả sử thực hiện hợp lý các lát Python)

Chương trình đầy đủ tương đương là 117 byte .

Haskell , 110 byte

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]

Hãy thử trực tuyến!

Không được vui lắm...

Octave , 92 byte

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

Hãy thử trực tuyến!

APL (Dyalog) , 50 byte

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

Hãy thử trực tuyến!

Japt, 25 24 byte

Tôi sợ rằng tôi có thể đã đi sai hướng với điều này nhưng tôi đã hết thời gian để thử một cách tiếp cận khác.

Đầu ra 0cho sai hoặc 1đúng.

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

Thử nó

Perl 5 , 291 + 1 (-a) = 292 byte

Darn Perl vì không có trình kiểm tra chính gốc.

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

Phiên bản bị đánh cắp,

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

Hãy thử trực tuyến!

Ngôn ngữ Wolfram (Mathicala) , 64 byte

Thực hiện đơn giản bằng cách sử dụng thay thế mẫu đệ quy

(thay thế "\ [Chia]" bằng biểu tượng "" tiết kiệm 7 byte)

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

Hãy thử trực tuyến!

Sạch , 128 117 114 byte

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

Hãy thử trực tuyến!

J , 35 byte

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

Hãy thử trực tuyến!

Số chia tối thiểu là yếu tố chính đầu tiên đã bị đánh cắp từ giải pháp Jelly của @ Dennis (trước đây tôi đang sử dụng <./@q:).

Có một cách tốt hơn để thực hiện việc lặp lại, nhưng tôi dường như không thể tìm thấy nó. Tôi đã nghĩ đến việc tránh làm bài kiểm tra nguyên thủy ( ^:(0&p:)) và thay vào đó là sử dụng bất lợi nhưng có vẻ như điều đó sẽ lâu hơn một chút vì bạn sẽ cần một _2{số thay đổi có thể không làm giảm mạng.

Tôi thực sự cảm thấy như phải có một cách để tránh có parens xung quanh việc kiểm tra tính nguyên thủy.

Giải thích (mở rộng)

(~: * 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 ký tự, 85 byte

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

(hy vọng rằng nó hội tụ cho tất cả số> 6) kiểm tra:

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  

Ý tưởng sử dụng 2 hàm ẩn danh tôi có được giải pháp Apl khác.

 {(⍵≤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 byte

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

Xem mã dưới đây để được giải thích - sự khác biệt duy nhất là (1) rằng N được giảm trước đó để tính toán mức tăng ở đầu vòng lặp và (2) nó sử dụng NOR thay vì OR.

Hãy thử trực tuyến!

Tôi đã thực hiện điều này trước khi đọc lại câu hỏi và nhận thấy rằng nó chỉ muốn đúng / sai.

Pyt, 52 byte

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

In một danh sách vô hạn các số Redivozit.

Giải trình:

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)

Hãy thử trực tuyến!