LychrelNumber实现V1.0

一、代码

1.main.cpp

#include <iostream>

using namespace std;

#include "BigNumber.h"

#define MAX_RANGE 1000
#define TIME 10000

#define UNKNOWN -1
#define YES 1

CBigNumber next[TIME+5] = {0};

void init();
int caculate(int number);
void result(int number, int ret);
void setAllInNextTable(bool result);

int main()
{
for(int i = 1; i < MAX_RANGE; i++)
{
init();
int ret = caculate(i);
result(i, ret);
}
return 0;
}

void init()
{
memset(next, 0, sizeof(next));
}

int caculate(int number)
{
int cnt = 0;
CBigNumber temp(number);
int ret;
while((ret = temp.isLychrelNumber()) == UNKNOWN)
{
if(cnt > TIME)
{
ret = YES;
break;
}
temp.add();
next[cnt++] = temp;
}
return ret;
}

void result(int number, int ret)
{
if(ret == YES)
{
setAllInNextTable(false);
cout<<number<<endl;
}
else
{
setAllInNextTable(true);
}
}

void setAllInNextTable(bool result)
{
for(int i = 0; next[i].size != 0; i++)
{
next[i].setValue(result);
}
}

2.BigNumber.h

#define MAX_TABLE_SIZE 1000000
#define MAX_DIGIT 18

bool value[MAX_TABLE_SIZE] = {0};
bool isCaculated[MAX_TABLE_SIZE] = {0};

bool isReverse(long long number)
{
int word[10] = {0};
int cnt = 0;
while(number)
{
word[cnt++] = number % 10;
number /= 10;
}
for(int i = 0; i < cnt; i++)
{
if( word[i] !=  word[cnt - i - 1])
{
return false;
}
}
return true;
}

bool isAllDigitSmallerThan5(long long number)
{
while(number)
{
int last = number % 10;
if(last >= 5)
return false;
number /= 10;
}
return true;
}

int isLychrelNumber(long long number)
{
if(isReverse(number) == true)
return 0;

if(isAllDigitSmallerThan5(number) == true)
return 0;

if(number >= MAX_TABLE_SIZE || isCaculated[number] == false)
return -1;

return !value[number];
}

#define MAX_SIZE 200
class CBigNumber
{
private:
long long data[MAX_SIZE];
bool isNumberTooBig();
bool isReverse();
bool isAllDigitSmallerThan5();
bool isInRecord();
public:
int size;
CBigNumber();
CBigNumber(const CBigNumber &B);
CBigNumber(long long normalData);
int isLychrelNumber();
void add();
void setValue(bool flag);
void print();
CBigNumber &operator=(const CBigNumber & B);
bool operator==(const CBigNumber & B);
CBigNumber getReverseNumber();
};
CBigNumber::CBigNumber()
{
size = 0;
memset(data, 0, sizeof(data));
}
CBigNumber::CBigNumber(const CBigNumber &B)
{
size = B.size;
for(int i = 0; i < B.size; i++)
data[i] = B.data[i];
}
CBigNumber::CBigNumber(long long normalData)
{
memset(data, 0, sizeof(data));
data[0] = normalData;
size = 1;
}
int CBigNumber::isLychrelNumber()
{
if(size == 1)
return ::isLychrelNumber(data[0]);

if(isNumberTooBig() == true)
return 1;

if(isReverse() == true)
return 0;

if(isAllDigitSmallerThan5() == true)
return 0;

if(isInRecord() == false)
return -1;

return !value[data[0]];
}
void CBigNumber::add()
{
CBigNumber reverse = getReverseNumber();
for(int i = 0; i < size; i++)
{
data[i] = data[i] + reverse.data[i];
if(data[i] > 1000000000000000000)
{
data[i] = data[i] - 1000000000000000000;
data[i+1]++;
}
}
if(data[size] > 0)
size++;
}
void CBigNumber::setValue(bool flag)
{
if(size == 1 && data[0] < MAX_TABLE_SIZE)
{
isCaculated[data[0]] = true;
value[data[0]] = flag;
}
}
void CBigNumber::print()
{
for(int i = 0; i < size; i++)
cout<<data[i];
}
CBigNumber& CBigNumber::operator=(const CBigNumber & B)
{
size = B.size;
for(int i = 0; i < size; i++)
data[i] = B.data[i];
return *this;
}
bool CBigNumber::operator==(const CBigNumber & B)
{
if(size != B.size)
return false;
for(int i = 0; i < size; i++)
if(data[i] != B.data[i])
return false;
return true;
}
bool CBigNumber::isNumberTooBig()
{
if(size >= MAX_SIZE)
return true;
return false;
}
bool CBigNumber::isReverse()
{
CBigNumber reverse = getReverseNumber();
if(reverse == *this)
return true;
else
return false;
}
bool CBigNumber::isAllDigitSmallerThan5()
{
for(int i = 0; i < size; i++)
if(::isAllDigitSmallerThan5(data[i]) =
7fe0
= false)
return false;
return true;
}
bool CBigNumber::isInRecord()
{
if(size > 1)
return false;
if(data[0] >= MAX_TABLE_SIZE)
return false;
return isCaculated[data[0]];
}
CBigNumber CBigNumber::getReverseNumber()
{
CBigNumber ret;

int digit[10000] = {0}, start;
for(int i = 0; i < size; i++)
{
start = i * 18;
long long temp = data[i];
while(temp)
{
digit[start++] = temp % 10;
temp = temp / 10;
}
}

memset(ret.data, 0, sizeof(ret.data));
for(int i = 0; i < start; i+=18)
{
for(int j = i; j < i+18; j++)
{
if(j >= start)break;
ret.data[ret.size] = ret.data[ret.size] * 10 + digit[j];
}
ret.size++;
}
return ret;
}

二、评论

1.main.cpp逻辑太复杂

2.不应该在.h中写实现代码

3.int CBigNumber::isLychrelNumber()函数太长，其中的判断不在一个逻辑层次

4.isNumberTooBig()优化效果不明显，却严重影响代码阅读，建议去掉

5.Record是对中间过程的缓存，建议更名为buffer

6.部分魔应定义为宏

7.垂直的函数顺序不好，应参考《代码简洁之道》5.2.3和5.2.5

8.部分命名需要重新设计