Giới thiệu

Xét một chuỗi các số nguyên f được định nghĩa như sau:

1. f (2) = 2
2. Nếu n là số nguyên tố lẻ thì f (n) = (f (n-1) + f (n + 1)) / 2
3. Nếu n = p · q là hợp số, thì f (n) = f (p) · f (q)

Không khó để thấy rằng f (n) = n với mọi n ≥ 2 , và do đó, tính toán f sẽ không phải là một thử thách rất thú vị. Hãy thay đổi định nghĩa: giảm một nửa trường hợp đầu tiên và nhân đôi trường hợp thứ hai. Chúng tôi nhận được một chuỗi g mới được định nghĩa như sau:

1. g (2) = 1
2. Nếu n là số nguyên tố lẻ thì g (n) = g (n-1) + g (n + 1)
3. Nếu n = p · q là hợp số, thì g (n) = g (p) · g (q)

Nhiệm vụ

Nhiệm vụ của bạn là lấy số nguyên n ≥ 2 làm đầu vào và tạo g (n) làm đầu ra. Bạn không phải lo lắng về tràn số nguyên, nhưng bạn sẽ có thể tính toán g (1025) = 81 một cách chính xác và về mặt lý thuyết thuật toán của bạn sẽ hoạt động cho các đầu vào lớn tùy ý.

Bạn có thể viết một chương trình đầy đủ hoặc một chức năng. Số byte thấp nhất sẽ thắng.

Thí dụ

Tôi đã tuyên bố ở trên rằng g (1025) = 81 , vì vậy hãy tính toán bằng tay. Hệ số nguyên tố của 1025 cho

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

Vì 41 là số nguyên tố, chúng tôi nhận được

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

Tiếp theo, chúng tôi tính toán các thừa số nguyên tố của 40 và 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)

Đối với những số nguyên tố nhỏ này, chúng tôi nhận được

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

Điều này có nghĩa rằng

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

và

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

Các trường hợp thử nghiệm

Dưới đây là các giá trị của g lên tới 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 byte

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)

Ví dụ sử dụng: (#2) 1025->81

Tham số ađược tính lên cho đến khi nó chia xhoặc nó đạt x(tức xlà số nguyên tố). Nó ngắn hơn một byte để kiểm tra a > xvà thêm một điều kiện ( a < x) vào kiểm tra mô đun thay vì kiểm tra a == x, bởi vì trước đây liên kết avới x+1, giúp trong cuộc gọi đệ quy. Đối chiếu:

|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=

Thạch , 18 byte

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

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

Đây về cơ bản chỉ là một bản dịch trực tiếp của đặc điểm kỹ thuật. (Sau khi suy nghĩ về nó một chút, tôi nghi ngờ rằng nếu có một công thức khép kín để tìm chuỗi, nó sẽ có nhiều byte hơn so với cách tiếp cận trực tiếp.)

Giải trình

Chúng ta có hai hàm đệ quy lẫn nhau. Đây là hàm trợ giúp (tính g (n) cho số nguyên tố 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.

Và đây là chương trình chính, tính g (n) cho mọi 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.

Rõ ràng, nếu chúng ta gọi chương trình chính theo số nguyên tố, mọi thứ đều không có ngoại trừ Ç, vì vậy nó trả về g (n) trong trường hợp này. Phần còn lại của chương trình xử lý hành vi cho composite n .

JavaScript (ES6), 59 byte

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

Kiểm tra

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 byte

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)

Thạch , 13 byte

Æfḟ2µ‘,’߀€SP

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

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

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

(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)))))))

Yay! Nó dài gần gấp đôi câu trả lời của Python!

Ungolfed và một lời giải thích:

(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).

Toán học, 83 byte

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

Hàm đệ quy không tên của một đối số nguyên dương, trả về một số nguyên. Không phải tất cả mà ngắn, cuối cùng. Tr[#0/@({#-1,#+1}/2)](trong trường hợp đầu vào là số nguyên tố) gọi hàm trên cả hai thành viên của cặp được đặt hàng {(#-1)/2,(#+1)/2}và thêm kết quả; điều này là tốt vì hàm có cùng giá trị tại (#-1)/2và #-1, ví dụ. Tương tự, 1##&@@#0/@Divisors@#~Part~{2,-2}gọi hàm trên ước số nhỏ thứ hai #và ước số tương ứng của nó (ước số thứ hai) và nhân các câu trả lời lại với nhau.

Clojure, 120 byte

(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))))))

Sử dụng :whenđể có được ước số của n, Flà nilnếu không tìm thấy ước số đó ( nlà số nguyên tố).

Python 2 , 62 byte

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)

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