分享个有趣的编程问题
码农有道公众号
共 335字,需浏览 1分钟
· 2022-01-23
大家好,我是吴师兄,周末快乐,分享个有趣的编程问题。
这就是一个求阶乘的问题,大家刚刚开始学编程的时候应该都写过这样的程序。
一个求阶乘的问题,还能玩出什么样的花儿来?
我在回答区看到了一个非常有趣的回答,把各种版本的代码都举例了出来,一个比一个还离谱,后面的代码,甚至让怀疑是我学过的代码吗?
数学家版本:
(简单利索,深藏功与名)
#include
#include
int main()
{
std::cout << std::tgamma(20 + 1) << std::endl;
}
语言学家版本:
(语言学家,你懂得,恨不得把所有语法特性都派上用场)
#include
#include
template<std::size_t...I> constexpr auto foo(std::index_sequence) { return ((I+1) * ...); }
int main()
{
std::cout << foo(std::make_index_sequence<20>()) << std::endl;
}
历史学家版本:
(void main() 有没有嗅到浓厚的历史气息?)
#include
void main(void) {
int i;
long long j;
for(i = 1, j = 1;i <= 20; j *= i++);
printf("%lld", j);
}
敏捷开发上线1.0版本:
(可以说是非常敏捷了)
#include
int main() {
//printf("%d", 1*2*3*4*5*6*7*8*9*10);
printf("%lld", (long long)1*2*3*4*5*6*7*8*9*10*11*12*13*14*15*16*17*18*19*20);
}
面向对象专家版本:
(好家伙,一个简单的问题,愣是祭出了接口、继承、虚函数、虚继承、智能指针等一大堆东西出来,这很面向对象)
#include
#include
#include
struct IBaseInterface {
virtual ~IBaseInterface() = 0;
};
inline IBaseInterface::~IBaseInterface() = default;
struct IDataProvider : virtual public IBaseInterface {
virtual int first() = 0;
virtual int last() = 0;
virtual int next(int v) = 0;
};
struct ICalculator : virtual public IBaseInterface {
virtual long long calc(IDataProvider *) = 0;
};
struct IPrinter : virtual public IBaseInterface {
virtual void print(const std::string &) = 0;
};
struct ISerializer : virtual public IBaseInterface {
virtual std::string serialize(long long value) = 0;
};
struct IRunnable : virtual public IBaseInterface {
virtual void run() = 0;
};
class Foo : virtual public IRunnable {
std::shared_ptr m_dp;
std::shared_ptr m_c;
std::shared_ptr m_s;
std::shared_ptr m_p;
public:
Foo(std::shared_ptr dp, std::shared_ptr c, std::shared_ptr s, std::shared_ptr p) : m_dp(std::move(dp)), m_c(std::move(c)), m_s(std::move(s)),m_p(std::move(p)) {}
void run() override { return m_p->print(m_s->serialize(m_c->calc(m_dp.get()))); }
};
class DefaultSerializer : virtual public ISerializer {
public:
std::string serialize(long long value) override { return std::to_string(value); }
};
class StreamPrinter : virtual public IPrinter {
std::ostream &m_os;
public:
explicit StreamPrinter (std::ostream &os) : m_os(os) {}
void print(const std::string &s) override { m_os << s << std::endl; }
};
class MultiplyAccumulateCalculator : virtual public ICalculator {
public:
long long calc(IDataProvider *dp) override {
int i = dp->first();
long long j = i;
do
j *= (i = dp->next(i));
while(i != dp->last());
return j;
}
};
int main() {
struct MyDataProvider : virtual public IDataProvider {
int first() override { return 1; }
int last() override { return 20; }
int next(int v) override { return v+1; }
};
Foo foo(std::make_shared(), std::make_shared(), std::make_shared(), std::make_shared(std::cout));
foo.run();
}
提前优化的并行版本:
(一看就是精通底层技术的大佬,把CPU拿捏得死死的)
#include
#include
double foo(int x) {
__m128 a = {1.0f, 2.0f, 3.0f, 4.0f};
__m128 b = {4.0f, 4.0f, 4.0f, 4.0f};
__m128 c = {1.0f, 1.0f, 1.0f, 1.0f};
for(int i = 0; i < x / 4; ++i, a = _mm_add_ps(a, b))
c = _mm_mul_ps(c, a);
for(int i = x % 4; i < 4; ++i)
a[i] = 1.0f;
c = _mm_mul_ps(c, a);
return (double)c[0] * (double)c[1] * (double)c[2] * (double)c[3];
}
int main() {
std::cout << foo(20) << std::endl;
}
黑魔法版本:
(能看懂这段代码的,都不是普通人!)
#include
#include
#include
#include
int main() {
std::vector<int> v(std::atoi(std::end(__DATE__) - (__LINE__) / 2) - 1); // 2021年,第六行
std::iota(v.begin(), v.end(), 1);
std::cout << std::accumulate(v.begin(), v.end(), 1ull, std::multiplies<>()) << std::endl;
}
“宏孩儿”元编程版:
(当年看各种C++框架中,排山倒海一样的宏定义,简直令人发指)
#include
// 由于boost.preprocessor仅提供255以下的整数运算
// 所以使用sequence来 (十位个位)(千位百位)(十万位万位) 的方式来表示大整数。
// 不进位加法:(77)(66)(55) + (44)(33)(22) = (121)(99)(77)
#define PP_ADD_N_N_CARRY_OP(R, DATA, I, ELEM) (BOOST_PP_ADD(BOOST_PP_SEQ_ELEM(I, DATA), ELEM))
#define PP_ADD_N_N_CARRY(SEQ_A, SEQ_B) BOOST_PP_SEQ_FOR_EACH_I(PP_ADD_N_N_CARRY_OP, SEQ_A, SEQ_B)
// 进位加法:(121)(99)(77) = (21)(0)(78)
// 注意SEQ_A的长度要比SEQ_B长
#define PP_ADD_N_N_OP(S, STATE, ELEM_CARRY) \
BOOST_PP_SEQ_PUSH_FRONT( \
BOOST_PP_SEQ_REPLACE(STATE, 0, BOOST_PP_MOD(BOOST_PP_ADD(BOOST_PP_SEQ_HEAD(STATE), ELEM_CARRY), 100)), \
BOOST_PP_DIV(BOOST_PP_ADD(BOOST_PP_SEQ_HEAD(STATE), ELEM_CARRY), 100) \
)
#define PP_ADD_N_N(SEQ_A, SEQ_B) BOOST_PP_SEQ_REVERSE(BOOST_PP_SEQ_FOLD_LEFT(PP_ADD_N_N_OP, BOOST_PP_SEQ_NIL(0), PP_ADD_N_N_CARRY(SEQ_A, SEQ_B)))
// 没什么好说的,X*N = X+X+X+X+X+...+X
#define PP_MUL_N_1_EXP_OP(Z, I, DATA) (DATA)
#define PP_MUL_N_1_EXP(SEQ_N, N) BOOST_PP_REPEAT(N, PP_MUL_N_1_EXP_OP, SEQ_N)
#define PP_MUL_N_1_MYOP(S, STATE, ITEM) PP_ADD_N_N(STATE, ITEM)
#define PP_MUL_N_1_FWD(EXP) BOOST_PP_SEQ_FOLD_LEFT(PP_MUL_N_1_MYOP, BOOST_PP_SEQ_HEAD(EXP), BOOST_PP_SEQ_TAIL(EXP))
#define PP_MUL_N_1(SEQ_N, N) PP_MUL_N_1_FWD(PP_MUL_N_1_EXP(SEQ_N, N))
#define FACT5 PP_MUL_N_1(PP_MUL_N_1(PP_MUL_N_1(PP_MUL_N_1((1), 2), 3), 4), 5)
#define FACT10 PP_MUL_N_1(PP_MUL_N_1(PP_MUL_N_1(PP_MUL_N_1(PP_MUL_N_1(FACT5, 6), 7), 8), 9), 10)
#define FACT15 PP_MUL_N_1(PP_MUL_N_1(PP_MUL_N_1(PP_MUL_N_1(PP_MUL_N_1(FACT10, 11), 12), 13), 14), 15)
#define FACT20 PP_MUL_N_1(PP_MUL_N_1(PP_MUL_N_1(PP_MUL_N_1(PP_MUL_N_1(FACT15, 16), 17), 18), 19), 20)
#define FACT25 PP_MUL_N_1(PP_MUL_N_1(PP_MUL_N_1(PP_MUL_N_1(PP_MUL_N_1(FACT20, 21), 22), 23), 24), 25)
static_assert(false, BOOST_PP_STRINGIZE(FACT10));
真·模板元编程版本
(泛型编程,码不惊人死不休)
#include
#include
#include
using BaseType_t = long long;
constexpr BaseType_t lgBase = 9; // 注意10000*10000刚刚好小于int的取值范围
constexpr BaseType_t Base = 1000000000; // 注意10000*10000刚刚好小于int的取值范围
// 大整数的表示
template struct BigInteger {
using type = BigInteger;
};
// 连接
template<class T1, class T2> struct BI_Cat;
template struct BI_Cat , BigInteger> : BigInteger {};
// 左移一个单元(即*Base)
template<class T> struct BI_SHL;
template struct BI_SHL> : BigInteger0> {};
// 去除开头的0
template<class T> struct BI_Remove_Zeros : T {};
template struct BI_Remove_Zeros> : BI_Remove_Zeros> {};
// 填充0到N个单元
template<int X, class IS> struct BI_Fill_Impl;
template<int X, class T, T...I> struct BI_Fill_Impl> : BigInteger<(I, X)...> {};
template<int Size> struct BI_Fill_Zeros : BI_Fill_Impl<0, std::make_index_sequence> {};
template<class T, int N> struct BI_Resize;
templateint N> struct BI_Resize, N> : BI_Cat<typename BI_Fill_Zerossizeof...(I)>::type, BigInteger> {};
// 返回较大的数值
template<int A, int B> struct int_min : std::integral_constant<int, (A {};
// 非进位加法:先把两个数的位数改成一样的然后依次相加
template<class A, class B, class ShouldResize> struct BI_AddNotCarry_Impl;
template struct BI_AddNotCarry_Impl , BigInteger, std::true_type> : BigInteger<(I1 + I2)...> {};
template struct BI_AddNotCarry_Impl , BigInteger, std::false_type>
: BI_AddNotCarry_Impl<
typename BI_Resize, int_min<sizeof...(I1), sizeof...(I2)>::value>::type,
typename BI_Resize, int_min<sizeof...(I1), sizeof...(I2)>::value>::type,
std::true_type
>{};
template<class A, class B> struct BI_AddNotCarry;
template struct BI_AddNotCarry , BigInteger>
: BI_AddNotCarry_Impl, BigInteger, std::bool_constant<sizeof...(I1) == sizeof...(I2)>> {};
// 判断是否为0
template<class Y> struct BI_IsZero;
template struct BI_IsZero> : std::bool_constant<((I == 0) && ...)> {};
// 自动进位
template<class A> struct BI_Carry;
template<class A, class B> struct BI_Add : BI_Carry<typename BI_AddNotCarry::type> {};
template<class Mod, class Div, class ShouldCalc = typename BI_IsZero::type> struct BI_Carry_Impl;
template<class Mod, class Div> struct BI_Carry_Impl : Mod {};
template<class Mod, class Div> struct BI_Carry_Impl
: BI_Addtypename BI_SHL::type > {};
template struct BI_Carry>
: BI_Remove_Zeros<typename BI_Carry_Impl, BigInteger<(I / Base)...>>::type> {};
// 乘以X并自动进位
template<class A, int X> struct BI_MulX;
templateint X> struct BI_MulX , X>
: BI_Carry> {};
// 计算阶乘
template<int X> struct BI_Fact : BI_MulX<typename BI_Fact-1>::type, X> {};
template<> struct BI_Fact<0> : BigInteger<1> {};
template
std::ostream &operator<<(std::ostream &out, BigInteger) {
return ((out << std::setfill('0') << I << std::setw(lgBase)), ...);
}
int main()
{
std::cout << typename BI_Fact<20>::type() << std::endl;
}
原回答:
https://www.zhihu.com/question/365763395/answer/971009059
不得不服,这位老哥真是人才,把 C++ 玩出这么多花样,不愧是语言学家。当然,现实工作中不会有人这样写代码的,所以大家图个乐就好,不用较真。
你们在第几个版本倒下了?
我反正看到面向对象专家版本就已经忍不住了···
评论
如何画出漂亮的神经网络图?神经网络可视化工具集锦搜集
点击上方“小白学视觉”,选择加"星标"或“置顶”重磅干货,第一时间送达1. draw_convnet一个用于画卷积神经网络的Python脚本https://github.com/gwding/draw_convnet2. NNSVGhttp://alexlenail.me/NN-SVG/LeNet.
小白学视觉
0
如何看待稚晖君的时间管理水平?
点击上方“小白学视觉”,选择加"星标"或“置顶”重磅干货,第一时间送达计算机视觉life整理原文链接:https://www.zhihu.com/question/491456524/answer/2183081310稚晖君究竟是如何安排业余时间去做这么多高水平的项目?而且每个项目的用时也很少,普通
小白学视觉
2
三个优秀的PyTorch实现语义分割框架
点击上方“小白学视觉”,选择加"星标"或“置顶”重磅干货,第一时间送达转自 | 机器学习AI算法工程使用的VOC数据集链接开放在文章中,预训练模型已上传Github,环境我使用Colab pro,大家下载模型做预测即可。代码链接: https://github.com/lixiang007
小白学视觉
0
如何确定神经网络的层数和隐藏层神经元数量?
点击上方“小白学视觉”,选择加"星标"或“置顶”重磅干货,第一时间送达公众号:尤而小屋作者:呦呦鹿鸣编辑:Peter大家好,我是Peter~关于神经网络中隐藏层的层数和神经元个数充满了疑惑。刚好看到一篇文章很好地答疑了,分享给大家~https://zhuanlan.zhihu.com/p/10041
小白学视觉
0
神经网络之CNN与RNN的关系
点击上方“小白学视觉”,选择加"星标"或“置顶”重磅干货,第一时间送达1、CNN介绍CNN是一种利用卷积计算的神经网络。它可以通过卷积计算将原像素很大的图片保留主要特征变成很小的像素图片。本文以李宏毅老师ppt内容展开具体介绍。1.1 Why CNN for Image①为什么引入CNN ?图片示意
小白学视觉
0
“海优最初弄出来可并不是为了给大佬弟子开后门的, 学术界现在几乎不存在任何套利空间,不要相信有什么办法可以投机取巧”
点击上方“小白学视觉”,选择加"星标"或“置顶”重磅干货,第一时间送达知乎问题:为什么部分同学倾向土博+国外博后而不是直接国外读博?感觉身边土博越来越多,基本都是土博➕海博后,申国外phd的明显减少(相比较疫情之前几年)知乎Tianteman: 这个问题下,可以看得出一部分国内硕博信息检索能力差的离
小白学视觉
0
真高!比亚迪员工爆料比亚迪在越南的薪资水平:基本工资480万,全勤奖35万,交通补助20万,餐补110万,每周6天,每天10小时
上一篇:某大公司为逼迫员工离职,竟然把他的工位安排到厕所旁,没想到他直接开始记录领导的如厕时间,还发到公司大群...对此,你怎么看?--完--PS:欢迎在留言区留下你的观点,一起讨论提高。如果今天的文章让你有新的启发,欢迎转发分享给更多人。全文完,感谢你的耐心阅读。如果你还想看到我的文章,请一定给本
开发者全社区
0
太敢穿了!透视纱裙!性感火辣的身材
绝了呀今天的厂花:吴宣仪1995年1月26日,吴宣仪出生于海南省海口市,中国内地流行乐女歌手、影视演员。2016年2月,吴宣仪随宇宙少女发行首张迷你专辑正式出道。2018年4月,她参加《创造101》综艺选秀,获得第二名,成功加入火箭少女101组合。吴宣仪的颜值一直备受称赞,她的五官立体精致,皮肤白皙
逆锋起笔
0