计数将一个数表示为连续数之和的方法-yiteyi-C++库

给定一个整数 N ，任务是找到将这个数字表示为两个或更多连续数字之和的方法自然数 .

null

例如：

输入： N=15 输出： 3. 说明： 15可以表示为：

1 + 2 + 3 + 4 + 5

4 + 5 + 6

7 + 8

输入： N=10 输出： 1.

方法： 其思想是将N表示为长度为L+1的序列，如下所示： N=a+（a+1）+（a+2）+（a+L） =>N=（L+1）*a+（L*（L+1））/2 =>a=（N-L*（L+1）/2）/（L+1）我们将L的值从1代入L*（L+1）/2 如果我们把a作为一个自然数，那么这个解应该被计算出来。

?列表=PLM68oyaqFM7Q-sv3gA5xbzfgVkoQ0xDrW

C++

                         // C++ program to count number of ways to express                       
                         // N as sum of consecutive numbers.                       
                         #include <bits/stdc++.h>                       
                         using                                     namespace                                     std;                       
           
                         long                                     int                                     countConsecutive(                                     long                                     int                                     N)                       
                         {                       
                                                 // constraint on values of L gives us the                       
                                                 // time Complexity as O(N^0.5)                       
                                                 long                                     int                                     count = 0;                       
                                                 for                                     (                                     long                                     int                                     L = 1; L * (L + 1) < 2 * N; L++) {                       
                                                 double                                     a = (1.0 * N - (L * (L + 1)) / 2) / (L + 1);                       
                                                 if                                     (a - (                                     int                                     )a == 0.0)                       
                                                 count++;                       
                                                 }                       
                                                 return                                     count;                       
                         }                       
           
                         // Driver Code                       
                         int                                     main()                       
                         {                       
                                                 long                                     int                                     N = 15;                       
                                                 cout << countConsecutive(N) << endl;                       
                                                 N = 10;                       
                                                 cout << countConsecutive(N) << endl;                       
                                                 return                                     0;                       
                         }                       

JAVA

                         // A Java program to count number of ways                       
                         // to express N as sum of consecutive numbers.                       
                         public                                     class                                     SumConsecutiveNumber {                       
                                                 // Utility method to compute number of ways                       
                                                 // in which N can be represented as sum of                       
                                                 // consecutive number                       
                                                 static                                     int                                     countConsecutive(                                     int                                     N)                       
                                                 {                       
                                                 // constraint on values of L gives us the                       
                                                 // time Complexity as O(N^0.5)                       
                                                 int                                     count =                                     0                                     ;                       
                                                 for                                     (                                     int                                     L =                                     1                                     ; L * (L +                                     1                                     ) <                                     2                                     * N; L++) {                       
                                                 double                                     a = (                                     double                                     )((                                     1.0                                     * N - (L * (L +                                     1                                     )) /                                     2                                     ) / (L +                                     1                                     ));                       
                                                 if                                     (a - (                                     int                                     )a ==                                     0.0                                     )                       
                                                 count++;                       
                                                 }                       
                                                 return                                     count;                       
                                                 }                       
           
                                                 // Driver code to test above function                       
                                                 public                                     static                                     void                                     main(String[] args)                       
                                                 {                       
                                                 int                                     N =                                     15                                     ;                       
                                                 System.out.println(countConsecutive(N));                       
                                                 N =                                     10                                     ;                       
                                                 System.out.println(countConsecutive(N));                       
                                                 }                       
                         }                       
                         // This code is contributed by Sumit Ghosh                       

Python3

                         # Python program to count number of ways to                       
                         # express N as sum of consecutive numbers.                       
           
                         def                                     countConsecutive(N):                       
                                   
                                                 # constraint on values of L gives us the                       
                                                 # time Complexity as O(N ^ 0.5)                       
                                                 count                                     =                                     0                       
                                                 L                                     =                                     1                       
                                                 while                                     ( L                                     *                                     (L                                     +                                     1                                     ) <                                     2                                     *                                     N):                       
                                                 a                                     =                                     (                                     1.0                                     *                                     N                                     -                                     (L                                     *                                     (L                                     +                                     1                                     ) )                                     /                                     2                                     )                                     /                                     (L                                     +                                     1                                     )                       
                                                 if                                     (a                                     -                                     int                                     (a)                                     =                                     =                                     0.0                                     ):                       
                                                 count                                     +                                     =                                     1                       
                                                 L                                     +                                     =                                     1                       
                                                 return                                     count                       
           
                         # Driver code                       
           
                         N                                     =                                     15                       
                         print                                     (countConsecutive(N))                       
                         N                                     =                                     10                       
                         print                                     (countConsecutive(N))                       
           
                         # This code is contributed by Sachin Bisht                       

C#

                         // A C# program to count number of                       
                         // ways to express N as sum of                       
                         // consecutive numbers.                       
                         using                                     System;                       
           
                         public                                     class                                     GFG {                       
           
                                                 // Utility method to compute                       
                                                 // number of ways in which N                       
                                                 // can be represented as sum                       
                                                 // of consecutive number                       
                                                 static                                     int                                     countConsecutive(                                     int                                     N)                       
                                                 {                       
           
                                                 // constraint on values of L                       
                                                 // gives us the time                       
                                                 // Complexity as O(N^0.5)                       
                                                 int                                     count = 0;                       
                                                 for                                     (                                     int                                     L = 1; L * (L + 1)                       
                                                 < 2 * N;                       
                                                 L++) {                       
                                                 double                                     a = (                                     double                                     )((1.0                       
                                                 * N                       
                                                 - (L * (L + 1))                       
                                                 / 2)                       
                                                 / (L + 1));                       
           
                                                 if                                     (a - (                                     int                                     )a == 0.0)                       
                                                 count++;                       
                                                 }                       
           
                                                 return                                     count;                       
                                                 }                       
           
                                                 // Driver code to test above                       
                                                 // function                       
                                                 public                                     static                                     void                                     Main()                       
                                                 {                       
                                                 int                                     N = 15;                       
                                                 Console.WriteLine(                       
                                                 countConsecutive(N));                       
           
                                                 N = 10;                       
                                                 Console.Write(                       
                                                 countConsecutive(N));                       
                                                 }                       
                         }                       
           
                         // This code is contributed by                       
                         // nitin mittal.                       

PHP

                         <?php                       
                         // PHP program to count number                       
                         // of ways to express N as sum                       
                         // of consecutive numbers.                       
           
                         function                                     countConsecutive(                                     $N                                     )                       
                         {                       
                                                 // constraint on values                       
                                                 // of L gives us the                       
                                                 // time Complexity as O(N^0.5)                       
                                                 $count                                     = 0;                       
                                                 for                                     (                                     $L                                     = 1;                       
                                                 $L                                     * (                                     $L                                     + 1) < 2 *                                     $N                                     ;                                     $L                                     ++)                       
                                                 {                       
                                                 $a                                     = (int)(1.0 *                                     $N                                     - (                                     $L                                     *                       
                                                 (int)(                                     $L                                     + 1)) / 2) / (                                     $L                                     + 1);                       
                                                 if                                     (                                     $a                                     - (int)                                     $a                                     == 0.0)                       
                                                 $count                                     ++;                       
                                                 }                       
                                                 return                                     $count                                     ;                       
                         }                       
           
                         // Driver Code                       
                         $N                                     = 15;                       
                         echo                                     countConsecutive(                                     $N                                     ),                                     ""                                     ;                       
                         $N                                     = 10;                       
                         echo                                     countConsecutive(                                     $N                                     ),                                     ""                                     ;                       
           
                         // This code is contributed by ajit                       
                         ?>                       

Javascript

                         <script>                       
                                                 // A Javascript program to count number of                       
                                                 // ways to express N as sum of                       
                                                 // consecutive numbers.                       
                                   
                                                 // Utility method to compute                       
                                                 // number of ways in which N                       
                                                 // can be represented as sum                       
                                                 // of consecutive number                       
                                                 function                                     countConsecutive(N)                       
                                                 {                       
                                   
                                                 // constraint on values of L                       
                                                 // gives us the time                       
                                                 // Complexity as O(N^0.5)                       
                                                 let count = 0;                       
                                                 for                                     (let L = 1; L * (L + 1) < 2 * N; L++)                       
                                                 {                       
                                                 let a = ((1.0 * N-(L * (L + 1)) / 2) / (L + 1));                       
                                   
                                                 if                                     (a - parseInt(a, 10) == 0.0)                       
                                                 count++;                       
                                                 }                       
                                   
                                                 return                                     count;                       
                                                 }                       
                                   
                                                 let N = 15;                       
                                                 document.write(countConsecutive(N) +                                     "</br>"                                     );                       
           
                                                 N = 10;                       
                                                 document.write(countConsecutive(N));                       
                                   
                         </script>                       

输出：

时间复杂性： O（N^0.5）

本文由 普拉纳夫·马拉特 .如果你喜欢GeekSforgek，并想贡献自己的力量，你也可以使用贡献极客。组织或者把你的文章寄去评论-team@geeksforgeeks.org. 看到你的文章出现在Geeksforgeks主页上，并帮助其他极客。如果您发现任何不正确的地方，或者您想分享有关上述主题的更多信息，请写下评论。

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

THE END

技术文章