前n个奇数自然数的四次幂和-yiteyi-C++库

编写一个程序，求出前n个奇数自然数的四次方之和。 1. ^4. + 3 ^4. + 5 ^4. + 7 ^4. + 9 ^4. + 11 ^4. ………….+（2n-1） ^4. . 例如：

null

Input  :   3Output :   7071⁴ +3⁴ +5⁴ =  707Input  :   6Output :   243101⁴ + 3⁴ + 5⁴ + 7⁴ + 9⁴ + 11⁴

推荐：请尝试你的方法 {IDE} 首先，在进入解决方案之前。

天真的方法：-在这个简单的查找前n个奇数自然数的四次幂的过程中，从1到n次迭代一个循环，结果存储在变量和中。 Ex.-n=3然后，（1*1*1*1）+（3*3*3）+（5*5*5*5）=707

C++

                         // CPP Program to find the sum of fourth powers                       
                         // of first n odd natural numbers                       
                         #include <bits/stdc++.h>                       
                         using                                     namespace                                     std;                       
           
                         // calculate the sum of fourth power of first                       
                         // n odd natural numbers                       
                         long                                     long                                     int                                     oddNumSum(                                     int                                     n)                       
                         {                       
                                                 int                                     j = 0;                       
                                                 long                                     long                                     int                                     sum = 0;                       
                                                 for                                     (                                     int                                     i = 1; i <= n; i++) {                       
                                                 j = (2 * i - 1);                       
                                                 sum = sum + (j * j * j * j);                       
                                                 }                       
                                                 return                                     sum;                       
                         }                       
           
                         // Driven Program                       
                         int                                     main()                       
                         {                       
                                                 int                                     n = 6;                       
                                                 cout << oddNumSum(n) << endl;                       
                                                 return                                     0;                       
                         }                       

JAVA

                         // Java Program to find the                       
                         // sum of fourth powers of                       
                         // first n odd natural numbers                       
                         import                                     java.io.*;                       
           
                         class                                     GFG {                       
           
                                                 // calculate the sum of                       
                                                 // fourth power of first                       
                                                 // n odd natural numbers                       
                                                 static                                     long                                     oddNumSum(                                     int                                     n)                       
                                                 {                       
                                                 int                                     j =                                     0                                     ;                       
                                                 long                                     sum =                                     0                                     ;                       
                                                 for                                     (                                     int                                     i =                                     1                                     ; i <= n; i++) {                       
                                                 j = (                                     2                                     * i -                                     1                                     );                       
                                                 sum = sum + (j * j * j * j);                       
                                                 }                       
                                                 return                                     sum;                       
                                                 }                       
           
                                                 // Driven Program                       
                                                 public                                     static                                     void                                     main(String args[])                       
                                                 {                       
                                                 int                                     n =                                     6                                     ;                       
                                                 System.out.println(oddNumSum(n));                       
                                                 }                       
                         }                       
           
                         // This code is contributed                       
                         // by Nikita tiwari.                       

Python 3

                         # Python 3 Program to find the                       
                         # sum of fourth powers of                       
                         # first n odd natural numbers                       
           
                         # calculate the sum of                       
                         # fourth power of first                       
                         # n odd natural numbers                       
                         def                                     oddNumSum(n) :                       
                                                 j                                     =                                     0                       
                                                 sm                                     =                                     0                       
                                                 for                                     i                                     in                                     range                                     (                                     1                                     , n                                     +                                     1                                     ) :                       
                                                 j                                     =                                     (                                     2                                     *                                     i                                     -                                     1                                     )                       
                                                 sm                                     =                                     sm                                     +                                     (j                                     *                                     j                                     *                                     j                                     *                                     j)                       
                                   
                                                 return                                     sm                       
                                   
                         # Driven Program                       
                         n                                     =                                     6                                     ;                       
                         print                                     (oddNumSum(n))                       
           
           
                         # This code is contributed                       
                         # by Nikita tiwari.                       

C#

                         // C# Program to find the                       
                         // sum of fourth powers of                       
                         // first n odd natural numbers                       
                         using                                     System;                       
           
                         class                                     GFG {                       
           
                                                 // calculate the sum of                       
                                                 // fourth power of first                       
                                                 // n odd natural numbers                       
                                                 static                                     long                                     oddNumSum(                                     int                                     n)                       
                                                 {                       
                                                 int                                     j = 0;                       
                                                 long                                     sum = 0;                       
                                                 for                                     (                                     int                                     i = 1; i <= n; i++) {                       
                                                 j = (2 * i - 1);                       
                                                 sum = sum + (j * j * j * j);                       
                                                 }                       
                                                 return                                     sum;                       
                                                 }                       
           
                                                 // Driven Program                       
                                                 public                                     static                                     void                                     Main()                       
                                                 {                       
                                                 int                                     n = 6;                       
                                                 Console.Write(oddNumSum(n));                       
                                                 }                       
                         }                       
           
                         // This code is contributed by                       
                         // vt_m.                       

PHP

                         <?php                       
                         // PHP Program to find the                       
                         // sum of fourth powers                       
                         // of first n odd natural                       
                         // numbers                       
           
                         // calculate the sum of                       
                         // fourth power of first                       
                         // n odd natural numbers                       
                         function                                     oddNumSum(                                     $n                                     )                       
                         {                       
                                                 $j                                     = 0;                       
                                                 $sum                                     = 0;                       
                                                 for                                     (                                     $i                                     = 1;                                     $i                                     <=                                     $n                                     ;                                     $i                                     ++)                       
                                                 {                       
                                                 $j                                     = (2 *                                     $i                                     - 1);                       
                                                 $sum                                     =                                     $sum                                     + (                                     $j                                     *                                     $j                                     *                                     $j                                     *                                     $j                                     );                       
                                                 }                       
                                                 return                                     $sum                                     ;                       
                         }                       
           
                         // Driver Code                       
                         $n                                     = 6;                       
                         echo                                     (oddNumSum(                                     $n                                     ));                       
           
                         // This code is contributed by Ajit.                       
                         ?>                       

Javascript

                         <script>                       
           
                         // javascript Program to find the sum of fourth powers                       
                         // of first n odd natural numbers                       
           
                         // calculate the sum of fourth power of first                       
                         // n odd natural numbers                       
                         function                                     oddNumSum( n)                       
                         {                       
                                                 let j = 0;                       
                                                 let sum = 0;                       
                                                 for                                     (let i = 1; i <= n; i++) {                       
                                                 j = (2 * i - 1);                       
                                                 sum = sum + (j * j * j * j);                       
                                                 }                       
                                                 return                                     sum;                       
                         }                       
           
                         // Driven Program                       
           
                                                 let n = 6;                       
                                                 document.write(oddNumSum(n));                       
           
                         // This code contributed by aashish1995                       
           
                         </script>                       

输出：

时间复杂度：O（N） 有效方法：- 一个有效的解决方案是使用直接数学公式，即：

四次自然数 = (1 ^4. + 2 ^4. + 3 ^4. +n.…+n ^4. ) =（n（n+1）（2n+1）（3n） ^2. +3n-1））/30 四次偶数 = (2 ^4. + 4 ^4. + 6 ^4. +………+2n ^4. ) =8（n（n+1）（2n+1）（3n） ^2. +3n-1））/15；我们需要奇数自然数，所以我们减去（四次方奇数自然数）=（四次方第一n自然数）–（四次方偶数自然数） = (1 ^4. + 2 ^4. + 3 ^4. +n.…+n ^4. ) – (2 ^4. + 4 ^4. + 6 ^4. +………+2n ^4. ) = (1 ^4. + 3 ^4. + 5 ^4. +………+（2n-1） ^4. ) 驱动公式 =（2n（2n+1）（4n+1）（12n） ^2. +6n-1）/30–（8（n（n+1）（2n+1）（3n） ^2. +3n-1））/15 =2n（2n+1）/30[（4n+1）（12n） ^2. +6n-1）–（8n+8）（（3n） ^2. +3n-1））] =n（2n+1）/15[（48n） ^3. +24n ^2. -4n+12n ^2. +6n-1）–（24n ^3. +24n ^2. –8n+24n ^2. +24n-8）] =n（2n+1）/15[24n ^3. -12n ^2. –14n+7]
    Sum of fourth power of first n odd numbers =  n(2n+1)/15[24n³ - 12n² - 14n + 7]

C++

                         // CPP Program to find the sum of fourth powers                       
                         // of first n odd natural numbers                       
                         #include <bits/stdc++.h>                       
                         using                                     namespace                                     std;                       
           
                         // calculate the sum of fourth power of first                       
                         // n odd natural numbers                       
                         long                                     long                                     int                                     oddNumSum(                                     int                                     n)                       
                         {                       
                                                 return                                     (n * (2 * n + 1) *                       
                                                 (24 * n * n * n - 12 * n                       
                                                 * n - 14 * n + 7)) / 15;                       
                         }                       
           
                         // Driven Program                       
                         int                                     main()                       
                         {                       
                                                 int                                     n = 4;                       
                                                 cout << oddNumSum(n) << endl;                       
                                                 return                                     0;                       
                         }                       

JAVA

                         // Java Program to find the sum of                       
                         // fourth powers of first n odd                       
                         // natural numbers                       
                         class                                     GFG {                       
                                   
                                                 // calculate the sum of fourth                       
                                                 // power of first n odd natural                       
                                                 // numbers                       
                                                 static                                     long                                     oddNumSum(                                     int                                     n)                       
                                                 {                       
                                                 return                                     (n * (                                     2                                     * n +                                     1                                     ) *                       
                                                 (                                     24                                     * n * n * n -                                     12                                     * n                       
                                                 * n -                                     14                                     * n +                                     7                                     )) /                                     15                                     ;                       
                                                 }                       
           
                                                 // Driven Program                       
                                                 public                                     static                                     void                                     main(String[] args)                       
                                                 {                       
                                                 int                                     n =                                     4                                     ;                       
                                   
                                                 System.out.println(oddNumSum(n));                       
                                                 }                       
                         }                       
           
                         // This code is contributed by                       
                         // Smitha Dinesh Semwal.                       

Python 3

                         # Python 3 Program to find the                       
                         # sum of fourth powers of first                       
                         # n odd natural numbers                       
           
                         # calculate the sum of fourth                       
                         # power of first n odd natural                       
                         #numbers                       
                         def                                     oddNumSum(n):                       
           
                                                 return                                     (n                                     *                                     (                                     2                                     *                                     n                                     +                                     1                                     )                                     *                       
                                                 (                                     24                                     *                                     n                                     *                                     n                                     *                                     n                                     -                                     12                                     *                                     n                       
                                                 *                                     n                                     -                                     14                                     *                                     n                                     +                                     7                                     ))                                     /                                     15                       
           
                         # Driven Program                       
                         n                                     =                                     4                       
                         print                                     (                                     int                                     (oddNumSum(n)))                       
           
                         # This code is contributed by                       
                         # Smitha Dinesh Semwal.                       

C#

                         // C# Program to find the sum of                       
                         // fourth powers of first n                       
                         // odd natural numbers                       
                         using                                     System;                       
           
                         class                                     GFG {                       
           
                                                 // calculate the sum of fourth                       
                                                 // power of first n odd                       
                                                 // natural numbers                       
                                                 static                                     long                                     oddNumSum(                                     int                                     n)                       
                                                 {                       
                                                 return                                     (n * (2 * n + 1) *                       
                                                 (24 * n * n * n - 12 * n                       
                                                 * n - 14 * n + 7)) / 15;                       
                                                 }                       
           
                                                 // Driven Program                       
                                                 public                                     static                                     void                                     Main()                       
                                                 {                       
                                                 int                                     n = 4;                       
                                                 Console.Write(oddNumSum(n));                       
                                                 }                       
                         }                       
           
                         // This code is contributed by                       
                         // vt_m.                       

PHP

                         <?php                       
                         // PHP Program to find the                       
                         // sum of fourth powers                       
                         // of first n odd natural                       
                         // numbers                       
           
                         // calculate the sum of                       
                         // fourth power of first                       
                         // n odd natural numbers                       
                         function                                     oddNumSum(                                     $n                                     )                       
                         {                       
                                                 return                                     (                                     $n                                     * (2 *                                     $n                                     + 1) *                       
                                                 (24 *                                     $n                                     *                                     $n                                     *                                     $n                                     -                       
                                                 12 *                                     $n                                     *                                     $n                                     - 14 *                       
                                                 $n                                     + 7)) / 15;                       
                         }                       
           
                         // Driver Code                       
                         $n                                     = 4;                       
                         echo                                     (oddNumSum(                                     $n                                     ));                       
           
                         // This code is contributed by Ajit.                       
                         ?>                       

Javascript

                         <script>                       
                         // javascript Program to find the sum of                       
                         // fourth powers of first n odd                       
                         // natural numbers                       
                                   
                         // calculate the sum of fourth                       
                         // power of first n odd natural                       
                         // numbers                       
                         function                                     oddNumSum(n)                       
                         {                       
                                                 return                                     (n * (2 * n + 1) *                       
                                                 (24 * n * n * n - 12 * n                       
                                                 * n - 14 * n + 7)) / 15;                       
                         }                       
           
                         // Driven Program                       
                         var                                     n = 4;                       
           
                         document.write(oddNumSum(n));                       
           
                         // This code is contributed by Amit Katiyar                       
                         </script>                       

输出：

时间复杂度：O（1）

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

THE END

技术文章