हार्मोनिक अनुक्रम का आंशिक योग!

13

परिभाषा

गणित में, हार्मोनिक अनुक्रम एक अनुक्रम को संदर्भित करता है जहां

हार्मोनिक अनुक्रम समीकरण

यानी n वें क्रम की अवधि के पारस्परिक के बराबर होती है n ।

परिचय

इस चुनौती में, इनपुट के रूप में एक सकारात्मक पूर्णांक n दिया गया, हार्मोनिक अनुक्रम के पहले n शब्दों के आंशिक योग को आउटपुट करता है ।

इनपुट

आपको एक सकारात्मक पूर्णांक दिया जाएगा (आपकी भाषा द्वारा समर्थित संख्याओं की सीमा के भीतर)। यह या तो हस्ताक्षरित और बिना हस्ताक्षर किए (आप पर निर्भर करता है) हो सकता है, क्योंकि चुनौती के लिए केवल सकारात्मक पूर्णांक की आवश्यकता होती है।

आप पूर्वनिर्धारित चर में मौजूद होने के अलावा किसी भी तरह से इनपुट ले सकते हैं। फ़ाइल, टर्मिनल, मोडल विंडो ( prompt()जावास्क्रिप्ट में) आदि से पढ़ने की अनुमति है। इनपुट को फ़ंक्शन तर्क के रूप में लेने की अनुमति है।

उत्पादन

आपके कार्यक्रम को 5 महत्वपूर्ण आंकड़ों की सटीकता के साथ एक फ्लोट (या पूर्णांक यदि आउटपुट समान रूप से 1 से विभाज्य है) के रूप में हार्मोनिक सीक्वेंस के पहले एन शब्दों का योग आउटपुट करना चाहिए , जहां एन इनपुट को संदर्भित करता है। गणितीय शब्दजाल में समान व्यक्त करने के लिए, आपको गणना करने की आवश्यकता है

पहली एन शब्दों के हार्मोनिक अनुक्रम आंशिक विवरण

जहाँ n इनपुट को संदर्भित करता है।

आप किसी वेरिएबल को आउटपुट लिखने के अलावा किसी भी तरह से आउटपुट दे सकते हैं। स्क्रीन, टर्मिनल, फ़ाइल, मोडल विंडो ( alert()जावास्क्रिप्ट में) आदि को लिखने की अनुमति है। फंक्शन returnवैल्यू के रूप में आउटपुट की अनुमति है।

अतिरिक्त नियम

परीक्षण के मामलों

परीक्षण मामले इनपुट को 1-अनुक्रमित मान लेते हैं

Input     Output
1         1
2         1.5
3         1.8333
4         2.0833
5         2.2833

जीत का मानदंड

यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे छोटा कोड जीत जाता है!

code-golf  math  sequence 
— अर्जुन
स्रोत
क्या आप हमें कुछ टेस्टकेस दे सकते हैं?
— user41805
2
क्या सटीकता की आवश्यकता है? सटीक आउटपुट आम तौर पर केवल एक अंश के रूप में संभव है, लेकिन कई भाषाओं में जिनमें अंश और हर के लिए अलग-अलग संख्याएँ होंगी। क्या हम आउटपुट a) फ्लोट, b) एक अंश या पूर्णांक युग्म c) या तो कर सकते हैं?
— लेवल रिवर सेंट
2
@ अर्जुन हार्मोनिक श्रृंखला अनंत तक बढ़ती है, इसलिए इसे 10 दशमलव स्थानों पर मिलना मुश्किल होगा क्योंकि संख्या हजारों और लाखों में हो जाती है। मैं दशमलव स्थानों के बजाय महत्वपूर्ण आंकड़ों के लिए जाऊंगा, और मुझे इतना सटीक होने की कोई आवश्यकता नहीं है। 5 महत्वपूर्ण आंकड़े पर्याप्त होना चाहिए। इसके 9.9999E10बजाय99999999999.9999999999
— लेवल रिवर सेंट
क्या हम 5 महत्वपूर्ण आंकड़ों पर जा सकते हैं?
— एग्री आउटलोफर
वैसे, यह ज्ञात है कि हार्मोनिक अनुक्रम में प्रारंभिक a_1 = 1. के अलावा कोई भी पूर्णांक नहीं है (आइडिया ऑफ प्रूफ कि a_n n> 1 के लिए पूर्णांक नहीं है: 2 ^ k 2 की सबसे बड़ी शक्ति से अधिक नहीं है n; फिर 2 ^ k भाजित a_n का विभाजन करता है।)
— ग्रेग मार्टिन

जवाबों:

9

पायथन 3, 27 बाइट्स

h=lambda n:n and 1/n+h(n-1)
— shooqie
स्रोत
0-इंडेक्सिंग या 1-इंडेक्सिंग?
— अर्जुन
2
RuntimeErrorपुनरावृत्ति सीमा से अधिक इनपुट को संभालने पर फेंकता है, डिफ़ॉल्ट रूप से 1000।
— sagiksp
आप कर सकते हैं sys.setrecursionlimit(473755252663)लेकिन ढेर अंततः बहुत आसानी से बह जाएगा
— बिल्ली
@ अर्जुन यह 1-अनुक्रमित है
— शुकी
8

जावास्क्रिप्ट, 19 18 बाइट्स

1 बाइट @RickHitchcock की बदौलत बचा

f=a=>a&&1/a+f(--a)

यह 1-अनुक्रमित है।

f=a=>a&&1/a+f(--a)

for(i=0;++i<10;)console.log(f(i))
स्निपेट का विस्तार करें

— user41805
स्रोत
जो मैंने अन्य पोस्ट के बारे में देखा है, उसमें से आप f=2 बाइट्स को बचाने के लिए अपने उत्तर से हटा सकते हैं ।
— रिक हिचकॉक
1
@RickHitchcock मैं हटा नहीं सकता f=क्योंकि फ़ंक्शन पुनरावर्ती है और यह स्वयं को संदर्भित करता है f(--a)। लेकिन अगर यह एक पुनरावर्ती समाधान नहीं था, तो मैं ऐसा करने में सक्षम था
— user41805
आह, समझ में आता है! एक बाइट के साथ सहेजें f=a=>a&&1/a+f(--a)।
— रिक हिचकॉक
@RickHitchcock अच्छा लगा!
— user41805
6

एपीएल (डायलॉग) , 5 बाइट्स

+/÷∘⍳

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

आप ⎕PP←{number}परिशुद्धता को बदलने के लिए शीर्ष लेख में जोड़ सकते हैं {number}।

यह 1-अनुक्रमित है।

व्याख्या

+/÷∘⍳                     Right argument; n
    ⍳                     Range; 1 2 ... n
  ÷                       Reciprocal; 1/1 1/2 ... 1/n
+/                        Sum; 1/1 + 1/2 + ... + 1/n
— user41805
स्रोत
6

गणितज्ञ, 21 20 16 बाइट्स

यह समाधान 1-अनुक्रमित है।

Sum[1./i,{i,#}]&
— J42161217
स्रोत
यह 1-इंडेक्सिंग है
— J42161217
1
> पहले n तत्वों के आंशिक योग की गणना करने के लिए आपको एक अंतर्निहित उपयोग नहीं करना चाहिए। (हाँ, यह आपके लिए है गणितज्ञ!)
— एमसीसीएस
4
ओपी का मतलब है कि मैं हार्मोनिकनंबर का उपयोग नहीं कर सकता [#] &
— J42161217
4
और एक को छोटा कर सकते हैं Tr[1./Range@#]&।
— ग्रेग मार्टिन
2
@Ian मेथेमेटिका सकता है प्रदर्शित 5 sig अंजीर, लेकिन समारोह रिटर्न मशीन परिशुद्धता संख्या (52 दोहरे बीट्स या परिशुद्धता के 16 बस के नीचे दशमलव अंक)
— LLlAMnYP
5

जाप -x , 8 6 5 3 बाइट्स

õpJ

ETHproductions के लिए कुछ धन्यवाद के साथ

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

— झबरा
स्रोत
0-इंडेक्सिंग या 1-इंडेक्सिंग?
— अर्जुन
मुझे लगता है कि आप एक बाइट को बचा सकते हैंõ x@1/X
— ETHproductions
... और एक अन्य जोड़ी का उपयोग करके बाइट्स XpJके बजाय 1/X:-)
— ETHproductions
धन्यवाद, @ETHproductions :) जैसे ही मैं चला गया मैंने उन्हें घुमा दिया।
— झबरा
वास्तव में मुझे नहीं लगता कि आपको _ऑटो-फ़ंक्शंस के कारण भी ज़रूरत है । मुझे वास्तव में उस टिप को लिखना चाहिए: पी (मेरे पास आज या कल का समय होना चाहिए, क्योंकि यह स्मारक दिवस है)
— ETHproductions
4

सीजेएम , 11 10 बाइट्स

1 बाइट ने एग्रीकॉल को धन्यवाद दिया

ri),{W#+}*

यह 1-आधारित अनुक्रमण का उपयोग करता है।

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

व्याख्या

ri            e# Read integer, n
  )           e# Increment by 1: gives n+1
   ,          e# Range: gives [0 1 2 ... n]
    {   }*    e# Fold this block over the array
     W#       e# Inverse of a number
       +      e# Add two numbers
— लुइस मेंडो
स्रोत
आप उपयोग कर सकते हैं Wके बजाय -1।
— एरिक आउटोलर
@EriktheOutgolfer ने खुद को :-)
— लुइस
@LuisMendo मुझे अपना नाम पसंद है, यह सिर्फ एक नाम है। और हाँ, मैंने अपने साथी गोल्फर गोल्फ को आगे भी मदद करने की प्रक्रिया में खुद को आगे बढ़ाया।
— एग्री आउटलोफर
@ एरिक यह एक मजाक के रूप में था। मदद के लिए धन्यवाद
— लुइस मेंडो
3

हास्केल, 20 बाइट्स

f 0=0
f n=1/n+f(n-1)

मूल समाधान, 22 बाइट्स

f n=sum[1/k|k<-[1..n]]

ये विलेयूस 1-अनुक्रमित इनपुट मानता है।

— रयान मैकक्लेरी
स्रोत
3

Tcl 38 बाइट्स

proc h x {expr $x?1./($x)+\[h $x-1]:0}

यह बहुत गंदा हैक है, और पुनरावर्ती कॉल "5-1-1-1 ..." जैसे शाब्दिक तार पास करते हैं जब तक कि यह 0 का मूल्यांकन नहीं करता है।

— avl42
स्रोत
प्रारूपण के लिए @Christopher का धन्यवाद। इसके साथ, बैकलैश का दोहराव अब आवश्यक नहीं था।
— avl42
कोई दिक्कत नहीं है! यह बेहतर लग रहा है
— क्रिस्टोफर
2

MATL, 5 बाइट्स

:l_^s

यह समाधान 1-आधारित अनुक्रमण का उपयोग करता है।

इसे MATL ऑनलाइन पर आज़माएं

व्याख्या

    % Implicitly grab input (N)
:   % Create an array from [1...N]
l_^ % Raise all elements to the -1 power (take the inverse of each)
s   % Sum all values in the array and implicitly display the result
— Suever
स्रोत
2

Axiom, 45 34 बाइट्स

f(x:PI):Any==sum(1./n,n=1..x)::Any

1-इंडेक्स; इसका तर्क एक सकारात्मक पूर्णांक (PI) है और "कोई भी" लौटाएं जो अगले फ़ंक्शन arg के लिए उपयोगी टाइप करने के लिए sys कन्वर्ट (या कन्वर्ट नहीं) (अंत में ऐसा लगता है कि नीचे उदाहरण देख रहा है)

(25) -> [[i,f(i)] for i in 1..9]
   (25)
   [[1,1.0], [2,1.5], [3,1.8333333333 333333333], [4,2.0833333333 333333333],
    [5,2.2833333333 333333333], [6,2.45], [7,2.5928571428 571428572],
    [8,2.7178571428 571428572], [9,2.8289682539 682539683]]
                                                      Type: List List Any
(26) -> f(3000)
   (26)  8.5837498899 591871142
                                        Type: Union(Expression Float,...)
(27) -> f(300000)
   (27)  13.1887550852 056117
                                        Type: Union(Expression Float,...)
(29) -> f(45)^2
   (29)  19.3155689383 88117644
                                                   Type: Expression Float
— RosLuP
स्रोत
1

सी, 54 बाइट्स

i;float f(n){float s;for(i=n+1;--i;s+=1./i);return s;}

1-अनुक्रमित संख्याओं का उपयोग करता है।

— Uriel
स्रोत
1

QBIC , 13 बाइट्स

[:|c=c+1/a]?c

व्याख्या

[ |        FOR a = 1 to
 :            the input n
   c=c+    Add to c (starts off as 0)
   1/a     the reciprocal of the loop iterator
]          NEXT
?c         PRINT c
— steenbergh
स्रोत
1

गोल> <> , 8 बाइट्स

F1LP,+|B

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

उदाहरण पूर्ण कार्यक्रम और यह कैसे काम करता है

1AGIE;GN
F1LP,+|B

1AGIE;GN
1AG       Register row 1 as function G
   IE;    Take input as int, halt if EOF
      GN  Call G and print the result as number
          Repeat indefinitely

F1LP,+|B
F     |   Repeat n times...
 1LP,       Compute 1 / (loop counter + 1)
     +      Add
       B  Return
— bubbler
स्रोत
0

ब्रिंगोल्फ, 20 बाइट्स [गैर-प्रतिस्पर्धात्मक]

VR1-1[1,!/M,$_1+]v&+

यह वास्तव में फ्लोटिंग के साथ काम करने में असमर्थता के कारण काम नहीं करेगा, हालांकि तर्क सही है।

स्पष्टीकरण:

VR1-1[1,!/M,$_1+]v&+   Implicit input
VR                     Create new stack and return to main stack
  1-                   Decrement input
    1                  Push 1
     [..........]      Loop, always runs once, then decrements first item on stack at ]
                       Breaks out of loop if first item on stack reaches 0
      1,!/             Push 1, swap last 2 values, and divide without popping
                       Original values are kept on stack, and result of division is pushed
          M,$_         Move result of division to next stack, then swap last 2 items and
                       Silently pop last item (1)
              1+       Increment last item on stack
                 v&+   Move to next stack, sum entire stack 
                       Implicit output of last item on current stack

यहाँ एक संशोधित दुभाषिया है जो तैरने का समर्थन करता है। पहला तर्क इनपुट है।

— Skidsdev
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.