हार्मोनिक श्रृंखला का सटीक आंशिक योग

Question

चुनौती

एक सकारात्मक पूर्णांक को देखते हुए N, प्रथम Nप्रत्याहारों का एक सटीक अंश के रूप में उत्पादन करते हैं, जो अंश और युग्मक के निरूपण के क्रम में पूर्णांकों की जोड़ी के रूप में दर्शाया जाता है।

नियम

• आउटपुट सटीक होना चाहिए।

• आउटपुट अंश और युग्मक के रूप में होना चाहिए, जो अंश और हर में निरूपित होता है।

• गैर-पूर्णांक संख्यात्मक प्रकार (अंतर्निहित या लाइब्रेरी) का उपयोग करना मना है।

  • स्पष्टीकरण / अपवाद: गैर-पूर्णांक संख्यात्मक प्रकार ठीक हैं और यदि केवल सभी मानों का उपयोग, गणना और लौटाया गया है तो पूर्णांक हैं (यानी आपकी भाषा डिफ़ॉल्ट रूप से तर्कसंगत संख्याओं का उपयोग करती है, लेकिन आप केवल अपने उत्तर में पूर्णांक अंकगणितीय का उपयोग करते हैं)

• आउटपुट को यथासंभव कम किया जाना चाहिए। ( 3/2ठीक है, 6/4नहीं है)

• मानक खामियों को मना किया जाता है।

• सबमिशन को कम से कम 20 तक इनपुट के लिए काम करना चाहिए, या यह मेटा , जो भी अधिक हो।

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

1: 1/1
2: 3/2 (1/1 + 1/2)
3: 11/6 (1/1 + 1/2 + 1/3)
4: 25/12 etc.
5: 137/60
6: 49/20
20: 55835135/15519504
56: 252476961434436524654789/54749786241679275146400
226: 31741146384418617995319820836410246588253008380307063166243468230254437801429301078323028997161/5290225078451893176693594241665890914638817631063334447389979640757204083936351078274058192000

टेस्ट केस जेनरेशन (पायथन 3)

import fractions
def f(x):
    return sum(fractions.Fraction(1,i) for i in range(1,x+1))

करने के लिए इसी तरह के इस चुनौती और इस चुनौती ।

अंश हैं OEIS A001008 , और हरों हैं OEIS A002805 ।

Comments

सैंडबॉक्स पोस्ट (हटाए गए)

— pizzapants184

संबंधित

— लीके नन

है gcdएक "निर्मित समारोह" अगर अपनी भाषा में यह प्रदान करता है?

— चास

@ChasBrown gcdऔर अन्य अंतर्निहित कार्य ठीक हैं। तर्कसंगत / आंशिक प्रकारों की अनुमति नहीं है।

— pizzapants184

@JoKing यह ठीक है यदि संख्याएँ तर्कसंगत हैं जब तक कि केवल पूर्णांक का उपयोग किया जाता है। मैं सवाल को अपडेट करूंगा।

— pizzapants184

Answer 1

पायथन 2 , 80 79 बाइट्स

D=1;N=n=0;exec"n+=1;y=N=N*n+D;x=D=D*n;"*input()
while y:x,y=y,x%y
print N/x,D/x

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

अंश और हर को प्रिंट करता है।

वाह! MathJax समर्थन !!!! एक अवलोकन:

$$\sum_{i=1}^{n} \frac{1}{i} = \sum_{i=1}^{n} \frac{n!}{n!i} = \frac{\sum_{i=1}^{n} \frac{n!}{i}}{n!}$$

फिर, प्रत्यावर्तन के बारे में सोच के लिए , सकारात्मक में umerator:$n$N

$$\sum_{i=1}^{n+1} \frac{(n+1)!}{i} = (n+1) \sum_{i=1}^{n} \frac{n!}{i} + \frac{(n+1)!}{n+1} = (n+1) \sum_{i=1}^{n} \frac{n!}{i} + n!$$

और एक Dव्यक्ति बारे में सोचने में मदद नहीं कर सकता है ! पुनरावर्ती रूप में अच्छी तरह से; इस प्रकार ।$n!$exec

हमें whileलूप में एक जीसीडी गणना के साथ कम हुए फ्रैक्चर पाइपर का भुगतान करना होगा ; और फिर हम कर रहे हैं।

Answer 2

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

!:RS,!:g/$

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

यह काम किस प्रकार करता है

!:RS,!:g/$  Main link. Argument: n

!           Compute n!.
  R         Range; yield [1, ..., n].
 :          Divide n! by each k in [1, ..., n].
   S        Take the sum. Let's call it s.
     !      Compute n! again.
    ,       Pair; yield [s, n!].
      :g/$  Divide [s, n!] by their GCD.

Answer 3

जे , 16 बाइट्स

!(,%+.)1#.!%1+i.

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

उदाहरण चलाते हैं

f =: !(,%+.)1#.!%1+i.
f 6x
   20 49
f 20x
   15519504 55835135
f 56x
   54749786241679275146400 252476961434436524654789

यह काम किस प्रकार करता है

!(,%+.)1#.!%1+i.    NB. Tacit verb
            1+i.    NB. 1 to n inclusive
          !%        NB. Divide factorial by 1 to n
       1#.          NB. Sum i.e. numerator (not reduced)
!                   NB. Factorial i.e. denominator (not reduced)
 (,%+.)             NB. Divide both by GCD

---

जे , 9 बाइट्स, अंश प्रकार का उपयोग करके

1#.1%1+i.

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

J अन्तरंग विभाजन के लिए अंश देता है यदि विभाज्य नहीं है।

Comments

यदि पैरामीटर में से कोई एक bigint है ।

— user202729

आप इस तरह के रैपर का उपयोग कर सकते हैं

— user202729

चाहेंगे 2 x:1#.1%1+i.एक वैध जवाब के रूप में गिनती, या यह एक तर्कसंगत प्रकार का गलत इस्तेमाल होता है?

— कोल

Answer 4

05AB1E , 10 बाइट्स

!DIL÷O)D¿÷

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

अन्य सभी प्रविष्टियों के समान विधि का उपयोग करता है। आउटपुट फॉर्म में है [denominator, numerator]।

!DIL÷O)D¿÷   Full program. Let's call the input I.
!D           Push the factorial twice to the stack. STACK: [I!, I!]
  IL         Range from 1 to I. STACK: [I!, I!, [1 ... I]]
    ÷        Vectorized integer division. STACK: [I!, [I! / 1, I! / 2, ..., I! / I]]
     O       Sum. STACK: [I!, I! / 1 + I! / 2 + ... + I! / I]
      )      Wrap stack. STACK: [[I!, I! / 1 + I! / 2 + ... + I! / I]]
       D     Duplicate. STACK: [[I!, I! / 1 + ... + I! / I], [I!, I! / 1 +... + I! / I]]
        ¿    GCD. STACK: [[I!, I! / 1 + ... + I! / I], gcd(I!, I! / 1 +... + I! / I)]
         ÷   Vectorized integer division. 

Answer 5

वोल्फ्राम भाषा (गणितज्ञ) , 30 बाइट्स

#/GCD@@#&@{Tr[#!/Range@#],#!}&

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

---

14 बाइट्स यदि अंतर्निहित भिन्नात्मक प्रकारों की अनुमति है

HarmonicNumber

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

Comments

InputForm@HarmonicNumber(24 बाइट्स) ओपी द्वारा दिए गए प्रारूप में आउटपुट देता है।

— एरिक टावर्स

Answer 6

जावास्क्रिप्ट (ईएस 6), 60 बाइट्स

लौटता है [numerator, denominator]।

f=(n,a=0,b=1)=>n?f(n-1,p=a*n+b,q=b*n):b?f(0,b,a%b):[p/a,q/a]

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

कैसे?

विधि @ ChasBrown के पायथन उत्तर के समान है ।

$a$$b$$a=0$$b=1$

$$a\gets an+b\\ b\gets bn\\ n\gets n-1$$

$n=0$

$(a,b)$$(p,q)$$a\gets \gcd(a,b)$

$$a\gets b\\ b\gets a \bmod b$$

$b=0$

$p/a$$q/a$

Answer 7

पर्ल 6 , 57 53 बाइट्स

{+($!=[*] 1..$_)/($!=($/=sum $! X/1..$_)gcd$!),$//$!}

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

एक अनाम कोड ब्लॉक जो एक पूर्णांक लेता है और एक टपल देता है denominator, numerator।

यदि हमें भिन्नात्मक प्रकारों का उपयोग करने की अनुमति दी गई है, तो यह 32 सरल होगा:

{sum(map 1/*.FatRat,1..$_).nude}

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

Answer 8

ऑक्टेव , 29 बाइट्स

@(n)sym(sprintf('+1/%i',1:n))

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

Answer 9

सी ++ 17 (जीसीसी) , 108 बाइट्स

केवल पूर्णांक अंकगणित का उपयोग करें:

#import<random>
int f(int x,long&n,long&d){n=0;d=1;int
a;while(n=n*x+d,d*=x,a=std::gcd(n,d),n/=a,d/=a,--x);}

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

---

सी ++ 17 (जीसीसी) , 108 बाइट्स

#import<random>
int f(long&n){double a=0;long
d=1;while(d*=n,a+=1./n,--n);n=a*d+.5;n/=a=std::gcd(n,d);d/=a;}

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

नीचे के समान, लेकिन C ++ 17 का उपयोग करें std::gcd।

---

सी ++ (जीसीसी) , 109 बाइट्स

#import<regex>
int f(long&n){double a=0;long
d=1;while(d*=n,a+=1./n,--n);n=a*d+.5;n/=a=std::__gcd(n,d);d/=a;}

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

क्योंकि C ++ में देशी बिगिन समर्थन नहीं है, यह निश्चित रूप से अतिप्रवाह होगा n>20।

आवश्यक है:

• gcc का संक्षिप्त importविवरण।
• जीसीसी std::__gcd।
• -O0(मुझे ऐसा लगता है) अन्यथा कंपाइलर ऑप्टिमाइज़ करेगा d/=a।
• कम से कम 64-बिट long।

स्पष्टीकरण:

• $d=n!, a=H_n$।
• दौर a*dकास्टिंग द्वारा निकटतम पूर्णांक तक a*d+.5के लिए longहै, और असाइन n। अब n/dआउटपुट है।
• अंश को सरल कीजिए std::__gcd।

Comments

आप (1 char कम) के auto a=0.बजाय उपयोग नहीं कर सकते double a=0?

— दान एम।

हाँ वो कर सकता है। और लूप से एक और बाइट: 106 बाइट्स

— जंगम

Answer 10

परी / जीपी , 34 बाइट्स

n->l=[sum(i=1,n,n!/i),n!];l/gcd(l)

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

---

17 बाइट्स यदि अंतर्निहित भिन्नात्मक प्रकारों की अनुमति है

n->sum(i=1,n,1/i)

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

Answer 11

MATL, 13 बाइट्स

:tptb/sht&Zd/

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

@Dennis 'जेली जवाब में इस्तेमाल के रूप में एक ही विधि ।

:t    % Range from 1 to n, duplicate. 
pt    % Take the product of that (= factorial), duplicate that too.     
b/    % Bring the range to top of stack, divide factorial by each element    
sh    % Sum those. Concatenate factorial and this into a single array.     
t&Zd/ % Compute GCD of those and divide the concatenated array elements by the GCD.     

(अंतर्निहित उत्पादन, पहले हर और फिर अंश को प्रिंट करता है।)

फ्लोटिंग पॉइंट अशुद्धि का मतलब यह है कि यह n = 20 के लिए काम नहीं करता है, क्योंकि मध्यवर्ती मान बहुत बड़े हैं। ऐसा लगता है कि टेस्ट केस आउटपुट एक टाइपो था, यह उसी उत्तर को देता है जैसे कि n = 20 के अन्य उत्तर।

यहाँ एक पूर्णांक प्रकार-संरक्षण संस्करण (25 बाइट्स) है जो मैंने इस बीच में खोजा था, यह पता लगाने से पहले:

25 बाइट्स, इनपुट 43 तक

O1i:3Y%"t@*b@*b+wht&Zd/Z}

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

uint64उन पर कार्य करने से पहले संख्याओं को अंकित करता है, अंकगणित को स्पष्ट रूप से एक लूप (उपयोग prodया उपयोग किए बिना sum) में करता है। इससे भी महत्वपूर्ण बात, प्रत्येक अंश के अंत में, आंशिक रूप से अंश और भाजक को उनके GCD द्वारा हर चरण में विभाजित किया जाता है। यह n43 तक की अनुमति देने के लिए इनपुट रेंज को बढ़ाता है । कोड का भाग @Chas Brown के पायथन उत्तर पर आधारित है।

तथ्यात्मक के बजाय एलसीएम का उपयोग करके वैकल्पिक (मूल) विधि:

16 15 बाइट्स

:t&Zmtb/sht&Zd/

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

Answer 12

एक्सेल VBA, 141 बाइट्स

[A1]कंसोल से आउटपुट और आउटपुट लेता है।

s="=If(Row()>A$1,":[B:B]=s+"1,Row())":l=[LCM(B:B)]:[C:C]=s &"0,"&l &"/B1)":g=[GCD(LCM(B:B),SUM(C:C))]:?Format([Sum(C:C)]/g,0)"/"Format(l/g,0)

Ungolfed और टिप्पणी की

Sub HarmonicSum(n)
    [A1] = n                            ''  Pipe input
    s = "=IF(ROW()>A$1,"                ''  Hold the start of formulas
    [B1:B40] = s + "1,ROW())"           ''  Get series of numbers 1 to N, trailing 1s
    l = [LCM(B1:B40)]                   ''  Get LCM
    [C1:C40] = s & "0," & l & "/B1)"    ''  Get LCM/M for M in 1 to N
    g = [GCD(LCM(B1:B40),SUM(C1:C40))]  ''  Get GCD
                                        ''  Format and print output
    Debug.Print Format([Sum(C1:C40)] / g, 0); "\"; Format(l / g, 0)
End Sub

Answer 13

डीसी , 87 बाइट्स

?sn1dsNsD[lndlDdlNln*+sN*sD1-dsn1<M]sMln1<MlDsAlNsB[lAlB%sTlBsAlTsBlB0<G]dsGxlDlA/lNlA/

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

यह उस क्रम में स्टैक के शीर्ष पर अंश और हर को छोड़ देता है, जैसा कि इस आउटपुट डिफ़ॉल्ट द्वारा अनुमत है । चूंकि dcइसमें gcdबिल्ट-इन नहीं है, यह गणना करने के लिए यूक्लिडियन एल्गोरिथ्म का उपयोग करता है gcd।

Answer 14

स्टैक्स , 11 बाइट्स

ó╢Δ'åç4}ú┌7

इसे चलाएं और डीबग करें

स्पष्टीकरण:

हम गणना करना चाहते हैं:

$$\sum_{i=1}^n{\frac 1 i}$$

हमें अब एक भाजक की जरूरत है $b$ और न्यूमेरिटर्स की एक सूची $a_i$:

$$\sum_{i=1}^n{\frac{a_i}b}=\frac{\sum_{i=1}^n{a_i}}{b}$$

हम बना सकते हैं $b=n!$, तो हमारे पास हैं:

$$\begin{align} \frac{a_i}{n!}&=\frac 1 i&|\times n! \\ a_i&=\frac{n!}i \end{align}$$

तो हमारे पास:

$$\sum_{i=1}^n{\frac 1 n}=\frac{\sum_{i=1}^n{\frac{n!}i}}{n!}$$

|Fx{[/m|+L:_m Full program
|F            Factorial
  x           Push input again
   {  m       Map over range [1, n]
    [           Copy the factorial
     /          Divide factorial by current value
       |+     Sum
         L    Listify stack, top gets first element
          :_  Divide both values by gcd
            m Print each followed by newline

Answer 15

एपीएल (एनएआरएस), 56 चार्ट, 112 बाइट्स

{⍵=1:⊂1 1⋄{(r s)←⍺⋄(i j)←⍵⋄m÷∨/m←((r×j)+s×i),s×j}/1,¨⍳⍵}

परीक्षा:

  f←{⍵=1:⊂1 1⋄{(r s)←⍺⋄(i j)←⍵⋄m÷∨/m←((r×j)+s×i),s×j}/1,¨⍳⍵}
  f 1
1 1 
  f 2
3 2 
  f 3
11 6 
  f 20
55835135 15519504 

कुछ शब्दों में, "2 अंश संख्याओं पर योग फ़ंक्शन" को कम करें (सेट पर एक अंश संख्या एक सूची 2 पूर्णांक है):

1 2, 1 3,..., 1 n

यह नीचे गलत लगता है:

 f 56
74359641471727289 16124934538402170

लेकिन अगर मैं इनपुट के प्रकार को बदल देता हूं:

  f 56x
252476961434436524654789 54749786241679275146400 
  f 226x
31741146384418617995319820836410246588253008380307063166243468230254437801429301078323028997161 529022507845189
  3176693594241665890914638817631063334447389979640757204083936351078274058192000

Answer 16

एपीएल (डायलॉग यूनिकोड) , 15 12 बाइट्स

⌽!(,÷∨)1⊥!÷⍳

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

टैसीट फ़ंक्शन, एक ही तर्क ले रहा है ⍵। ⌽यदि हम हर को पहले प्रिंट करने की अनुमति देते हैं तो एक बाइट हटाकर ।

3 बाइट्स के लिए @dzaima धन्यवाद।

किस तरह:

⌽!(,÷∨)1⊥!÷⍳ ⍝ Tacit function, argument will be called ⍵.
           ⍳ ⍝ Range 1..⍵ 
          ÷  ⍝ Dividing
         !   ⍝ the factorial of ⍵
       1⊥    ⍝ Base-1 decode, aka sum;
 !(   )      ⍝ Using that sum and the factorial of ⍵ as arguments, fork:
     ∨       ⍝ (GCD
    ÷        ⍝ dividing
   ,         ⍝ the vector with both arguments)
⌽            ⍝ reversed.