Computer >> कंप्यूटर >  >> प्रोग्रामिंग >> C++

श्रृंखला का योग प्राप्त करने के लिए C++ प्रोग्राम:1 - x^2/2! + एक्स ^ 4/4! -…. नौवें कार्यकाल तक

इस ट्यूटोरियल में, हम श्रृंखला 1 - x^2/2 का योग प्राप्त करने के लिए एक प्रोग्राम पर चर्चा करेंगे! + एक्स ^ 4/4! ... nवें कार्यकाल तक।

इसके लिए हमें x और n के मान दिए जाएंगे। हमारा कार्य दिए गए n पदों तक दी गई श्रृंखला के योग की गणना करना होगा। यह फैक्टोरियल की गणना करके और शक्तियों की गणना के लिए मानक पावर फ़ंक्शन का उपयोग करके आसानी से किया जा सकता है।

उदाहरण

#include <math.h>
#include <stdio.h>
//calculating the sum of series
double calc_sum(double x, int n){
   double sum = 1, term = 1, fct, j, y = 2, m;
   int i;
   for (i = 1; i < n; i++) {
      fct = 1;
      for (j = 1; j <= y; j++) {
         fct = fct * j;
      }
      term = term * (-1);
      m = term * pow(x, y) / fct;
      sum = sum + m;
      y += 2;
   }
   return sum;
}
int main(){
   double x = 5;
   int n = 7;
   printf("%.4f", calc_sum(x, n));
   return 0;
}

आउटपुट

0.3469

  1. श्रृंखला 1/1 का योग खोजने के लिए सी ++ प्रोग्राम! + 2/2! + 3/3! + 4/4! + …… एन / एन!

    यहां हम देखेंगे कि हम दी गई श्रृंखला का योग कैसे प्राप्त कर सकते हैं। n का मान उपयोगकर्ता द्वारा दिया जाएगा। हम एक फैक्टोरियल फ़ंक्शन बनाकर इस समस्या को हल कर सकते हैं, और लूप में प्रत्येक चरण में फैक्टोरियल प्राप्त कर सकते हैं। लेकिन फैक्टोरियल कैलकुलेशन सामान्य जोड़ की तुलना में महंगा काम है। हम अ

  1. श्रृंखला 1/1 का योग खोजने के लिए जावा प्रोग्राम! + 2/2! + 3/3! + 4/4! +…….+ एन/एन!

    श्रृंखला का योग ज्ञात करने के लिए जावा प्रोग्राम निम्नलिखित है - 1/1! + 2/2! + 3/3! + 4/4! +…….+ n/n! उदाहरण import java.io.*; import java.lang.*; public class Demo{    public static double pattern_sum(double val){       double residual = 0, factorial_val = 1;

  1. एक श्रृंखला 1/1 का योग खोजने के लिए पायथन प्रोग्राम! + 2/2! + 3/3! + 4/4! +…….+ एन/एन!

    इस लेख में, हम दिए गए समस्या कथन को हल करने के लिए समाधान और दृष्टिकोण के बारे में जानेंगे। समस्या कथन −एक पूर्णांक इनपुट n को देखते हुए, हमें एक श्रृंखला 1/1 का योग ज्ञात करना होगा! + 2/2! + 3/3! + 4/4! +…….+ एन/एन! यहां हम लूप के लिए लागू कर रहे हैं, इसलिए, हमें समय जटिलता के रूप में O(n) मिलता