Calculate 1+2+…+n - Interview Question&Answer

Problem: Calculate 1+2+…+n without multiplication, division, key words for, while, if, else,switch, case, as well as conditional operator (A ? B : C).

Analysis: This problem is not meaningful during software development since usually we do not have such rigorous limitations. However, many interviewers believe that it is useful to test candidates’ ability of divergent thinking. Ability of divergent thinking reflects the depth and width of programming understanding.

Besides equation n(n+1)/2 to get 1+2+…+n, we only have two approaches: Iteration and recursion. Since key words for and while are forbidden, we cannot utilize iteration directly any more. In a recursive function, we need to use key word if or conditional operators to check whether we should continue or stop recursion. Unfortunately, both of them are also forbidden.

Solution 1: Based on Constructors

Let us firstly focus on iterations. An iteration is actually only to repeat n times, and we can achieve it without key words for and while. We can define a class, and then create n instances of it. Therefore, its constructor and destructor will be definitely called n times. If we implement calculation operations inside the constructor, it will iterate for n times. The following code is based on this solution:

class Temp

{

public:

    Temp() { ++ N; Sum += N; }

    static void Reset() { N = 0; Sum = 0; }

    static unsigned int GetSum() { return Sum; }

private:

    static unsigned int N;

    static unsigned int Sum;

};

unsigned int Temp::N = 0;

unsigned int Temp::Sum = 0;

unsigned int Sum_Solution1(unsigned int n)

{

    Temp::Reset();

    Temp *a = new Temp[n];

    delete []a;

    a = NULL;

    return Temp::GetSum();

}

Solution 2: Based on Virtual Functions

We secondly focus on recursion. We cannot determine to continue or stop recursion inside a single function. How about to define two functions, one for normal operations and the other as a terminator? We may use Boolean variables since we are going to select a function out of two. When the Boolean variable is true (1), the operational function will be selected. When it isfalse (0), the terminal function will be selected.

We have to convert integer variables into Boolean variables. It is an easy task since it can be achieved with two not operations (!!n). Non-zero numbers will be true with two not operations and zero will be false.

class A;

A* Array[2];

class A

{

public:

    virtual unsigned int Sum (unsigned int n)

    {

        return 0;

    }

};

class B: public A

{

public:

    virtual unsigned int Sum (unsigned int n)

    {

        return Array[!!n]->Sum(n-1) + n;

    }

};

int Sum_Solution2(int n)

{

    A a;

    B b;

    Array[0] = &a;

    Array[1] = &b;

    int value = Array[1]->Sum(n);

    return value;

}

This solution is based on virtual functions. The function B::Sum is called when variable n is not zero, while the function A::Sum, which acts as a terminator, is called when n equals to zero.

Solution 3: Based on Function Pointers

There are no virtual functions in native C programming environment, so we have to simulate them with function pointers. The code below may be more straightforward:

typedef unsigned int (*fun)(unsigned int);

unsigned int Solution3_Teminator(unsigned int n)

{

    return 0;

}

unsigned int Sum_Solution3(unsigned int n)

{

    static fun f[2] = {Solution3_Teminator, Sum_Solution3};

    return n + f[!!n](n - 1);

}

Solution 4: Based on Template Classes

We can also utilize compiler to simulate recursive calculate. Let us have a look at the following code:

template <unsigned int n> struct Sum_Solution4

{

    enum Value { N = Sum_Solution4<n - 1>::N + n};

};

template <> struct Sum_Solution4<1>

{

    enum Value { N = 1};

};

The value of Sum_Solution4<100>::N is the result of 1+2+…+100. When compilers seeSum_Solution4<100>, it will generate code for the template class Sum_Solution4 with parameter 100. A class Sum _Solution4 <99> is needed to generate the classSum_Solution4<100> since Sum _Solution4<100>::N= Sum _Solution4 <99>::N+100. The recursive process stops when it reaches the Sum_Solution4<1> because it has been defined explicitly.

In the solution, the input n must be a constant value since calculations are all in compiling time. It is a big short coming for this solution. Additionally, n cannot be a large number since compilers have limitations on the depths of recursive compiling.