_{Redivosite เป็นคำของกระเป๋าเดินทางที่คิดค้นขึ้นเพื่อจุดประสงค์เดียวของการท้าทายนี้ มันเป็นส่วนผสมของการลดการหารและการประกอบ}

คำนิยาม

รับจำนวนเต็มN> 6 :

• ถ้าNเป็นไพรม์, Nไม่ใช่หมายเลข Redivosite
• ถ้าNเป็นคอมโพสิต:
  • คำนวณซ้ำ'N = N / d + d + 1จนกระทั่งN'เป็นไพรม์โดยที่dคือตัวหารที่เล็กที่สุดของNมากกว่า 1
  • Nคือหมายเลข Redivosite หากค่าสุดท้ายของN 'เป็นตัวหารของ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 Number

งานของคุณ

• รับค่าNจำนวนเต็มส่งคืนค่าความจริงหากเป็นจำนวน Redivosite หรือค่าที่ผิดพลาดเป็นอย่างอื่น (นอกจากนี้คุณยังสามารถแสดงผลค่าสองค่าที่แตกต่างกันได้ตราบใดที่ค่าเหล่านั้นสอดคล้องกัน)
• การป้อนข้อมูลที่รับประกันได้ว่าจะมีขนาดใหญ่กว่า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

แก้ไข: -2 ไบต์ขอบคุณ @BMO, ขอบคุณ -3 ไบต์ถึง @ H.PWiz และ-5 -6 ไบต์ขอบคุณ @ Ørjan Johansen

Husk , 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

ลองออนไลน์!

ส่งออกผ่านรหัสทางออก

Ungolfed:

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 || .. ปัจจัยสำคัญของเอช
    t | | .. ก้อย (ลบองค์ประกอบแรก) ในขณะที่ความจริง (H เป็นแบบประกอบ):
       h + / ZKhPZK || ฟังก์ชั่นที่สอง B. รับอาร์กิวเมนต์เดี่ยว Z:
         / Z || .. หาร Z โดย:
           KhP || .. มันเป็นปัจจัยที่สำคัญที่สุดและมอบหมายให้เค   
       h | | .. เพิ่มขึ้น
        + K || และเพิ่มเค
iI || ตรวจสอบว่าผลลัพธ์ (ค่าสุดท้าย) แบ่งอินพุตหรือไม่

และ 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)= เวลาที่ซับซ้อนของตะแกรง Eratosthenes) แม้จะมีขนาดใหญ่N(แต่เก็บO(N)จำนวนเต็มในหน่วยความจำ)

บันทึก:

• มันสามารถพิสูจน์ได้ว่าค่ากลางทั้งหมดของnไม่เกินNและสำหรับN > 7 pสามารถอยู่ในrange(2,N)แทนrange(2,N+1)การกรอง
• /ไม่ทำงาน//ต้องใช้เพราะรายการดัชนี
• การจัดเก็บrangeตัวแปรอื่นไม่ได้ช่วย

คำอธิบาย:

• -~NN+1==
• ในตอนแรกอาร์เรย์sจะเริ่มต้นด้วยN+1ศูนย์ (Python คือดัชนี 0 ดังนั้นดัชนีมี0..N)
• หลังจากการเตรียมใช้งานs[n]คาดว่าจะเป็น0ถ้าnเป็นนายกและpสำหรับpนายกรัฐมนตรีขั้นต่ำซึ่งแบ่งnถ้าnเป็นคอมโพสิต s[0]และs[1]คุณค่านั้นไม่สำคัญ

• สำหรับแต่ละpช่วง[2 .. N-1]:

  • ถ้าs[p] < 1(นั่นคือs[p] == 0) แล้วpเป็นนายกและสำหรับแต่ละqเป็นหลายของpและกำหนดs[q] == 0s[q] = p

• สุดท้าย 2 บรรทัดตรงไปตรงมายกเว้นว่า==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)เวลาที่ซับซ้อนถือว่าการใช้งานที่เหมาะสมของชิ้นงูหลาม)

เทียบเท่าโปรแกรมเต็มรูปแบบเป็น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ไบต์

ฉันกลัวว่าฉันอาจไปผิดทาง แต่ฉันหมดเวลาลองแนวทางอื่น

เอาต์พุต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:)^:_

ลองออนไลน์!

ตัวหารขั้นต่ำที่เป็นปัจจัยหลักตัวแรกถูกขโมยจากโซลูชัน Jelly ของ @ Dennis (ก่อนหน้านี้ฉันใช้อยู่<./@q:)

ควรมีวิธีที่ดีกว่าในการทำซ้ำ แต่ฉันไม่สามารถหามันได้ ฉันคิดว่าการหลีกเลี่ยงการทดสอบแบบดั้งเดิม ( ^:(0&p:)) และแทนที่จะใช้วิธีที่ไม่พึงประสงค์ แต่ดูเหมือนว่าจะนานกว่านี้เล็กน้อยเนื่องจากคุณจะต้องมี_2{การเปลี่ยนแปลงบางอย่างซึ่งอาจไม่ทำให้การลดลงสุทธิ

ฉันรู้สึกเหมือนว่าจะต้องมีวิธีที่จะหลีกเลี่ยง parens รอบการตรวจสอบ primality เกินไป

คำอธิบาย (ขยาย)

(~: * 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 อื่น

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

ลองออนไลน์!