Giriş

Aşağıdaki gibi tanımlanan bir f tamsayı dizisini düşünün :

1. f (2) = 2
2. Eğer n, o zaman bir tek asal olduğu (n) r = (r (n-1) + f (n + 1)) / 2
3. Eğer , n = p · q , sonra kompozit f (n) = f (s) · r (k)

Her n ≥ 2 için f (n) = n olduğunu görmek çok zor değil ve bu nedenle f'yi hesaplamak çok ilginç bir zorluk olmayacak. Tanım için bir bükülme yapalım: ilk vakayı yarıya ve ikinci vakayı ikiye katlayın. Aşağıdaki gibi tanımlanan yeni bir g dizisi elde ediyoruz :

1. g (2) = 1
2. Eğer n, o zaman bir tek asal olduğu , g (n) = g (n-1) + g (n + 1)
3. Eğer , n = p · q , sonra kompozit , g (n) = gr (p)-g (q)

Görev

Göreviniz girdi olarak n ≥ 2 tamsayısını almak ve çıktı olarak g (n) üretmek . Tamsayı taşması konusunda endişelenmenize gerek yok, ancak g (1025) = 81 hesaplayabilmeniz gerekir doğru bir şekilde ve algoritmanız teorik olarak keyfi olarak büyük girdiler için çalışmalıdır.

Tam bir program veya işlev yazabilirsiniz. En düşük bayt sayısı kazanır.

Misal

Yukarıda g (1025) = 81 olduğunu iddia ettim , bu yüzden elle hesaplayalım. Asal çarpanlara 1025 verir

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

Yana 41 asal, biz olsun

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

Ardından, 40 ve 42'nin birincil çarpanlarına ayırma işlemlerini hesaplıyoruz :

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)

Bu küçük asallar için

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

Bunun anlamı şudur ki

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

ve

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

Test senaryoları

İşte g'nin 50'ye kadar değerleri .

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 bayt

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)

Kullanım örneği: (#2) 1025->81

Parametre abölünene xya da x(yani xasal olana) kadar sayılır . Bunu test etmek için bir byte daha kısa a > xve daha durum (ekleme a < xyerine için test modülü test) a == x, önceki bağlar nedeniyle aiçin x+1yinelemeli çağrı yardımcı olur. Karşılaştırmak:

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

Jöle , 18 bayt

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

Çevrimiçi deneyin!

Bu temel olarak spesifikasyonun doğrudan bir çevirisidir. (Biraz düşündükten sonra, diziyi bulmak için kapalı bir formül varsa, doğrudan yaklaşımdan daha fazla bayt olacağını sanıyorum.)

açıklama

Karşılıklı iki özyineli fonksiyonumuz var. Yardımcı fonksiyon ( asal n için g (n) değerini hesaplar ):

‘;’Ñ€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.

Ve işte, herhangi bir n için g (n) hesaplayan ana program :

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

Açıkçası, ana programı asal bir sayı olarak çağırırsak, her şey bir no-op dışındadır Ç, bu nedenle bu durumda g (n) döndürür . Programın geri kalanı kompozit n için davranışı ele alır .

JavaScript (ES6), 59 bayt

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

Ölçek

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 bayt

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)

Jöle , 13 bayt

Æfḟ2µ‘,’߀€SP

Çevrimiçi deneyin!

Nasıl çalışır

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

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

Yaşasın! Python'un cevabından neredeyse iki kat daha uzun!

Ungolfed ve bir açıklama:

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

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

Bir tamsayı döndüren bir pozitif tamsayı bağımsız değişkeninin adsız özyinelemeli işlevi. Sonunda o kadar da kısa değil. Tr[#0/@({#-1,#+1}/2)](girişin asal olması durumunda), sipariş edilen çiftin her iki üyesindeki işlevi çağırır {(#-1)/2,(#+1)/2}ve sonuçları ekler; fonksiyon aynı değere sahip olduğundan, bu ince (#-1)/2ve #-1örneğin. Benzer şekilde, 1##&@@#0/@Divisors@#~Part~{2,-2}işlevi en küçük ikinci bölen #ve onun tamamlayıcı böleninde (ikinci larget bölen) çağırır ve cevapları bir araya getirir.

Clojure, 120 bayt

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

Kullanımları :whenait bölenler almak için n, Folan nilböyle bir bölen bulunursa ( nasal).

Python 2 , 62 bayt

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)

Çevrimiçi deneyin!