Represent an integer by the sum of at least two consecutive integers

There are some integers which can be represented by the sum of at least two consecutive integers. For example, 3 = 1 + 2, 9 = 4 + 5 = 2 + 3 + 4, 15 = 1 + 2 + 3 + 4 + 5 = 4 + 5 + 6 = 7 + 8, 18 = 5 + 6 + 7 = 3 + 4 + 5 + 6, 20 = 2 + 3 + 4 + 5 + 6, and so on. However, there are also some integers which do not have such forms of representation. For example, 2, 8, 64, and so on. The following program can test whether an integer input has such form or not. If it does, find all such forms and print them out; If it doesn't, return null and just print out the message to show no such form found.

1. #include <iostream>
2. #include <vector>
3. #include <math.h>
4. using namespace std;
6. inline bool is_odd(int number) {
7.     return number % 2 != 0;
8. }
10. // Return all the consecutive sum representations of a positive integer.
11. vector<vector<int>* >* consecutive_sum(int number) {
12.     if(number < 3) {
13.         return NULL;
14.     }
15.     vector<vector<int>* >* con_sum = new vector<vector<int>* >;
16.     vector<int>* one_con;
17.     int bound = ((int)sqrt(2*number)) + 1; // The upper bound of the count of the sequence.
18.     for(int count = 2; count < bound; ++count) {
19.         if(is_odd(count)) { // The count of the sequence is odd.
20.             if(number%count == 0 && number/count > count/2) { // Has a legal sequence, and store it.
21.                 int start = number/count - count/2;
22.                 one_con = new vector<int>;
23.                 for(int i = 0; i < count; ++i, ++start) {
24.                     one_con->push_back(start);
25.                 }
26.                 con_sum->push_back(one_con);
27.             }
28.         }
29.         else { // The count of the sequence is even.
30.             if(number%count == count/2 && number/count >= count/2) { // Has a legal sequence, and store it.
31.                 int start = number/count - (count/2 - 1);
32.                 one_con = new vector<int>;
33.                 for(int i = 0; i < count; ++i, ++start) {
34.                     one_con->push_back(start);
35.                 }
36.                 con_sum->push_back(one_con);
37.             }
38.         }
39.     }
40.     
41.     return con_sum;
42. }
44. // Print all the forms of representation of an integer.
45. void print_consecutive_sum(vector<vector<int>* >* con_sum) {
46.     if(con_sum == NULL || con_sum->empty()) {
47.         cout << "No consecutive sequences of this number." << endl;
48.         return;
49.     }
50.     vector<vector<int>* >::iterator con_sum_iter, con_sum_end;
51.     vector<int>::iterator con_one_iter, con_one_end;
52.     for(con_sum_iter = con_sum->begin(), con_sum_end = con_sum->end(); con_sum_iter != con_sum_end; ++con_sum_iter) {
53.         for(con_one_iter = (*con_sum_iter)->begin(), con_one_end = (*con_sum_iter)->end(); con_one_iter != con_one_end; ++con_one_iter) {
54.             cout << *con_one_iter << " ";
55.         }
56.         cout << endl;
57.     }
58. }
60. int main() {
61.     int n;
62.     cout << "Start...(Exit by entering ZERO)" << endl;
63.     cin >> n;
64.     while(n != 0) {
65.         print_consecutive_sum(consecutive_sum(n));
66.         cin >> n;
67.     }
68.     cout << "Exit." << endl;
69.     return 0;
70. }

Actually the idea to solve this problem is so easy that you can find it out just through the codes and the comments.

 

Moreover, you may ask what integers do not have such form of representation? OK, if we change the main function like this, all the integers which do not have such form of representation are printed out.

1. int main() {
2.     int n;
3.     cout << "Start...(Exit by entering ZERO)" << endl;
4.     cin >> n;
5.     while(n != 0) {
6.         /*
7.         print_consecutive_sum(consecutive_sum(n));
8.         */
9.         vector<vector<int>* >* cs;
10.         for(int i = 1; i < n; ++i) {
11.             cs = consecutive_sum(i);
12.             if(cs == NULL || cs->empty()) {
13.                 cout << i << " ";
14.             }
15.         }
16.         cout << endl;
17.         cin >> n;
18.     }
19.     cout << "Exit." << endl;
20.     return 0;
21. }

Run this modified program, and you will find such integers share one common feature: They are all some power of 2. 1 = 2⁰, 2 = 2¹, 4 = 2², 8 = 2³, ..., 256 = 2⁸, and so on. But why they don't have such form of representation? What is your opinion? Any related comments are welcome. ^_^

 

Referenced to <Beauty of Programming>.