บทนำ

พิจารณาลำดับของจำนวนเต็มf ที่กำหนดดังนี้:

1. f (2) = 2
2. ถ้าnเป็นไพรม์ที่แปลก f (n) = (f (n-1) + f (n + 1)) / 2
3. ถ้าn = p · qประกอบกันดังนั้นf (n) = f (p) · f (q)

ไม่ยากมากที่จะเห็นว่าf (n) = nสำหรับทุก ๆn ≥ 2และดังนั้นการคำนวณfจึงไม่ใช่เรื่องท้าทายที่น่าสนใจมาก ลองทำตามคำจำกัดความ: แบ่งครึ่งแรกของเคสออกเป็นสองเท่า เราได้ลำดับใหม่g ที่นิยามดังนี้:

1. g (2) = 1
2. ถ้าnเป็นจำนวนคี่ที่แปลกดังนั้นg (n) = g (n-1) + g (n + 1)
3. ถ้าn = p · qเป็นคอมโพสิตแล้ว g (n) = g (p) · g (q)

งาน

งานของคุณคือการใช้จำนวนเต็มn ≥ 2เป็นอินพุตและสร้างg (n)เป็นเอาต์พุต คุณไม่ต้องกังวลเกี่ยวกับจำนวนเต็มล้น แต่คุณควรจะสามารถคำนวณg (1025) = 81ได้อย่างถูกต้องและอัลกอริทึมของคุณควรทำงานในทางทฤษฎีสำหรับอินพุตที่มีขนาดใหญ่ตามอำเภอใจ

คุณสามารถเขียนโปรแกรมเต็มรูปแบบหรือฟังก์ชั่น จำนวนไบต์ต่ำสุดชนะ

ตัวอย่าง

ฉันอ้างว่าg (1025) = 81ดังนั้นลองคำนวณด้วยมือ การแยกตัวประกอบเฉพาะของ1,025ให้

1025 = 5*5*41 => g(1025) = g(5)*g(5)*g(41)

เนื่องจาก41เป็นสิ่งสำคัญเราได้รับ

g(41) = g(40) + g(42)

ต่อไปเราคำนวณค่าแฟคตอเรชันที่สำคัญของ40และ42 :

40 = 2*2*2*5 => g(40) = g(2)*g(2)*g(2)*g(5) = g(5)
42 = 2*3*7 => g(42) = g(2)*g(3)*g(7) = g(3)*g(7)

สำหรับช่วงเวลาเล็กน้อยเหล่านี้เราได้รับ

g(3) = g(2) + g(4) = 1 + 1 = 2
g(5) = g(4) + g(6) = 1 + 2 = 3
g(7) = g(6) + g(8) = 2 + 1 = 3

ซึ่งหมายความว่า

g(41) = g(40) + g(42) = g(5) + g(3)*g(7) = 3 + 2*3 = 9

และ

g(1025) = g(5)*g(5)*g(41) = 3*3*9 = 81

กรณีทดสอบ

นี่คือคุณค่าของการเป็นกรัมถึง50

2 -> 1
3 -> 2
4 -> 1
5 -> 3
6 -> 2
7 -> 3
8 -> 1
9 -> 4
10 -> 3
11 -> 5
12 -> 2
13 -> 5
14 -> 3
15 -> 6
16 -> 1
17 -> 5
18 -> 4
19 -> 7
20 -> 3
21 -> 6
22 -> 5
23 -> 7
24 -> 2
25 -> 9
26 -> 5
27 -> 8
28 -> 3
29 -> 9
30 -> 6
31 -> 7
32 -> 1
33 -> 10
34 -> 5
35 -> 9
36 -> 4
37 -> 11
38 -> 7
39 -> 10
40 -> 3
41 -> 9
42 -> 6
43 -> 11
44 -> 5
45 -> 12
46 -> 7
47 -> 9
48 -> 2
49 -> 9
50 -> 9

Haskell, 69 ไบต์

x#a|x<3=1|a>x=a#2+(x-1)#2|mod x a<1,a<x=a#2*div x a#2|b<-a+1=x#b
(#2)

ตัวอย่างการใช้งาน: (#2) 1025 ->81

พารามิเตอร์aจะถูกนับขึ้นจนกว่าจะหารxหรือถึงx(เช่นxเป็นค่าเฉพาะ) มันสั้นลงหนึ่งไบต์ในการทดสอบa > xและเพิ่มเงื่อนไขเพิ่มเติม ( a < x) ในการทดสอบโมดูลัสแทนการทดสอบa == xเพราะก่อนหน้านี้ผูกaกับx+1ซึ่งจะช่วยในการโทรซ้ำ เปรียบเทียบ:

|a==x=(x+1)#2+(x-1)#2|mod x a<1=
|a>x=a#2+(x-1)#2|mod x a<1,a<x=

เยลลี่ขนาด 18 ไบต์

‘;’Ñ€Sµ1n2$?
ÆfÇ€P

ลองออนไลน์!

นี่เป็นเพียงการแปลโดยตรงของข้อกำหนด (หลังจากคิดไปเล็กน้อยผมสงสัยว่าถ้ามีสูตรปิดเพื่อค้นหาลำดับมันจะเป็นไบต์มากกว่าวิธีเข้าโดยตรง)

คำอธิบาย

เรามีสองฟังก์ชันแบบเรียกซ้ำ นี่คือฟังก์ชันตัวช่วย (ซึ่งคำนวณg (n)สำหรับ prime n ):

‘;’Ñ€Sµ1n2$?
           ?  If
        n2$     the input is not equal to 2 (parsed as a group due to $)
      µ       then do all the following (parsed as a group due to µ):
‘;’             Find the list [n+1, n-1];
   р           Call the main program on each element (i.e. [g(n+1),g(n-1)]);
     S          and return the sum of the list (i.e. g(n+1)+g(n-1)).
              Otherwise:
       1        Return 1.

และนี่คือโปรแกรมหลักซึ่งคำนวณg (n)สำหรับnใด ๆ:

ÆfÇ€P
Æf            Factorize the input into its prime factors;
  ǀ          Call the helper function on each element of that list;
    P         Then take the product.

เห็นได้ชัดว่าถ้าเราเรียกโปรแกรมหลักเป็นจำนวนเฉพาะทุกอย่างจะไม่มีตัวเลือกยกเว้นÇดังนั้นมันจะส่งกลับg (n)ในกรณีนี้ ส่วนที่เหลือของโปรแกรมจัดการพฤติกรรมสำหรับคอมโพสิตn

JavaScript (ES6), 59 ไบต์

f=(n,d=2)=>n-2?d<n?n%d?f(n,d+1):f(n/d)*f(d):f(n-1)+f(n+1):1

ทดสอบ

f=(n,d=2)=>n-2?d<n?n%d?f(n,d+1):f(n/d)*f(d):f(n-1)+f(n+1):1

// f(2) to f(50)
for(N = 2, list = []; N <= 50; N++) {
  list.push(N + ' -> ' + f(N));
}
console.log(list.join(', '));

// f(1025)
console.log(f(1025));

Python 2, 85 69 ไบต์

g=lambda n,k=3:(n&~-n<1)or n%k and g(n,k+2)or(g(k+1)+g(k-1))*g(n/k,k)

เยลลี่ 13 ไบต์

Æfḟ2µ‘,’߀€SP

ลองออนไลน์!

มันทำงานอย่างไร

Æfḟ2µ‘,’߀€SP  Main link. Argument: n

Æf             Yield the array of prime factors of n.
  ḟ2           Remove all occurrences of 2.
    µ          Begin a new, monadic chain. Argument: A (array of odd prime factors)
     ‘         Increment all elements of A.
       ’       Decrement all elements of A.
      ,        Pair; yield [A+1, A-1].
        ߀€    Map the main link over all elements of A+1 and A-1.
           S   Column-wise reduce by addition.
            P  Reduce by multiplication.

Clojure, 126 ไบต์

(defn t[n](if(= n 2)1(let[a(+(.indexOf(for[b(range 2 n)](mod n b)2)0))](if(> a 1)(*(t(/ n a))(t a))(+(t(dec n))(t(inc n)))))))

เย้! มันเกือบเป็นสองเท่าตราบเท่าที่คำตอบของ Python!

Ungolfed และคำอธิบาย:

(defn trivial [n]
  ; Define the function.
  (if (= n 2) 1
  ; If the number is 2, return 1
    (let [a (+ 2 (.indexOf (for [b (range 2 n)] (mod n b)) 0))]
      ; Let a be the lowest prime factor of n
      (if (> a 1)
        ; The .indexOf function returns -1 if a is a prime, so -1 + 2 = 1.
        ; Checks if a is a prime.
        (* (trivial (/ n a)) (trivial a))
        ; If a is prime, return the trivial(a/n) * trivial(a).
        (+ (trivial (dec n)) (trivial (inc n)))))))
        ; Else, return trivial(n-1) + trivial(n + 1).

Mathematica, 83 ไบต์

Which[#<4,#-1,PrimeQ@#,Tr[#0/@({#-1,#+1}/2)],0<1,1##&@@#0/@Divisors@#~Part~{2,-2}]&

ฟังก์ชันเรียกซ้ำของอาร์กิวเมนต์จำนวนเต็มบวกหนึ่งรายการคืนค่าจำนวนเต็ม ไม่ใช่ว่าจะสั้นทั้งหมดในที่สุด Tr[#0/@({#-1,#+1}/2)](ในกรณีที่มีการป้อนข้อมูลเป็นสำคัญ) เรียกฟังก์ชันสมาชิกทั้งคู่สั่ง{(#-1)/2,(#+1)/2}และเพิ่มผล; นี่เป็นเรื่องปกติเนื่องจากฟังก์ชั่นมีค่าเหมือนกันที่(#-1)/2และ#-1ตัวอย่างเช่น ในทำนองเดียวกันการ1##&@@#0/@Divisors@#~Part~{2,-2}เรียกใช้ฟังก์ชันบนตัวหารที่เล็กที่สุดที่สอง#และตัวหาร complememtary (ตัวหารที่สองที่ใหญ่กว่า) และคูณคำตอบด้วยกัน

Clojure, 120 ไบต์

(defn g[n](if(= n 2)1(if-let[F(first(for[i(range 2 n):when(=(mod n i)0)]i))](*(g F)(g(/ n F)))(+(g(dec n))(g(inc n))))))

การใช้ประโยชน์:whenที่จะได้รับตัวหารของn, Fคือnilหากไม่มีการหารดังกล่าวจะพบ ( nเป็นสำคัญ)

Python 2 , 62 ไบต์

f=lambda n,k=3:k>n or n%k and f(n,k+2)or(f(k-1)+f(k+1))*f(n/k)

ลองออนไลน์!