面试题之发散思维能力：如何用非常规方法求1+2+···+n
时间:2016-06-01 11:51 来源:linux.it.net.cn 作者:IT
今天在《剑指offer》里看到了下面这样一个简单且有趣的题，考察程序员的发散思维能力，前提是你对C++相关知识点熟悉，否则是想不出来方案的，分享给大家。
题目：求1+2+···+n，要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句（A?B:C）。
点评：这个问题本身没有太多的实际意义，因为在软件开发中不可能有这么苛刻的限制。但不少面试官认为这是一道不错的能够考查应聘者发散思维能力的题目，而发散思维能够反映出应聘者知识面的宽度，以及对编程相关技术理解的深度。
分析：通常求1+2+ ··· +n有三种常规思路：（1）循环；（2）递归（需要用if语句或者条件判断语句来判断是继续递归下去还是终止递归）；（3）使用公式n*(n+1)/2。因为题目限制，这三种常规方案都不可行。那么如何用非常规方案求解该问题呢？下面提供两种解题思路，对应四种解决方案，本质上还是采用循环或递归的思路，只是写法改变了。
解题思路一：循环角度
基本思想：从循环角度思考。循环只是让相同的代码重复执行n遍而已，我们完全可以不用for和while来达到这个目的。比如下面采用的构造函数法。
方案一：利用构造函数求解
具体方案：我们先定义一个类型，接着创建n个该类型的实例，那么这个类型的构造函数将确定会被调用n次。我们可以将与累加相关的代码放到构造函数里。
实现代码：
class Temp
{
public:
Temp() { ++N; Sum += N; }
static void init() { 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::init();
Temp *temp = new Temp[n];
delete []temp;
temp = NULL;
return Temp::getSum();
}
解题思路二：递归角度
基本思想：从递归角度思考。根据题目限制我们不能在一个函数中判断递归终止的条件，那么我们不妨定义两个函数：一个函数充当原递归函数中递归的角色，另一个函数处理递归终止的情况，我们需要做的就是在两个函数里二选一。从二选一我们很自然的想到布尔变量，比如值为true（1）的时候调用第一个函数，值为false（0）的时候调用第二个函数。那如何将数值变量n转换成布尔变量呢？解决方法就是对n连续做两次取反运算，即!!n，这样非零的n就会转换为true，0就转换为false。
基于该思想有下面三种解决方案。
方案二：利用虚函数求解
具体方案：用虚函数来实现函数的选择。比如父类虚函数处理递归终止，子类虚函数实现递归累加，那么当n不为0时，调用子类函数，n为0时调用父类函数即可完成计算。
实现代码：
class Base;
Base* array[2];
class Base
{
public:
virtual unsigned int sum(unsigned int n)
{
return 0;
}
};
class Derived : public Base
{
public:
virtual unsigned int sum(unsigned int n)
{
return array[!!n]->sum(n - 1) + n;
}
};
unsigned int sum_solution2(unsigned int n)
{
Base b;
Derived d;
array[0] = &b;
array[1] = &d;
return array[1]->sum(n);
}
方案三：利用函数指针求解
具体方案：在纯C语言的编程环境中，我们不能使用虚函数，此时可以用函数指针来模拟，这样代码可能还更加直观一些。
实现代码：
typedef unsigned int (*fun)(unsigned int);
unsigned int sum_terminator(unsigned int n)
{
return 0;
}
unsigned int sum_solution3(unsigned int n)
{
fun f[2] = {sum_terminator, sum_solution3};
return f[!!n](n - 1) + n;
}
方案四：利用模板类型求解
具体方案：最后我们还可以让编译器来帮助完成类似于递归的计算。例如利用模板类型，以n作为模板参数。
实现代码：
template <unsigned int n> struct sum
{
enum value { N = sum<n - 1>::N + n };
};
template <> struct sum<1>
{
enum value { N = 1 };
};
说明：sum<100>::N就是1+2+···+100的结果。该方法有明显的缺陷，由于该计算过程是在编译过程中完成的，因此要求输入n必须是在编译期间就能确定的常量，也就是我们不能动态输入n，这是最大的缺点，而且编译器对递归编译代码的递归深度是有限制的，也就是要求n不能太大。
综合测试代码：
#include <iostream>
using namespace std;
unsigned int sum_solution1(unsigned int n);
unsigned int sum_solution2(unsigned int n);
unsigned int sum_solution3(unsigned int n);
unsigned int sum_solution4(unsigned int n);
unsigned int main()
{
unsigned int n;
scanf("%d", &n);
printf("sum_solution1(%d): %d\n", n, sum_solution1(n));
printf("sum_solution2(%d): %d\n", n, sum_solution2(n));
printf("sum_solution3(%d): %d\n", n, sum_solution3(n));
printf("sum_solution4(%d): %d\n", 100, sum_solution4(n));
return 0;
}
/************** solution 1 ***************/
class Temp
{
public:
Temp() { ++N; Sum += N; }
static void init() { 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::init();
// Temp temp[] = new Temp[n];
Temp *temp = new Temp[n];
delete []temp;
temp = NULL;
return Temp::getSum();
}
/************** solution 2 ***************/
class Base;
Base* array[2];
class Base
{
public:
virtual unsigned int sum(unsigned int n)
{
return 0;
}
};
class Derived : public Base
{
public:
virtual unsigned int sum(unsigned int n)
{
return array[!!n]->sum(n - 1) + n;
}
};
unsigned int sum_solution2(unsigned int n)
{
Base b;
Derived d;
array[0] = &b;
array[1] = &d;
return array[1]->sum(n);
}
/************** solution 3 ***************/
typedef unsigned int (*fun)(unsigned int);
unsigned int sum_terminator(unsigned int n)
{
return 0;
}
unsigned int sum_solution3(unsigned int n)
{
fun f[2] = {sum_terminator, sum_solution3};
return f[!!n](n - 1) + n;
}
/************** solution 4 ***************/
template <unsigned int n> struct sum
{
enum value { N = sum<n - 1>::N + n };
};
template <> struct sum<1>
{
enum value { N = 1 };
};
unsigned int sum_solution4(unsigned int n)
{
return sum<100>::N; // 必须指定常数
}
View Code
运行结果：
大家还能想出其它的解决方案吗？欢迎补充~~~
------------------------------------分割线-----------------------------------------
2014.2.12更新：
感谢博客园网友张海拔的补充，提供了下面这个非常简单的解决方案：
#include <stdio.h>
int main(void)
{
int n;
scanf("%d", &n);
char a[n][n];
printf("sum = %d\n", ((int)sizeof a + n)>>1);
return 0;
}
在Linux下用gcc测试的确可行，不过需要C99可变长参数的支持，因此在微软编辑器下是编译不成功的。本文只从三种常规方案的循环和递归两种方案提供解题思路，这里从公式n*(n+1)/2出发，提供了第三种解题思路，不失为一种好的解决方案。
(责任编辑：IT)
今天在《剑指offer》里看到了下面这样一个简单且有趣的题，考察程序员的发散思维能力，前提是你对C++相关知识点熟悉，否则是想不出来方案的，分享给大家。
题目：求1+2+···+n，要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句（A?B:C）。
点评：这个问题本身没有太多的实际意义，因为在软件开发中不可能有这么苛刻的限制。但不少面试官认为这是一道不错的能够考查应聘者发散思维能力的题目，而发散思维能够反映出应聘者知识面的宽度，以及对编程相关技术理解的深度。
分析：通常求1+2+ ··· +n有三种常规思路：（1）循环；（2）递归（需要用if语句或者条件判断语句来判断是继续递归下去还是终止递归）；（3）使用公式n*(n+1)/2。因为题目限制，这三种常规方案都不可行。那么如何用非常规方案求解该问题呢？下面提供两种解题思路，对应四种解决方案，本质上还是采用循环或递归的思路，只是写法改变了。
解题思路一：循环角度
基本思想：从循环角度思考。循环只是让相同的代码重复执行n遍而已，我们完全可以不用for和while来达到这个目的。比如下面采用的构造函数法。
方案一：利用构造函数求解
具体方案：我们先定义一个类型，接着创建n个该类型的实例，那么这个类型的构造函数将确定会被调用n次。我们可以将与累加相关的代码放到构造函数里。
实现代码：
class Temp
{
public:
Temp() { ++N; Sum += N; }
static void init() { 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::init();
Temp *temp = new Temp[n];
delete []temp;
temp = NULL;
return Temp::getSum();
}
解题思路二：递归角度
基本思想：从递归角度思考。根据题目限制我们不能在一个函数中判断递归终止的条件，那么我们不妨定义两个函数：一个函数充当原递归函数中递归的角色，另一个函数处理递归终止的情况，我们需要做的就是在两个函数里二选一。从二选一我们很自然的想到布尔变量，比如值为true（1）的时候调用第一个函数，值为false（0）的时候调用第二个函数。那如何将数值变量n转换成布尔变量呢？解决方法就是对n连续做两次取反运算，即!!n，这样非零的n就会转换为true，0就转换为false。
基于该思想有下面三种解决方案。
方案二：利用虚函数求解
具体方案：用虚函数来实现函数的选择。比如父类虚函数处理递归终止，子类虚函数实现递归累加，那么当n不为0时，调用子类函数，n为0时调用父类函数即可完成计算。
实现代码：
class Base;
Base* array[2];
class Base
{
public:
virtual unsigned int sum(unsigned int n)
{
return 0;
}
};
class Derived : public Base
{
public:
virtual unsigned int sum(unsigned int n)
{
return array[!!n]->sum(n - 1) + n;
}
};
unsigned int sum_solution2(unsigned int n)
{
Base b;
Derived d;
array[0] = &b;
array[1] = &d;
return array[1]->sum(n);
}
方案三：利用函数指针求解
具体方案：在纯C语言的编程环境中，我们不能使用虚函数，此时可以用函数指针来模拟，这样代码可能还更加直观一些。
实现代码：
typedef unsigned int (*fun)(unsigned int);
unsigned int sum_terminator(unsigned int n)
{
return 0;
}
unsigned int sum_solution3(unsigned int n)
{
fun f[2] = {sum_terminator, sum_solution3};
return f[!!n](n - 1) + n;
}
方案四：利用模板类型求解
具体方案：最后我们还可以让编译器来帮助完成类似于递归的计算。例如利用模板类型，以n作为模板参数。
实现代码：
template <unsigned int n> struct sum
{
enum value { N = sum<n - 1>::N + n };
};
template <> struct sum<1>
{
enum value { N = 1 };
};
说明：sum<100>::N就是1+2+···+100的结果。该方法有明显的缺陷，由于该计算过程是在编译过程中完成的，因此要求输入n必须是在编译期间就能确定的常量，也就是我们不能动态输入n，这是最大的缺点，而且编译器对递归编译代码的递归深度是有限制的，也就是要求n不能太大。
综合测试代码：
#include <iostream>
using namespace std;
unsigned int sum_solution1(unsigned int n);
unsigned int sum_solution2(unsigned int n);
unsigned int sum_solution3(unsigned int n);
unsigned int sum_solution4(unsigned int n);
unsigned int main()
{
unsigned int n;
scanf("%d", &n);
printf("sum_solution1(%d): %d\n", n, sum_solution1(n));
printf("sum_solution2(%d): %d\n", n, sum_solution2(n));
printf("sum_solution3(%d): %d\n", n, sum_solution3(n));
printf("sum_solution4(%d): %d\n", 100, sum_solution4(n));
return 0;
}
/************** solution 1 ***************/
class Temp
{
public:
Temp() { ++N; Sum += N; }
static void init() { 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::init();
// Temp temp[] = new Temp[n];
Temp *temp = new Temp[n];
delete []temp;
temp = NULL;
return Temp::getSum();
}
/************** solution 2 ***************/
class Base;
Base* array[2];
class Base
{
public:
virtual unsigned int sum(unsigned int n)
{
return 0;
}
};
class Derived : public Base
{
public:
virtual unsigned int sum(unsigned int n)
{
return array[!!n]->sum(n - 1) + n;
}
};
unsigned int sum_solution2(unsigned int n)
{
Base b;
Derived d;
array[0] = &b;
array[1] = &d;
return array[1]->sum(n);
}
/************** solution 3 ***************/
typedef unsigned int (*fun)(unsigned int);
unsigned int sum_terminator(unsigned int n)
{
return 0;
}
unsigned int sum_solution3(unsigned int n)
{
fun f[2] = {sum_terminator, sum_solution3};
return f[!!n](n - 1) + n;
}
/************** solution 4 ***************/
template <unsigned int n> struct sum
{
enum value { N = sum<n - 1>::N + n };
};
template <> struct sum<1>
{
enum value { N = 1 };
};
unsigned int sum_solution4(unsigned int n)
{
return sum<100>::N; // 必须指定常数
}
运行结果：
大家还能想出其它的解决方案吗？欢迎补充~~~
------------------------------------分割线-----------------------------------------
2014.2.12更新：
感谢博客园网友张海拔的补充，提供了下面这个非常简单的解决方案：
#include <stdio.h>
int main(void)
{
int n;
scanf("%d", &n);
char a[n][n];
printf("sum = %d\n", ((int)sizeof a + n)>>1);
return 0;
}
在Linux下用gcc测试的确可行，不过需要C99可变长参数的支持，因此在微软编辑器下是编译不成功的。本文只从三种常规方案的循环和递归两种方案提供解题思路，这里从公式n*(n+1)/2出发，提供了第三种解题思路，不失为一种好的解决方案。 (责任编辑：IT) |