题目描述
求1+2+3+…+n，要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句（A?B:C）。
题目解析
求1到n的和，重点是不能使用乘除、for、while、if、else、switch、case等关键字以及条件判断的语句(A?B:C),那么显然这道题目难度提升了一个台阶，如果没做过这个类型的题目，可能会心中一揪，两眼一把黑。
解题思路
这里可以通过递归的方式进行计算，但是很疑问的地方在于如何结束递归。这里可以有多种的方式，基本方向是采用逻辑与或的方式来计算，与的时候通过n>0来短路，这样在n=0的时候不需要计算递归的值，或的时候通过n==0来短路，在n=0的时候可以短路逻辑或运算。
public class Solution {
    public int Sum_Solution(int n) {
        
        int sum = n;
        //boolean b = (n > 0) && (sum += Sum_Solution(n-1)) > 0;
        boolean b = (n == 0) || (sum += Sum_Solution(n-1)) > 0;
        
        return sum;
    }
}

这个问题有很多解法，比如上面的递归，还有迭代这样都可以计算，但是可以看出递归的逻辑性很高，这种方法不建议选取，如果递归深度过大，那么对内存的占用是特别大的，也就是说在有预算的范围内是尽量选用递归，这样可以使代码简洁，那么如果这道题没有预算，比如给的n是100000或者1000000000这样的，那么就不可以了，这时候老老实实选用循环去解答比较好。

有这样一道C/C++题：求1+2+3+...+n，要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句（A?B:C）。
还有多少种解法？对于这个问题限制了我们常用的求解方式，目的是想让我们另辟蹊径。那么我们只有硬着头皮找各种方式来应对此题，下面为大家带来几个来自网友们的方法，供我们共同学习：
1、利用了&&的短路特性：即当&&（与）的左边为假时整个表达式为假，右边的不用再计算了；下边附上解决代码：





class
Solution {
public:
    int
Sum_Solution(int  n) {
        int
sum = n;
        sum && (sum += Sum_Solution(n - 1));
        return
sum;
    }
};


1）利用逻辑与的短路特性实现递归终止。 
2）当n==0时， sum && (sum += Sum_Solution(n
 - 1))只执行前面的判断，为false，然后直接返回0；
3）当n>0时，执行sum+=Sum_Solution(n-1)，实现递归计算Sum_Solution(n)。
2、用公式是不可以的，公式里有乘法！！实现乘法可以用sizeof多维数组，

class
Solution {
public:
    int
Sum_Solution(int
n) {
        bool
a[n][n+1];
        return
sizeof(a)>>1;
    }
};
3、当有人说用公式不可以的时候，别人果断的用其他方式利用了公式，而且只需要一行（惊呆）：
class Solution {
    public ：int Sum_Solution(int n) {
        return  （ (int) (.pow(n, 2)+n)）>>1;    

    }


}
4、用异常退出递归
public class Solution { 
    public int Sum_Solution(int n) { 
        return sum(n); 
    } 
    int sum(int n){ 
        try{ 
            int i = 1%n; 
            return n+sum(n-1); 
        } 
        catch(Exception e){ 
            return 0; 
        } 
    }
}

5、先取对数再指数算回去。
class Solution {
public:
    int Sum_Solution(int n) {
        //return n*(n+1)/2;
        return multi(n, n + 1) >> 1;
    }
    int multi(int a, int b){
        // we can guarantee that both a and b is positive integers
        int res = int(pow(10, log10(a) + log10(b))+0.5);
        return res;
    }
};



先奉上这些，当然方法还有很多种，有待我们挖掘。。。。不说了，我也要赶紧学习去了

今天在牛客网上看到一道面试题，感觉很有意思自己也思考了很长时间，希望可以分享下来，题目是这样描述的：

求1+2+3+...+n，要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句（A?B:C）。

刚开始的时候我想1+2+3+…+n不正好是等差数列吗？直接使用等差数列的求和公式不就可以吗？n*(n+1)/2，但是公式中依然有乘法啊，所以这个想法被pass掉。 

  后来我就想到了逻辑运算中的逻辑与&&操作，这个操作有一个特性就是短路特性，如果当前面的条件成立的时候后面的条件就不再执行了，如果我用前面一个条件代表递归结束，后面一个条件代表递归执行，不正好可以实现这个目的吗？于是我写出了下面的代码：



size_t Sum_Solution(size_t n)
{
    //当n为0的时候只执行前面的条件，结果为false
    //当n大于0的时候可以执行到后面的条件，实现递归计算，
    int sum=n;
    bool ret=(n > 0) && ((sum += Sum_Solution(n-1)) > 0);
    return sum;
}

当然了，还有其他的解决方法了。。。



方法一.利用构造函数的方法实现循环

如果我们一次创建n个对象，每次创建对象都会调用一次构造函数，而每调用一次构造函数循环变量就增加1，而sum也随之递增，这不就利用构造函数达到循环的效果了吗？

//利用构造函数模拟循环
class Sum_Solution
{
public:
    Sum_Solution()  //构造函数控制循环的次数
    {
        ++_i;
        _sum += _i;
    }
    static void InitData()
    {
        _i=0;
        _sum=0;
    }
    static size_t GetSum()  //返回最终结果
    {
        return _sum;
    }
private:
    static size_t _i;
    static size_t _sum;
};
//使用静态的变量可保证累加的效果
size_t Sum_Solution::_i=0;
size_t Sum_Solution::_sum=0;

void testSum_Solution()
{
    int n=100;
    Sum_Solution::InitData();//调用初始化函数给变量_i，和_sum赋初值
    Sum_Solution *tmp=new Sum_Solution[n];
    delete[]tmp;
    size_t ret=Sum_Solution::GetSum();
    cout<<ret<<endl;
}



方法二.利用虚函数的方法模拟递归

所谓的递归就是要有实现递归的函数以及递归结束的条件，如果可以使得实现递归的函数和判断递归结束的条件用两个类实现就可以解决这个问题了。



//使用虚函数模拟递归实现
class A
{
public:
    virtual size_t GetSum(size_t n)  //递归结束的条件
    {
        return 0;
    }
};
A *arr[2];
class B:public A
{
public:
    virtual size_t GetSum(size_t n)  //递归的实现
    {
        return arr[!!n]->GetSum(n-1)+n;
    }
};
void testSolution()
{
    //n==0,调用A::GetSum(),当n != 0的时候调用B::GetSum()
    int n=100;
    A a;
    B b;
    arr[0]=&a;
    arr[1]=&b;
    size_t sum=arr[1]->GetSum(n); 
    cout<<sum<<endl;
}



方法三.使用函数指针的方式来解决

如果面试官不让你使用C++的方法该怎仫办？函数指针可以很好的解决这个问题。

//利用函数指针来实现
typedef size_t (*GetSum)(size_t);
size_t Finish(size_t n)
{
    return 0;
}
size_t Sum_Solution(size_t n)
{
    static GetSum arr[2]={Finish,Sum_Solution};
    return n+arr[!!n](n-1);
}

在这里就分享结束啦~~~

题目：

求 1+2+…+n ，要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句（A?B:C）。

示例 1：

输入: n = 3

输出: 6

示例 2：

输入: n = 9

输出: 45


限制：

1 <= n <= 10000

第一眼看过去：我不敢相信这居然被划分到中等难度的题……这是低估我们的背公式能力吗。return n*(n+1)/2  不就行了吗
然后我仔细看了一下题目要求，发现我题目都没看清楚。
要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句（A?B:C）
本来如果没有要求，我们能想到的方法大概有这几种：

 1.公式，有乘除法；
  2.从1开始正向暴力加法，界定范围最大是n，到n+1需要结束，会用到判断语句；
 3.递归计算 n + func ( n-1 )，界定范围最小是1，到0需要结束，会用到判断语句。

感觉到了死路一条？乘除法是不能用的，那么只能用加减法；正向暴力的加减法，最终的判断条件是 是否到达n，这判断语句无法避免；递归计算，判断条件是 是否到达 1 。
看看第三种方法的特殊性，结束条件0，也可以替换为，0和非0 的区别，那么 boolean 类型的 and 操作是可以使用的，得到和 if 一样的效果。
我们回忆一下 && 操作 的特性： A && B，如果A为true ，就会去执行B ，如果A 为false ，那么就直接跳过了，整个语句是false。
那么，A && B 式子中的 A 就适合填入 边界条件的判断，也就是 n （n减到0的那一刻，就为false了）；B 则可以填入 累加的运算，保证在n还不是0的时候，对结果的更新。
class Solution {
    public int sumNums(int n) {
        int ans=n;

        boolean flag = n>0 && ( ans += sumNums(n-1))>0;

        return ans;
    }
}

注意这里面对于n>0的判断：
flag = n>0

和后面递归的判断：
( ans += sumNums(n-1))>0

都不属于判断语句，而是简单的逻辑操作，所以没有违规。

Java 中，为构成语句，需加一个辅助布尔量 xx ，否则会报错；
Java 中，开启递归函数需改写为 sumNums(n - 1) >0 ，此整体作为一个布尔量输出，否则会报错.

不能轻敌啊。。。这个题如果是面试的时候直接拿出来，还真不一定做的出来