हम सभी जानते हैं कि कुछ चर x की शक्ति से ई द्वारा निरूपित यूलर की संख्या , मैक्लॉरिन श्रृंखला विस्तार का उपयोग करके अनुमानित की जा सकती है :

X को 1 के बराबर करके, हम प्राप्त करते हैं

चुनौती

किसी भी भाषा में एक प्रोग्राम लिखें, जो एक इनपुट एन में ले जाकर यूलर के नंबर का अनुमान लगाता है और श्रृंखला की गणना एन-वें पद पर करता है। ध्यान दें कि पहले शब्द में 0 है!! 1 नहीं !, यानी N = 1 1/0 से मेल खाता है।

स्कोरिंग

कम से कम बाइट्स जीत के साथ कार्यक्रम।

— मेव मिक्स
स्रोत

7

Nयदि पर्याप्त परिमित फ्लोटिंग पॉइंट संख्या का उपयोग किया जाए तो पर्याप्त बड़े परिणाम प्राप्त होंगे। क्या वह व्यवहार स्वीकार्य है या परिणाम को उत्तरोत्तर प्राप्त करने के लिए उत्तरोत्तर अधिक सटीक होना पड़ता है N?

— FryAmTheEggman

12

कुछ परीक्षण मामले साफ-सुथरे होंगे।

— लिन

7

(इस तरह के मुद्दे को सैंडबॉक्स में अधिमानतः हल किया गया है - यदि आप अपनी चुनौतियों को वहां पहले पोस्ट करते हैं, तो गोल्फर उपयोगी प्रतिक्रिया देंगे।)

— लिन

2

क्या x ^ n nth टर्म या (n + 1) वें?

— msh210

4

मैं व्यक्तिगत रूप से इसे तिरस्कृत करता हूं, लेकिन ऐसे लोग हैं जो सूचकांक 0 पर शब्द को शून्य शब्द के रूप में संदर्भित करते हैं। उस मामले पर स्वतंत्र रूप से हमारे विचार, सवाल जितना संभव हो उतना स्पष्ट होना चाहिए। इसके अलावा, कुछ परीक्षण मामलों को सत्यापित करने के लिए कि समाधान सही ढंग से काम कर रहे हैं, बहुत मददगार होंगे।

— डेनिस

12

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

R’!İS

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

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

R’!İS  Main link. Argument: n

R      Yield the range [1, ..., n].
 ’     Map decrement over the list.
  !    Map factorial over the list.
   İ   Map inverse over the list.
    S  Compute the sum.

— डेनिस
स्रोत

8

"अंतर्निर्मित होने के लिए [1, n] एक से अधिक होने का अर्थ बनाता है [0, n) imho के लिए।"

— लीक नून

6

... और एक महीने और थोड़ा बाद में, जेली है Ḷ, जो एक [0, n) सीमा बनाती है। ^ वी ^;

— लिन

13

विस्टफुल-सी - 336 बाइट्स

मेरा पहला असली कामचलाऊ कार्यक्रम! वास्तव में एक छोटी सी गोल्फिंग मैंने की है, जिसके somedayबजाय उपयोग करने की wait forवजह से पहले की लंबाई कम थी।

if only <stdio.h> were included...
if only int f were 1...
if only int N were 0...
wish for "%d",&N upon a star
if only int i were 0...
if only double e were 0...
someday i will be N...
        if only e were e+1./f...
        if only i were i+1...
        if only f were f*i...
*sigh*
wish "%f\n",e upon a star
if wishes were horses...

— Maltysen
स्रोत

मुझे बताया गया था कि आप शामिल करने के लिए की जरूरत नहीं है<stdio.h>

— लीकी नून

के someday i were N...बजाय काम करता है someday i will be N...?

— लीक नन

10

पायथ, 7 6 बाइट्स

smc1.!

इसे यहाँ आज़माएँ।

 m      map over range 0..input:
    .!  factorial
  c1    1 / ^
s       sum

एक बाइट के लिए FryAmTheEggman को धन्यवाद !

— Doorknob
स्रोत

9

TI-84 BASIC, 12 15 14

Input N
Σ(A!⁻¹,A,0,N

TI एक टोकन भाषा है ( बाइट्स को टोकन के माध्यम से गिना जाता है , व्यक्तिगत वर्ण नहीं)।

— कोई नाम नहीं
स्रोत

1

उद्धृत मेटा पोस्ट में 11 अपवोट और 10 डाउनवोट हैं। यह सर्वसम्मति नहीं है। Ansएक वैध इनपुट प्रारूप नहीं है, इसलिए केवल 15-बाइट संस्करण मान्य है।

— मेघो

काफी उचित; संपादन ...

— कोई नाम नहीं

1

Ansपीपीसीजी पर हमेशा डिफ़ॉल्ट इनपुट प्रारूप होता है (मेरे पुराने टीआई उत्तरों के माध्यम से देखें), और अधिक लोग इससे सहमत नहीं हैं, इसलिए अपने उत्तर को बदलने में परेशान न हों।

— टिमटेक

2

@MickLH यहाँ विवाद नहीं है। इसके अलावा, ये 8-बिट बाइट्स हैं।

— 20:11

1

@Timtech जबकि मैं आपसे सहमत हूं, समुदाय की सहमति को परिभाषित किया जाता है जैसा कि मेगो कहते हैं।

— कॉनर ओ'ब्रायन

9

जूलिया, 28 27 21 बाइट्स

n->sum(1./gamma(1:n))

यह एक अनाम फ़ंक्शन है जो पूर्णांक को स्वीकार करता है और एक फ्लोट देता है। इसे कॉल करने के लिए, इसे एक वैरिएबल पर असाइन करें।

दृष्टिकोण काफी सीधा है। हम sum1 गामा फ़ंक्शन द्वारा विभाजित हैं एन के माध्यम से 1 में से प्रत्येक पर मूल्यांकन किया गया है । यह संपत्ति n का लाभ उठाता है ! = = ( एन +1)।

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

डेनिस के लिए 1 बाइट धन्यवाद और ग्लेन ओ को 6 बचे धन्यवाद!

— एलेक्स ए।
स्रोत

लगभग MATLAB में समान है:@(n)sum(1./factorial(0:n))

— दोष

6

पायथन, 36 बाइट्स

अजगर 2:

f=lambda n,i=1:n/i and 1.+f(n,i+1)/i

पायथन 3:

f=lambda n,i=1:i<=n and 1+f(n,i+1)/i

— XNOR
स्रोत

अजगर 3 प्रकार के साथ कम किया जा सकता है orके बजाय and: f=lambda n,i=1:i>=n or 1+f(n,i+1)/i।

— कंस्ट्रक्टर

6

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

[d1-d1<f*]sf[dlfx1r/r1-d1<e+]se1?dk1-d1<e+p

यह श्रंखला का काफी प्रत्यक्ष अनुवाद है। मैंने चतुर होने की कोशिश की, लेकिन इसका परिणाम लंबा कोड था।

व्याख्या

[d1-d1<f*]sf

एन> 0 के लिए एक साधारण फैक्टरियल फंक्शन

[dlfx1r/r1-d1<e+]se

एन के लिए भाज्य निष्पादित करें, ..., 1; इन्वर्ट और योग

1?dk1-

1 के साथ स्टैक को प्रधान करें; इनपुट स्वीकार करें और एक उपयुक्त परिशुद्धता सेट करें

d1<e+

यदि इनपुट 0 या 1 था, तो हम इसे केवल पास कर सकते हैं, अन्यथा आंशिक राशि की गणना करें।

परिणाम प्रिंट करें।

परीक्षण के परिणाम

पहले 100 विस्तार:

0
1
2
2.500
2.6666
2.70832
2.716665
2.7180553
2.71825394
2.718278766
2.7182815251
2.71828180110
2.718281826194
2.7182818282857
2.71828182844671
2.718281828458223
2.7182818284589936
2.71828182845904216
2.718281828459045062
2.7182818284590452257
2.71828182845904523484
2.718281828459045235331
2.7182818284590452353584
2.71828182845904523536012
2.718281828459045235360273
2.7182818284590452353602862
2.71828182845904523536028736
2.718281828459045235360287457
2.7182818284590452353602874700
2.71828182845904523536028747123
2.718281828459045235360287471339
2.7182818284590452353602874713514
2.71828182845904523536028747135253
2.718281828459045235360287471352649
2.7182818284590452353602874713526606
2.71828182845904523536028747135266232
2.718281828459045235360287471352662481
2.7182818284590452353602874713526624964
2.71828182845904523536028747135266249759
2.718281828459045235360287471352662497738
2.7182818284590452353602874713526624977552
2.71828182845904523536028747135266249775705
2.718281828459045235360287471352662497757231
2.7182818284590452353602874713526624977572453
2.71828182845904523536028747135266249775724691
2.718281828459045235360287471352662497757247074
2.7182818284590452353602874713526624977572470919
2.71828182845904523536028747135266249775724709352
2.718281828459045235360287471352662497757247093683
2.7182818284590452353602874713526624977572470936984
2.71828182845904523536028747135266249775724709369978
2.718281828459045235360287471352662497757247093699940
2.7182818284590452353602874713526624977572470936999574
2.71828182845904523536028747135266249775724709369995936
2.718281828459045235360287471352662497757247093699959554
2.7182818284590452353602874713526624977572470936999595729
2.71828182845904523536028747135266249775724709369995957475
2.718281828459045235360287471352662497757247093699959574944
2.7182818284590452353602874713526624977572470936999595749646
2.71828182845904523536028747135266249775724709369995957496673
2.718281828459045235360287471352662497757247093699959574966943
2.7182818284590452353602874713526624977572470936999595749669652
2.71828182845904523536028747135266249775724709369995957496696740
2.718281828459045235360287471352662497757247093699959574966967601
2.7182818284590452353602874713526624977572470936999595749669676254
2.71828182845904523536028747135266249775724709369995957496696762747
2.718281828459045235360287471352662497757247093699959574966967627699
2.7182818284590452353602874713526624977572470936999595749669676277220
2.71828182845904523536028747135266249775724709369995957496696762772386
2.718281828459045235360287471352662497757247093699959574966967627724050
2.7182818284590452353602874713526624977572470936999595749669676277240739
2.71828182845904523536028747135266249775724709369995957496696762772407632
2.718281828459045235360287471352662497757247093699959574966967627724076601
2.7182818284590452353602874713526624977572470936999595749669676277240766277
2.71828182845904523536028747135266249775724709369995957496696762772407663006
2.718281828459045235360287471352662497757247093699959574966967627724076630325
2.7182818284590452353602874713526624977572470936999595749669676277240766303508
2.71828182845904523536028747135266249775724709369995957496696762772407663035328
2.718281828459045235360287471352662497757247093699959574966967627724076630353518
2.7182818284590452353602874713526624977572470936999595749669676277240766303535449
2.71828182845904523536028747135266249775724709369995957496696762772407663035354729
2.718281828459045235360287471352662497757247093699959574966967627724076630353547565
2.7182818284590452353602874713526624977572470936999595749669676277240766303535475915
2.71828182845904523536028747135266249775724709369995957496696762772407663035354759429
2.718281828459045235360287471352662497757247093699959574966967627724076630353547594542
2.7182818284590452353602874713526624977572470936999595749669676277240766303535475945681
2.71828182845904523536028747135266249775724709369995957496696762772407663035354759457111
2.718281828459045235360287471352662497757247093699959574966967627724076630353547594571352
2.7182818284590452353602874713526624977572470936999595749669676277240766303535475945713792
2.71828182845904523536028747135266249775724709369995957496696762772407663035354759457138185
2.718281828459045235360287471352662497757247093699959574966967627724076630353547594571382143
2.7182818284590452353602874713526624977572470936999595749669676277240766303535475945713821752
2.71828182845904523536028747135266249775724709369995957496696762772407663035354759457138217826
2.718281828459045235360287471352662497757247093699959574966967627724076630353547594571382178492
2.7182818284590452353602874713526624977572470936999595749669676277240766303535475945713821785218
2.71828182845904523536028747135266249775724709369995957496696762772407663035354759457138217852481
2.718281828459045235360287471352662497757247093699959574966967627724076630353547594571382178525131
2.7182818284590452353602874713526624977572470936999595749669676277240766303535475945713821785251635
2.71828182845904523536028747135266249775724709369995957496696762772407663035354759457138217852516607
2.718281828459045235360287471352662497757247093699959574966967627724076630353547594571382178525166394

1000 शब्दों का उपयोग करना:

2.7182818284590452353602874713526624977572470936999595749669676277240\
766303535475945713821785251664274274663919320030599218174135966290435\
729003342952605956307381323286279434907632338298807531952510190115738\
341879307021540891499348841675092447614606680822648001684774118537423\
454424371075390777449920695517027618386062613313845830007520449338265\
602976067371132007093287091274437470472306969772093101416928368190255\
151086574637721112523897844250569536967707854499699679468644549059879\
316368892300987931277361782154249992295763514822082698951936680331825\
288693984964651058209392398294887933203625094431173012381970684161403\
970198376793206832823764648042953118023287825098194558153017567173613\
320698112509961818815930416903515988885193458072738667385894228792284\
998920868058257492796104841984443634632449684875602336248270419786232\
090021609902353043699418491463140934317381436405462531520961836908887\
070167683964243781405927145635490613031072085103837505101157477041718\
986106873969655212671546889570350116

— टोबी स्पाईट
स्रोत

5

जे, 10 बाइट्स

[:+/%@!@i.

सीधा-आगे का दृष्टिकोण।

व्याख्या

[:+/%@!@i.    Input: n
        i.    Creates the range [0, 1, ..., n-1]
      !@      Maps factorial to each
    %@        Map 1/x to each
[:+/          Take the sum of the values and return it

— मील की दूरी पर
स्रोत

अच्छा लगा। तुच्छ 1 बाइट सुधार:1#.%@!@i.

— योना

4

CJam, 11

r~,:m!Wf#:+

या

r~{m!W#}%:+

इसे ऑनलाइन आज़माएँ: पहला संस्करण और दूसरा संस्करण

स्पष्टीकरण:

r~= पढ़ें और मूल्यांकन करें
m!= भाज्य
W#= -1 पावर तक बढ़ाएं ( W= -1)
:+= सरणी का योग
प्रथम संस्करण [0… N-1] सरणी का निर्माण करता है और तथ्यात्मक और इसके सभी तत्वों के विपरीत लागू होता है; दूसरा संस्करण भाज्य करता है और प्रत्येक संख्या के लिए उलटा करता है और फिर उन्हें एक सरणी में रखता है।

— aditsu
स्रोत

4

जावास्क्रिप्ट ईएस 6, 44 42 40

n=>{for(k=s=m=1;m<n;s+=k/=m++);return s}

एक अनाम फ़ंक्शन अब।

2 बाइट्स @ एलेक्सा को बचाने के लिए धन्यवाद और अन्य 2 बाइट्स के लिए @LeakyNun को धन्यवाद!

— ಠ_ಠ
स्रोत

n=>{for(k=s=m=1;m<n;s+=k/=m++);return s}

— लीक नून

4

MATL, 11 7 बाइट्स

:Ygl_^s

4 बाइट @ लुइस की सिफारिश का उपयोग करने के लिए धन्यवाद बचाया gamma( Yg)

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

व्याख्या

        % Implicitly grab input (N)
:       % Create an array from 1...N
Yg      % Compute factorial(x-1) for each element (x) in the array
l_^     % Take the inverse
s       % Sum all elements
        % Implicitly display the result

— Suever
स्रोत

आप हटा सकते हैं]

— लुइस मेंडो

इसके अलावा, 1i:Yg/s7 बाइट्स के लिए

— लुइस मेंडो

@LuisMendo ओह, हाँ, मैं उम्मीद कर रहा था कि एक फैक्टरियल प्राप्त करने का एक बेहतर तरीका है लेकिन मैं गामा के बारे में भूल गया था। शीघ्र ही अपडेट हो जाएगा

— Suever

4

MATL , 6 बाइट्स

q_t1Zh

यह योग का उपयोग कर गणना करता है हाइपरमेट्रिक फंक्शन ₁F ₁ ( a ; b ; z ) :

ऑक्टेव पर और ऑनलाइन कंपाइलर पर काम करता है, लेकिन मैटलैब पर नहीं, हाइपरमेट्रिक फंक्शन को परिभाषित करने के तरीके में अंतर के कारण (जिसे सही किया जाएगा)।

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

व्याख्या

q_    % Take N implicitly. Compute -N+1
t     % Duplicate
1     % Push 1
Zh    % Hypergeometric function 1F1(-N+1;-N+1;1). Implicitly display

— लुइस मेंडो
स्रोत

4

सी, 249 बाइट्स

#include <stdio.h>
#include <stdlib.h>
#define z double
z f(z x){z r=1;z n=1;while(x>0){r*=n;n++;x--;}return r;}int main(int argc, char **argv){z e=0;z p=0;z d=0;p=strtod(argv[1],NULL);while(p>0){e+=1.0d/f(d);printf("%.10f\n",e);p--;d++;}return 0;}

Ungolfed:

/* approximate e */

#include <stdio.h>
#include <stdlib.h>

double fact(double x){
    double result = 1;
    double num = 1;

    while (x > 0){
        result *= num;
        num++;
        x--;
    }
    return result;
}

int main(int argc, char **argv){
    double e = 0;
    double precision = 0;
    double denom = 0;

    precision = strtod(argv[1], NULL);
    while (precision > 0){
        e += 1.0d / fact(denom);
        printf("%.10f\n", e);
        precision--;
        denom++;
    }
    return 0;
}

पुनरावृत्तियों की संख्या निर्धारित करने के लिए एक तर्क के रूप में एक संख्या लेता है।

— LordCreepity
स्रोत

नमस्कार, और PPCG में आपका स्वागत है! महान पहली पोस्ट!

— NoOneIsHere

प्रोग्रामिंग पहेलियाँ और कोड गोल्फ में आपका स्वागत है! मुझे लगता है कि कार्यक्रम केवल अंतिम सन्निकटन को मुद्रित करने के लिए है। कम से कम जीसीसी के साथ, आपको intपहले mainऔर आवश्यकता नहीं है return 0। इसके अलावा, यदि आप के NULLसाथ प्रतिस्थापित करते हैं 0, तो आपको शामिल करने की आवश्यकता नहीं है। argcऔर argvएकल-अक्षर चर के लिए छोटा किया जा सकता है। यदि आप सी में गोल्फ का आनंद लेते हैं, तो आपको सी सहायक में गोल्फिंग के लिए टिप्स मिल सकते हैं ।

— डेनिस

IMHO, भले ही संकलक कुछ चेतावनियों को फेंकता है लेकिन सही परिणाम देता है फिर भी, आप अपने कोड के कई हिस्सों को इस बिंदु पर फेंक सकते हैं कि कुछ भी त्रुटि के बिना कम नहीं किया जा सकता है।

— आंद्रे

और आपको जरूरत नहीं है#include <stdio.h>

— लीक नून

3

k (13 बाइट्स)

के लिए ओवरफ्लो का विषय N>20

{+/%*\1,1+!x}

— skeevey
स्रोत

3

05AB1E, 6 बाइट्स

$L<!/O

व्याख्या की

$           # push 1 and input: N = 5
 L<         # range [0..N-1]: [0,1,2,3,4]
   !        # factorial over range [1,1,2,6,24]
    /       # divide 1/range: [1.0, 1.0, 0.5, 0.16666666666666666, 0.041666666666666664]
     O      # sum: 2.708333333333333

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

— Emigna
स्रोत

1

5 बाइट्स के साथ L<!zO।

— ग्रिम्मी

3

पाइके, 10 बाइट्स

FSBQi^R/)s

यहाँ कोशिश करो!

या 8 बाइट्स अगर शक्ति = 1

FSB1R/)s

यहाँ कोशिश करो!

— नीला
स्रोत

पहला कोड 3 से अधिक से बंद था जब मैंने इसे चलाया: 5.436532738095238

— टोक्सीजाम

@ tox123 अब तय किया गया

— ब्लू

क्या आप इनका परीक्षण कर रहे हैं? मुझे मिला: पहले के लिए 7.3887125220458545, दूसरा बेहतर काम करता है।

— विषाक्त

वह एक ई ^ एक्स है जिसे आप न केवल ई

— ब्लू

यह चुनौती नहीं है।

— विषाक्त

3

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

f=(n,i=1)=>n&&1+f(n-1,i+1)/i

— नील
स्रोत

3

दिल्लोग एपीएल , 6 बाइट्स

+/÷!⍳⎕

+/के योग
÷के reciprocals
!के factorials
⍳0 से संख्या
⎕संख्यात्मक इनपुट

मानता है ⎕IO←0, जो कई प्रणालियों पर डिफ़ॉल्ट है।

TryAPL !

— एडम
स्रोत

3

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

((scanl(+)0$(1/)<$>scanl(*)1[1..])!!)

सबसे छोटा नहीं है, लेकिन यकीनन सबसे सुंदर है।

लाईकोनी के सौजन्य से , यहाँ एक समाधान है जो 2 बाइट्स छोटा है:

sum.(`take`((1/)<$>scanl(*)1[1..]))

λ> let f = ((scanl (+) 0 $ (1/) <$> scanl (*) 1 [1..]) !!)

λ> map f [1..5]
[1.0,2.0,2.5,2.6666666666666665,2.708333333333333]

λ> f 10
2.7182815255731922

λ> f 100
2.7182818284590455

λ> log (f 10)
0.9999998885745155

λ> log (f 100)
1.0

— रोड्रिगो डी अजेवेडो
स्रोत

2

आप इस UTF-8 बाइट काउंटर का उपयोग कर सकते हैं । मैंने सुझाव दिया कि अपने बाइट की गिनती जोड़ने के लिए सुझाव दें, जो है 50। शीर्ष लेख जोड़ने के लिए, का उपयोग करें ## Language, <xxx> bytes:।

— NoOneIsHere

1

क्या आपको व्हॉट्सएप की जरूरत है?

— NoOneIsHere

1

आप इनपुट को एक चर में मौजूद होने का अनुमान नहीं लगा सकते हैं, इसलिए आपको एक मान्य फ़ंक्शन सबमिशन प्रस्तुत करने f n=या \n->प्राप्त करने की आवश्यकता है। हालांकि, हम कुछ बाइट्स भी बचा सकते हैं: (\x->1/x)अनुभाग को छोटा किया जा सकता है (1/), [1,2..]जैसा है [1..]और map(...)$हो सकता है (...)<$>। एक साथ 36 बाइट्स: इसे ऑनलाइन आज़माएं!

— लैकोनी

1

एक बिंदु-मुक्त फ़ंक्शन में बदलने से एक और बाइट बचती है: इसे ऑनलाइन आज़माएं! और यह एक बाइट लंबा होने के बावजूद भी ((scanl(+)0$(1/)<$>scanl(*)1[1..])!!)अच्छा दिखता है।

— लिकोनी जूल

1

जैसा कि आपने स्वयं को कोष्ठक के बिना संस्करण देखा है, केवल एक मान्य हास्केल अभिव्यक्ति है जब इसके बाद एक मूल्य सम्मिलित किया जाता है, लेकिन यह मानकर कि पूर्वनिर्धारित चर में मौजूद इनपुट की अनुमति नहीं है , आपको कोष्ठक जोड़ना होगा या फिर एक अग्रणी \n->बनाना होगा। एक समारोह।

— लैकोनी

3

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

⍳⊥⊢÷!

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

में पाया मिश्रित आधार चाल का उपयोग करना मेरा उत्तर की एक और चुनौती । उपयोग करता है ⎕IO←0।

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

⍳⊥⊢÷!  Right argument: n, the number of terms
  ⊢÷!  v: 1÷(n-1)!
⍳      B: The array of 0 .. n-1
 ⊥     Expand v to length-n array V,
       then mixed base conversion of V in base B

Base | Digit | Value
--------------------
0    | v     | v×(1×2×..×(n-1)) = 1÷0!
1    | v     | v×(2×3×..×(n-1)) = 1÷1!
2    | v     | v×(3×..×(n-1))   = 1÷2!
..   | ..    | ..
n-2  | v     | v×(n-1)          = 1÷(n-2)!
n-1  | v     | v                = 1÷(n-1)!

— bubbler
स्रोत

10k प्रतिनिधि! अब यह देखने के लिए कि क्या मैं ट्यूरिंग मशीन में इसे खींच सकता हूं ....

— ouflak

अच्छा उत्तर लेकिन मुझे यह देखने में परेशानी हो रही 1÷(n-1)!है कि अंक कैसे है? क्या आप इसे स्पष्ट करने के लिए J में अनुवाद कर सकते हैं?

— जोनाह

2

दरअसल, 6 बाइट्स

r♂!♂ìΣ

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

स्पष्टीकरण:

r♂!♂ìΣ
r       range(N) ([0, N-1])
 ♂!     factorial of each element
   ♂ì   reciprocal of each element
     Σ  sum

— मै जाऊं
स्रोत

2

ब्रेकीलॉग , 18 बाइट्स

:1-:0r:ef:$!a:/a+.

व्याख्या

:1-                 Subtract 1 from Input
   :0r              Create the list [0, Input - 1]
      :ef           Find all integers between 0 and Input - 1
         :$!a       Apply factorial to each member of that list
             :/a    Apply inverse to each element of that list
                +.  Unify the output with the sum of the list

— Fatalize
स्रोत

2

मेपल, 18

add(1/i!,i=0..n-1)

उपयोग:

> f:=n->add(1/i!,i=0..n-1);
> f(1);
  1
> f(4);
  8/3

— DSkoog
स्रोत

मुझे लगता है कि फ़ंक्शन n-> जोड़ (1 / i!, I = 0..n-1) है

— RosLuP

2

सी, 69 बाइट्स

double f(int n){double s=1,f=1;for(int i=0;i++<n;s+=f)f/=i;return s;}

Ideone यह!

— लीक नन
स्रोत

2

दस फुट लेजर पोल के साथ जावा , 238 236 बाइट्स

import sj224.tflp.math.*;interface U{static void main(String[]a){BigRational r=null,s,t;r=s=t=r.ONE;for(int n=new java.util.Scanner(System.in).nextInt()-1;n-->0;){t=t.multiply(r);s=s.add(t.pow(-1));r=r.add(r.ONE);}System.out.print(s);}}

अधिकांश अन्य उत्तरों की तुलना में बेहतर ओवरफ्लो प्रतिरोध है। 100 शब्दों के लिए, परिणाम है

31710869445015912176908843526535027555643447320787267779096898248431156738548305814867560678144006224158425966541000436701189187481211772088720561290395499/11665776930493019085212404857033337561339496033047702683574120486902199999153739451117682997019564785781712240103402969781398151364608000000000000000000000

— SuperJedi224
स्रोत

2

जूलिया, 28 बाइट्स

~k=k<1?1:1/gamma(k+1)+~(k-1)

व्याख्या

~k=                    #Define ~ to be
    k<1                #If k is less than 1
        ?1             #to be one
        :1/gamma(k+1)  #else add the reciprocal factorial to 
            +~(k-1)    #the function applied to the predecessor value

gamma(k+1)factorial(k)सकारात्मक पूर्णांक निविष्टियों के लिए बराबर है , और इसे गैर-पूर्णांक पूर्णांक के अलावा सभी मानों के लिए सामान्यीकृत करता है। यह एक बाइट बचाता है, तो इसका उपयोग क्यों न करें?

— eaglgenes101
स्रोत

1

MATLAB / ऑक्टेव, 22 बाइट्स

@(x)sum(1./gamma(1:x))

एक अनाम फ़ंक्शन बनाता ansहै जिसका उपयोग करके कॉल किया जा सकता हैans(N) ।

यह समाधान gamma(x)सरणी में प्रत्येक तत्व के लिए गणना करता है [1 ... N] जो इसके बराबर है factorial(x-1)। हम फिर प्रत्येक तत्व का विलोम लेते हैं और सभी तत्वों को जोड़ते हैं।

ऑनलाइन डेमो

— Suever
स्रोत

1

पर्ल 5, 37 बाइट्स

विजेता नहीं, लेकिन अच्छा और सीधा:

$e=$p=1;$e+=1/($p*=$_)for 1..<>;say$e

इनपुट्स के लिए आउटपुट 0 से 10:

1
2
2.5
2.66666666666667
2.70833333333333
2.71666666666667
2.71805555555556
2.71825396825397
2.71827876984127
2.71828152557319
2.71828180114638

— हॉब्स
स्रोत

1

आर, 17 बाइट्स

sum(1/gamma(1:n))

बिल्कुल सीधा, हालांकि संख्यात्मक सटीक मुद्दे किसी समय में उत्पन्न होने के लिए बाध्य हैं।

— आंद्रे कोस्टीर्का
स्रोत

1

वोल्फ्रामअल्फा , 12 बाइट्स

sum1/k!,0..n

— अनास्तासिया-रोमानोवा ova
स्रोत

ई के लगभग

चुनौती

स्कोरिंग

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

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

विस्टफुल-सी - 336 बाइट्स

पायथ, 7 6 बाइट्स

TI-84 BASIC, 12 15 14

जूलिया, 28 27 21 बाइट्स

पायथन, 36 बाइट्स

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

व्याख्या

परीक्षण के परिणाम

जे, 10 बाइट्स

व्याख्या

CJam, 11

जावास्क्रिप्ट ईएस 6, 44 42 40

MATL, 11 7 बाइट्स

MATL , 6 बाइट्स

व्याख्या

सी, 249 बाइट्स

k (13 बाइट्स)

05AB1E, 6 बाइट्स

पाइके, 10 बाइट्स

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

दिल्लोग एपीएल , 6 बाइट्स

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

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

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

दरअसल, 6 बाइट्स

ब्रेकीलॉग , 18 बाइट्स

व्याख्या

मेपल, 18

सी, 69 बाइट्स

दस फुट लेजर पोल के साथ जावा , 238 236 बाइट्स

जूलिया, 28 बाइट्स

व्याख्या

MATLAB / ऑक्टेव, 22 बाइट्स

पर्ल 5, 37 बाइट्स

आर, 17 बाइट्स

वोल्फ्रामअल्फा , 12 बाइट्स