एक तुच्छ अनुक्रम का एक मोड़

Question

परिचय

पूर्णांकों का एक दृश्य पर विचार च परिभाषित इस प्रकार है:

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)

यह देखना बहुत मुश्किल नहीं है कि हर n and 2 के लिए f (n) = n , और इस तरह से कंप्यूटिंग 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 is 2 को इनपुट के रूप में लेना है, और आउटपुट के रूप में g (n) का उत्पादन करना है। आपको पूर्णांक अतिप्रवाह के बारे में चिंता करने की ज़रूरत नहीं है, लेकिन आपको जी (1025) = 81 को सही ढंग से गणना करने में सक्षम होना चाहिए , और आपके एल्गोरिथ्म को सैद्धांतिक रूप से बड़े इनपुट के लिए काम करना चाहिए।

आप एक पूर्ण कार्यक्रम या एक फ़ंक्शन लिख सकते हैं। सबसे कम बाइट गिनती जीतती है।

उदाहरण

मैंने उस जी (1025) = 81 से ऊपर का दावा किया है , तो चलो इसे हाथ से गणना करते हैं। 1025 का मुख्य कारक है

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)

इन छोटे primes के लिए हम प्राप्त करते हैं

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

Comments

एरीली A002487 के समान है , और अभी तक (अलग नहीं है 15, 21, 25, 29, 33, 41, और एक गुच्छा अधिक है, लेकिन मैं किसी भी पैटर्न को क्यों नहीं पा सकता हूं।)

— गेब्रियल बेनामी

@GabrielBenamy ठीक है, मेरा अनुक्रम भी संतुष्ट करता है a(2*n) = a(n), और a(2*n+1) = a(n) + a(n+1)अगर 2*n+1प्रधान है तो रखती है। कई अन्य विषम संख्याओं के लिए, अनुक्रम शायद संयोग से सहमत हैं।

— जर्गब

क्या 1 स्वीकार्य के बजाय सच लौट रहा है?

— डेनिस

@ चुनौती एक संख्यात्मक कार्य का मूल्यांकन करने के बारे में है, निर्णय समस्या नहीं है, इसलिए मैं नहीं मानूंगा।

— पावेल

@ पावेल के पक्ष में भारी समर्थन है , हालांकि, कम से कम पाइथन में, सभी इरादों और उद्देश्यों के लिए सच्चा 1 जैसा कार्य करता है।

— डेनिस

Answer 1

हास्केल, 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=

Answer 2

जेली , 18 बाइट्स

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

इसे ऑनलाइन आज़माएं!

यह मूल रूप से विनिर्देशन का सीधा अनुवाद है। (इसके बारे में थोड़ा सोचने के बाद, मुझे संदेह है कि यदि अनुक्रम को खोजने के लिए एक बंद सूत्र है, तो यह प्रत्यक्ष दृष्टिकोण के लिए अधिक बाइट्स होगा।)

व्याख्या

हमारे दो पारस्परिक रूप से पुनरावर्ती कार्य हैं। यहाँ हेल्पर फ़ंक्शन (जो प्राइम n के लिए g (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.

और यहाँ मुख्य कार्यक्रम है, जो किसी भी n के लिए g (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) देता है। कार्यक्रम के बाकी समग्र एन के लिए व्यवहार को संभालता है ।

Answer 3

जावास्क्रिप्ट (ईएस 6), 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));

Answer 4

पायथन 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)

Answer 5

जेली , 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.

Answer 6

क्लोजर, 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)))))))

वाह! यह पायथन जवाब के रूप में लंबे समय के रूप में लगभग दो बार है!

अनगुल्ड और एक स्पष्टीकरण:

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

Comments

अच्छा, मुझे नहीं पता था कि तुम कर सकते हो (.indexOf (for [...] ...) x)!

— निकोनिरह

वर्तमान 118 बाइट संस्करण के लिए 11 रिटर्न (t 1025), शायद यही ifहोना था :when? लेकिन फिर nthखाली सूची फेंकता है IndexOutOfBoundsException।

— निकोनिरह

@NikoNyrh हाँ, ऐसा नहीं होना चाहिए - मैंने भी इसका परीक्षण किया, और कोड अमान्य है। मूल संस्करण पर वापस लौट जाएगा।

— १०:५० बजे

Answer 7

मैथेमेटिका, 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}दूसरे सबसे छोटे भाजक #और उसके संगति भाजक (दूसरे-बड़े भाजक) पर कार्य को बुलाता है और उत्तर को एक साथ गुणा करता है।

Comments

अनाम पुनरावर्ती कार्य कैसे कार्य करते हैं?

— पावेल

इस उत्तर के बारे #0में अनुभाग देखें ।

— ग्रेग मार्टिन

Answer 8

क्लोजर, 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की divisors प्राप्त करने के लिए n, Fहै nil, तो ऐसी कोई भाजक पाया जाता है ( nप्रधानमंत्री) है।

Comments

क्या आप झगड़ा करना चाहते हैं, सर? चालू है। (दोस्ताना प्रतियोगिता?)

— clismique

Answer 9

पायथन 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)

इसे ऑनलाइन आज़माएं!