前n个自然数的立方和的Java程序-yiteyi-C++库

打印系列1的总和 ^3. + 2 ^3. + 3 ^3. + 4 ^3. + …….+ N ^3. 直到第n学期。

null

例如：

Input : n = 5
Output : 225
1³ + 2³ + 3³ + 4³ + 5³ = 225

Input : n = 7
Output : 784
1³ + 2³ + 3³ + 4³ + 5³ + 
6³ + 7³ = 784

JAVA

                         // Simple Java program to find sum of series                       
                         // with cubes of first n natural numbers                       
                                   
                         import                                     java.util.*;                       
                         import                                     java.lang.*;                       
                         class                                     GFG                       
                         {                       
                                   
                                                 /* Returns the sum of series */                       
                                                 public                                     static                                     int                                     sumOfSeries(                                     int                                     n)                       
                                                 {                       
                                                 int                                     sum =                                     0                                     ;                       
                                                 for                                     (                                     int                                     x=                                     1                                     ; x<=n; x++)                       
                                                 sum += x*x*x;                       
                                                 return                                     sum;                       
                                                 }                       
                                   
                         // Driver Function                       
                                                 public                                     static                                     void                                     main(String[] args)                       
                                                 {                       
                                                 int                                     n =                                     5                                     ;                       
                                                 System.out.println(sumOfSeries(n));                       
                                   
                                                 }                       
                         }                       
                                   
                         // Code Contributed by Mohit Gupta_OMG <(0_o)>                       

输出：

时间复杂度：O（n）一 有效解决方案 就是使用直接的数学公式 （n（n+1）/2）^2

For n = 5 sum by formula is
       (5*(5 + 1 ) / 2)) ^ 2
          = (5*6/2) ^ 2
          = (15) ^ 2
          = 225

For n = 7, sum by formula is
       (7*(7 + 1 ) / 2)) ^ 2
          = (7*8/2) ^ 2
          = (28) ^ 2
          = 784

JAVA

                         // A formula based Java program to find sum                       
                         // of series with cubes of first n natural                       
                         // numbers                       
                                   
                         import                                     java.util.*;                       
                         import                                     java.lang.*;                       
                         class                                     GFG                       
                         {                       
                                                 /* Returns the sum of series */                       
                                                 public                                     static                                     int                                     sumOfSeries(                                     int                                     n)                       
                                                 {                       
                                                 int                                     x = (n * (n +                                     1                                     )  /                                     2                                     );                       
                                   
                                                 return                                     x * x;                       
                                                 }                       
                                   
                         // Driver Function                       
                                                 public                                     static                                     void                                     main(String[] args)                       
                                                 {                       
                                                 int                                     n =                                     5                                     ;                       
                                                 System.out.println(sumOfSeries(n));                       
                                   
                                                 }                       
                         }                       
                                   
                         // Code Contributed by Mohit Gupta_OMG <(0_o)>                       

输出：

时间复杂度：O（1） 这个公式是如何工作的？ 我们可以用数学归纳法来证明这个公式。我们可以很容易地看到，这个公式适用于n=1和n=2。对于n=k-1，这是真的。

Let the formula be true for n = k-1.
Sum of first (k-1) natural numbers = 
            [((k - 1) * k)/2]²

Sum of first k natural numbers = 
          = Sum of (k-1) numbers + k³
          = [((k - 1) * k)/2]² + k³
          = [k²(k² - 2k + 1) + 4k³]/4
          = [k⁴ + 2k³ + k²]/4
          = k²(k² + 2k + 1)/4
          = [k*(k+1)/2]²

即使结果不超过整数限制，上述程序也会导致溢出。 喜欢以前的职位，我们可以通过先除法在一定程度上避免溢出。

JAVA

                         // Efficient Java program to find sum of cubes                       
                         // of first n natural numbers that avoids                       
                         // overflow if result is going to be withing                       
                         // limits.                       
                         import                                     java.util.*;                       
                         import                                     java.lang.*;                       
                         class                                     GFG                       
                         {                       
                                                 /* Returns the sum of series */                       
                                                 public                                     static                                     int                                     sumOfSeries(                                     int                                     n)                       
                                                 {                       
                                                 int                                     x;                       
                                                 if                                     (n %                                     2                                     ==                                     0                                     )                       
                                                 x = (n/                                     2                                     ) * (n+                                     1                                     );                       
                                                 else                       
                                                 x = ((n +                                     1                                     ) /                                     2                                     ) * n;                       
                                                 return                                     x * x;                       
                                                 }                       
                                   
                         // Driver Function                       
                                                 public                                     static                                     void                                     main(String[] args)                       
                                                 {                       
                                                 int                                     n =                                     5                                     ;                       
                                                 System.out.println(sumOfSeries(n));                       
                                                 }                       
                         }                       
                         // Code Contributed by Mohit Gupta_OMG <(0_o)>                       

输出：

请参阅完整的文章前n个自然数的立方和程序更多细节！

文章版权归作者所有，未经允许请勿转载。

THE END

技术文章