博客园_this.Study(DateTime.Now)

Linux进程相关的一些笔记

2011-07-25T06:29:00Z

Linux进程相关的一些笔记

周银辉

跑去搞医疗CT了，接触到的都是Linux，这段时间学习了一些Linux进程以及进程间通信（IPC），将其整理了一下，有四十多页，不便直接贴成博文，那就打包下载吧。

下载地址： http://files.cnblogs.com/zhouyinhui/processNotes.zip

我是Linux新手，所以笔记中难免有理解得不到位甚至错误的地方，若发现，淡定地留言便可，我改...

本文链接

[Project Euler] 来做欧拉项目练习题吧: 题目020

2011-04-20T14:58:00Z

[Project Euler] 来做欧拉项目练习题吧: 题目020

周银辉　

题目描述:

n! means n x (n 1) x ... x 3 x 2 x 1

For example, 10! = 10 x 9 x ... x 3 x 2 x 1 = 3628800,
and the sum of the digits in the number 10! is 3 + 6 + 2 + 8 + 8 + 0 + 0 = 27.

Find the sum of the digits in the number 100!

题目分析:

求100!所得结果的各位数字之和

做法可以有两种：

一是做大数乗法，对于Java内置了BigInteger，或者Scheme可以实现无限精度的语言而已，问题就很简单。

否则自己模拟大数乗法，正如下面的multiply。

#include <stdio.h>

#include <math.h>

#include <stdlib.h>

#include <string.h>

#define BF_SZ 1000 //buffer size

//将整数转换成字符串，并传出长度, 请手动释放返回值

//stdlib中的itoa也能完成类似的功能，

//但stdlib传入的buffer长度未知，一般会设置得比较大，而造成浪费

char* int_to_str(int n, int* length)

{

*length = floor(log10(abs(n!=0?n:1))) + 1;

char *str = (char*)calloc(sizeof(char)*(*length+1));

int i = *length-1;

while(n!=0)

{

str[i] = n%10+48;

n = n/10;

i--;

}

return str;

}

//大数乗法，结果放在r中

void multiply(const char *a,const char *b, char *r)

{

int i, j, *t, length_a, length_b, length_t; // t for temp

length_a = strlen(a);

length_b = strlen(b);

length_t = length_a + length_b;

t=(int*)malloc(sizeof(int)*length_t);

for(i=0; i<length_t; i++)

{

t[i]=0;

}

for (i=0; i<length_a; i++)

{

for (j=0;j<length_b;j++)

{

t[i+j+1] += (a[i]-48)*(b[j]-48);

}

// 这里实现进位操作

for (i=length_t-1; i>=0; i--)

{

if(t[i]>=10)

{

t[i-1] += t[i]/10;

t[i] %= 10;

}

i=0;

while(t[i]==0)

{

i++; // 跳过数前面的0

}

for (j=0; i<length_t; i++,j++)

{

r[j] = t[i]+48;

}

r[j]='\0';

free(t);

}

int test(int n, char* buffer, char* temp)

{

int i, j, k, a, b, c, p; //p for product

int len;

for(i=2; i<=n; i++)

{

char *str = int_to_str(i, &len);

//printf("%s\t", str);

//做buffer和str的大数乘法

multiply(buffer, str, buffer);

free(str);

}

return 0;

}

int main()

{

char* buffer = (char*)malloc(BF_SZ*sizeof(char));

char* temp = (char*)malloc(BF_SZ* sizeof(char));

memset(buffer, '0', BF_SZ);

buffer[BF_SZ-1] = '1';

memset(temp, '0', BF_SZ);

test(100, buffer, temp);

printf("buffer is %s\n", buffer);

int i, len=strlen(buffer), count=0;

for (i=0; i<len; i++)

{

count += buffer[i]-48;

}

printf("the count is %d\n", count);

free(buffer);

free(temp);

return 0;

}

二是做大数阶乘：

#include <stdio.h>

#include <stdlib.h>

int buffer[1000];

void multiply(int buffer[],int n,int *length)

{

int c=0, i, len=*length;

for(i=0; i<len; i++)

{

buffer[i] = buffer[i]*n + c;

c = buffer[i]/10;

buffer[i]%=10;

}

while(c!=0)

{

buffer[len++] = c%10;

c /= 10;

}

*length=len;

}

main()

{

buffer[0]=1;

int i, n=100, len=1;

for(i=2; i<=n; i++)

{

multiply(buffer, i, &len);

}

for(i=len-1; i>=0; i--)

{

printf("%d",buffer[i]);

}

printf("\n");

}

这种模拟大数运算的题目要求细心和耐性,其它便没什么了

本文链接

[Project Euler] 来做欧拉项目练习题吧: 题目019

2011-04-19T12:38:00Z

[Project Euler] 来做欧拉项目练习题吧: 题目019

周银辉

题目描述:

You are given the following information, but you may prefer to do some research for yourself.

1 Jan 1900 was a Monday.
Thirty days has September,
April, June and November.
All the rest have thirty-one,
Saving February alone,
Which has twenty-eight, rain or shine.
And on leap years, twenty-nine.
A leap year occurs on any year evenly divisible by 4, but not on a century unless it is divisible by 400.

How many Sundays fell on the first of the month during the twentieth century (1 Jan 1901 to 31 Dec 2000)?

问题分析:

计算从1901年到2000年间，有多少个星期天是在月初。

题目说1900年1月1日是星期一，也就是说1900年1月7日是星期天，那么从这天开始每增加7天都是星期天。

然后问题就转换成了这些星期天中哪些是在月初。

高级语言都内置了日期函数，如果用类似于date.addDays(n)之类的函数，这个问题就变得非常简单了。

不使用内置函数的话，就用下面的get_days和get_date方法吧:

#include <stdio.h>

long get_days(long y, long m, long d)

{

m = (m + 9)%12; /* mar=0, feb=11 */

y = y - m/10; /* if Jan/Feb, year-- */

return y*365 + y/4 - y/100 + y/400 + (m*306 + 5)/10 + (d - 1);

}

void get_date(long days, long* y, long* m, long* d)

{

long yy, ddd, mm, dd, mi;

yy = (10000*days + 14780)/3652425;

ddd = days - (yy*365 + yy/4 - yy/100 + yy/400);

if (ddd < 0)

{

yy--;

ddd = days - (yy*365 + yy/4 - yy/100 + yy/400);

}

mi = (52 + 100*ddd)/3060;

*y = yy + (mi + 2)/12;

*m = (mi + 2)%12 + 1;

*d = ddd - (mi*306 + 5)/10 + 1;

}

int main()

{

long count = 0;

long year = 1900;

long month;

long day;

long days = get_days(1900, 1, 7);

while(1)

{

days += 7; //增加7天，肯定是星期天

//取得该天的日期，判断其是否是1号

get_date(days, &year, &month, &day);

//printf("%ld-%ld-%ld\n", year, month, day);

if (year>2000)

{

break;

}

if(day==1 && year>=1901)

{

//今天是1号，那么至少要等28天以后才可能是1号了，下次循环是要加7天，所以这里加21天

//避免无用的运算

days += 21;

count ++;

}

printf("total count %ld\n", count);

return 0;

}

此题几乎不需要多少时间:

real 0m0.005s

user 0m0.001s

sys 0m0.003s

本文链接

[Project Euler] 来做欧拉项目练习题吧: 题目018

2011-03-29T14:28:00Z

[Project Euler] 来做欧拉项目练习题吧: 题目018

周银辉

问题描述：

By starting at the top of the triangle below and moving to adjacent numbers on the row below, the maximum total from top to bottom is 23.

3
7 4
2 4 6
8 5 9 3

That is, 3 + 7 + 4 + 9 = 23.

Find the maximum total from top to bottom of the triangle below:

75
95 64
17 47 82
18 35 87 10
20 04 82 47 65
19 01 23 75 03 34
88 02 77 73 07 63 67
99 65 04 28 06 16 70 92
41 41 26 56 83 40 80 70 33
41 48 72 33 47 32 37 16 94 29
53 71 44 65 25 43 91 52 97 51 14
70 11 33 28 77 73 17 78 39 68 17 57
91 71 52 38 17 14 91 43 58 50 27 29 48
63 66 04 68 89 53 67 30 73 16 69 87 40 31
04 62 98 27 23 09 70 98 73 93 38 53 60 04 23

NOTE: As there are only 16384 routes, it is possible to solve this problem by trying every route. However, Problem 67, is the same challenge with a triangle containing one-hundred rows; it cannot be solved by brute force, and requires a clever method!

问题分析：

题目中数据看上去是一个三角形，但由于题目要求的是从一个点出发沿着其相邻的两个点向下一行前进，点和其下一行相邻的两个点刚好构成一个二叉树。

设A[i,j]表示第i行的第j个数，那么A[i,j]相邻的两个点就是A[i+1,j]和A[i+1,j+1]，也就是它的左右子树。

变化成二叉树就好办了.设best[A]表示以点A出发点并且满足题目要求的运算结果，节点A在数组中对应的数值为(A)，节点A的左右子树分别为B和C，

那么best[A] = (A) + max(best[B], best[C])，呵呵，递归的

（参考代码中的buffer是为了避免重复递归运算而设置的缓冲区 )

#include <stdio.h>

#define SZ 15

#define END (SZ-1)

int data[SZ][SZ] =

{

{75},

{95, 64},

{17, 47, 82},

{18, 35, 87, 10},

{20, 4, 82, 47, 65},

{19, 1, 23, 75, 3, 34},

{88, 2, 77, 73, 7, 63, 67},

{99, 65, 4, 28, 6, 16, 70, 92},

{41, 41, 26, 56, 83, 40, 80, 70, 33},

{41, 48, 72, 33, 47, 32, 37, 16, 94, 29},

{53, 71, 44, 65, 25, 43, 91, 52, 97, 51, 14},

{70, 11, 33, 28, 77, 73, 17, 78, 39, 68, 17, 57},

{91, 71, 52, 38, 17, 14, 91, 43, 58, 50, 27, 29, 48},

{63, 66, 4, 68, 89, 53, 67, 30, 73, 16, 69, 87, 40, 31},

{ 4, 62, 98, 27, 23, 9, 70, 98, 73, 93, 38, 53, 60, 4, 23}

};

int buffer[SZ][SZ];

int test(int i, int j)

{

if(j>i) //j>i时是上面数组中没有显式标明数字的那些区域，不参与运算

{

return 0;

}

int sum, sumLeft=0, sumRight=0, ni, nj; // ni: next i

int currentNode;

currentNode = data[i][j];

if(i==END)

{

return currentNode;

}

ni = i+1;

nj = j+1;

if(ni<SZ)

{

if(buffer[ni][j] != 0)

{

sumLeft = buffer[ni][j];

}

else

{

sumLeft = test(ni, j);

buffer[ni][j] = sumLeft;

}

if(nj<SZ)

{

if(buffer[ni][nj] != 0)

{

sumRight = buffer[ni][nj];

}

else

{

sumRight = test(ni, nj);

buffer[ni][nj] = sumRight;

}

sum = currentNode + (sumLeft>sumRight ? sumLeft:sumRight);

buffer[i][j] = sum;

return sum;

}

int main()

{

printf("result is %d\n", test(0,0));

return 0;

}

速度还不错（intel 双核2.4G）：

real 0m0.004s

user 0m0.001s

sys 0m0.003s

本文链接

[Project Euler] 来做欧拉项目练习题吧: 题目017

2011-03-03T11:56:00Z

[Project Euler] 来做欧拉项目练习题吧: 题目017

周银辉

题目描述:

If the numbers 1 to 5 are written out in words: one, two, three, four, five, then there are 3 + 3 + 5 + 4 + 4 = 19 letters used in total.

If all the numbers from 1 to 1000 (one thousand) inclusive were written out in words, how many letters would be used?

NOTE: Do not count spaces or hyphens. For example, 342 (three hundred and forty-two) contains 23 letters and 115 (one hundred and fifteen) contains 20 letters. The use of "and" when writing out numbers is in compliance with British usage.

问题分析:

这个题目比较简单哈，用铅笔和纸也比如容易算出啦。比如计算单个数字的出现次数，"hundred"单词出现的次数等等。

而用程序计算嘛，关键在于创建一个数字和对应单词长度的映射，也就是上面numbers那个数组。

然后分离出百位数、十位数、个位数，以及处理各种特殊情况就可以了。

#include <stdio.h>

int numbers[91];

void ini_numbers()

{

//为了节省空间，用hash_map也可以

numbers[0] = 0;//no pronunciation for zero

numbers[1] = 3;//"one"

numbers[2] = 3;//"two"

numbers[3] = 5;//"three"

numbers[4] = 4;//"four"

numbers[5] = 4;//"five"

numbers[6] = 3;//"six"

numbers[7] = 5;//"seven"

numbers[8] = 5;//"eight"

numbers[9] = 4;//"nine"

numbers[10] = 3;//"ten"

numbers[11] = 6;//"eleven"

numbers[12] = 6;//"twelve"

numbers[13] = 8;//"thirteen"

numbers[14] = 8;//"fourteen"

numbers[15] = 7;//"fifteen"

numbers[16] = 7;//"sixteen"

numbers[17] = 9;//"seventeen"

numbers[18] = 8;//"eighteen"

numbers[19] = 8;//"nineteen"

numbers[20] = 6;//"twenty"

numbers[30] = 6;//"thirty"

numbers[40] = 5;//"forty"

numbers[50] = 5;//"fifty"

numbers[60] = 5;//"sixty"

numbers[70] = 7;//"seventy"

numbers[80] = 6;//"eighty"

numbers[90] = 6;//"ninety"

}

int get_length(int n)

{

int a=0; //hundreds'digit

int b=0; //ten's digit

int c=0; //units' digit

int length = 0;

a = n/100;

n = n%100;

b = n/10;

c = n%10;

if(a!=0)

{

length += numbers[a] + 7; // 7 for "hundred"

if(b!=0 || c!=0)

{

length += 3; //3 for "and"

}

if(b!=0)

{

if(b==1)

{

length += numbers[b*10+c];

return length;

}

else

{

length += numbers[b*10];

}

if(c!=0)

{

length += numbers[c];

}

return length;

}

int main()

{

int i, length=0;

ini_numbers();

for(i=1; i<=999; i++)

{

length += get_length(i);

}

length += 11; //11 for "one thousand"

printf("total length: %d\n", length);

return 0;

}

本文链接

[Project Euler] 来做欧拉项目练习题吧: 题目016

2011-02-25T13:15:00Z

[Project Euler] 来做欧拉项目练习题吧: 题目016

周银辉

问题描述

2¹⁵ = 32768 and the sum of its digits is 3 + 2 + 7 + 6 + 8 = 26.

What is the sum of the digits of the number 2¹⁰⁰⁰?

问题分析:

直接用大数乘法就可以解决,并且速度挺快(言下之意"所以没有去找其他的招了").

将数字转换成字符串进行处理,2^m = 2^(m-1) * 2 我们将2^(m-1)放在字符数组buffer中，与2相乘时进位放在字符数组temp中，然后就可以模拟乘法了。

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#define POWER 1000

#define BUF_SZ 310

int test(char *buffer, char *temp)

{

buffer[BUF_SZ-1] = '2';

int i, j, a, b, c;

for(i=2; i<=POWER; i++)

{

for(j=BUF_SZ-1; j>=0; j--)

{

a = (int)buffer[j]-48;

b = (int)temp[j]-48;

c = a*2+b;

buffer[j] = (char)(c%10+48);

if(j>0)

{

temp[j-1] = (char)(c/10+48);

}

int result=0;

for(i=0; i<BUF_SZ; i++)

{

result += (int)buffer[i]-48;

}

return result;

}

int main()

{

char *buffer = (char*)malloc(sizeof(char)*BUF_SZ);

char *temp = (char*)malloc(sizeof(char)*BUF_SZ);

memset(buffer, '0', BUF_SZ);

memset(temp, '0', BUF_SZ);

printf("sum is: %d\n", test(buffer,temp));

printf("buffer is: %s\n", buffer);

free(buffer);

free(temp);

return 0;

}

BUF_SZ之所以取310，因为我偷偷用计算器算了下2^1000的数量级是301，呵呵

在我的机器上(intel 2.4G双核):

real 0m0.011s

user 0m0.007s

sys 0m0.003s

本文链接

[Project Euler] 来做欧拉项目练习题吧: 题目015

2011-02-23T16:56:00Z

[Project Euler] 来做欧拉项目练习题吧: 题目015

周银辉

问题描述

Starting in the top left corner of a 22 grid, there are 6 routes (without backtracking) to the bottom right corner.

How many routes are there through a 2020 grid?

问题分析

这个题需要一点点观察能力：

观察2*2的方格，以左上角为起点，右下角为终点，形成的所有路径刚好可以构成一棵二叉树。

(不走回头路，并且以经过的方格上的节点为树节点，其中方格左上角为根节点，叶子节点始终是方格右下角)。

而路径条数也就是树的叶子节点个数。

用Count[A]表示树A的叶子节点个数，Left,Right表示左右子树.那么Count[A] = Count[Left] + Count[Right]

OK,问题就变得很简单了，一个递归算法就可以解决。

此后的问题，就是优化递归算法(创建一个缓冲区)，减少重复运算，否则速度是不可接受的。

#include <stdio.h>

#define SZ 21 //20*20, index from 0 to 20, so size is 21

#define END (SZ-1)

long long grid[SZ][SZ];

long long test(int i, int j)

{

int record = grid[i][j];

if(record!=0)

{

return record;

}

if(i==END && j==END)

{

return 1;

}

long long left=0, right=0, total=0;

int ni=i+1, nj=j+1; //ni: next i

if(ni<SZ)

{

left = test(ni, j);

grid[ni][j] = left;

}

if(nj<SZ)

{

right = test(i, nj);

grid[i][nj] = right;

}

total = left+right;

grid[i][j] = total;

return total;

}

int main()

{

printf("path count: %lld\n", test(0,0));

return 0;

}

速度挺快的:

real 0m0.004s

user 0m0.001s

sys 0m0.003s

本文链接

[Project Euler] 来做欧拉项目练习题吧: 题目014

2011-02-20T13:02:00Z

[Project Euler] 来做欧拉项目练习题吧: 题目014

周银辉

问题描述

The following iterative sequence is defined for the set of positive integers:

n --> n/2 (n is even)
n --> 3n + 1 (n is odd)

Using the rule above and starting with 13, we generate the following sequence:

13 --> 40 --> 20 --> 10 --> 5 --> 16 --> 8 --> 4 --> 2 --> 1

It can be seen that this sequence (starting at 13 and finishing at 1) contains 10 terms. Although it has not been proved yet (Collatz Problem), it is thought that all starting numbers finish at 1.

Which starting number, under one million, produces the longest chain?

NOTE: Once the chain starts the terms are allowed to go above one million.

问题分析：

在小于1000000的数中，哪个数作为首项并按如下公式能得到最长的数列：

n --> n/2 (n is even)

n --> 3n + 1 (n is odd)

根据n判断其构成的数列长度，如果n比较小的话，则简单地写个递归函数就可以了。

但对于一百万这样的大数据，递归一百万次效率很低下，并且可能堆栈溢出。

所以，为了减少递归次数，用一个缓冲区来保存中间结果，比如我们已经计算过13的话，在计算26时，其除以2等于13，

然后我们可以直接从缓冲区中取13上次的计算结果。

另外在缓冲区中取值时有一个技巧：我们应该在递归前判断缓冲区中是否有值，如果有则不递归，而不应该在递归后才判断缓冲区是否有值(如果有则立即返回)。前者递归函数要调用132434424次，时间上约30秒，后者调用3168610次，时间上1秒多。

设置的缓冲区在递归算法中经常用到，就如许多动态规划题目一样

std::hash_map<long, long> buffer;

long get_chain_length(long n)

{

long length=0, next;

std::hash_map<long, long>::iterator found;

if(n==1)

{

length = 1;

}

else

{

next = n%2==0? n>>1 : n*3+1;

found = buffer.find(n);

if(found != buffer.end())

{

length = found->second;

}

else

{

length = 1+ get_chain_length(next);

buffer[n] = length;

}

return length;

}

本文链接

[Project Euler] 来做欧拉项目练习题吧: 题目013

2011-02-16T23:21:00Z

[Project Euler] 来做欧拉项目练习题吧: 题目013

周银辉

问题描述：

Work out the first ten digits of the sum of the following one-hundred 50-digit numbers.

37107287533902102798797998220837590246510135740250

46376937677490009712648124896970078050417018260538

74324986199524741059474233309513058123726617309629

91942213363574161572522430563301811072406154908250

23067588207539346171171980310421047513778063246676

89261670696623633820136378418383684178734361726757

28112879812849979408065481931592621691275889832738

44274228917432520321923589422876796487670272189318

47451445736001306439091167216856844588711603153276

70386486105843025439939619828917593665686757934951

62176457141856560629502157223196586755079324193331

64906352462741904929101432445813822663347944758178

92575867718337217661963751590579239728245598838407

58203565325359399008402633568948830189458628227828

80181199384826282014278194139940567587151170094390

35398664372827112653829987240784473053190104293586

86515506006295864861532075273371959191420517255829

71693888707715466499115593487603532921714970056938

54370070576826684624621495650076471787294438377604

53282654108756828443191190634694037855217779295145

36123272525000296071075082563815656710885258350721

45876576172410976447339110607218265236877223636045

17423706905851860660448207621209813287860733969412

81142660418086830619328460811191061556940512689692

51934325451728388641918047049293215058642563049483

62467221648435076201727918039944693004732956340691

15732444386908125794514089057706229429197107928209

55037687525678773091862540744969844508330393682126

18336384825330154686196124348767681297534375946515

80386287592878490201521685554828717201219257766954

78182833757993103614740356856449095527097864797581

16726320100436897842553539920931837441497806860984

48403098129077791799088218795327364475675590848030

87086987551392711854517078544161852424320693150332

59959406895756536782107074926966537676326235447210

69793950679652694742597709739166693763042633987085

41052684708299085211399427365734116182760315001271

65378607361501080857009149939512557028198746004375

35829035317434717326932123578154982629742552737307

94953759765105305946966067683156574377167401875275

88902802571733229619176668713819931811048770190271

25267680276078003013678680992525463401061632866526

36270218540497705585629946580636237993140746255962

24074486908231174977792365466257246923322810917141

91430288197103288597806669760892938638285025333403

34413065578016127815921815005561868836468420090470

23053081172816430487623791969842487255036638784583

11487696932154902810424020138335124462181441773470

63783299490636259666498587618221225225512486764533

67720186971698544312419572409913959008952310058822

95548255300263520781532296796249481641953868218774

76085327132285723110424803456124867697064507995236

37774242535411291684276865538926205024910326572967

23701913275725675285653248258265463092207058596522

29798860272258331913126375147341994889534765745501

18495701454879288984856827726077713721403798879715

38298203783031473527721580348144513491373226651381

34829543829199918180278916522431027392251122869539

40957953066405232632538044100059654939159879593635

29746152185502371307642255121183693803580388584903

41698116222072977186158236678424689157993532961922

62467957194401269043877107275048102390895523597457

23189706772547915061505504953922979530901129967519

86188088225875314529584099251203829009407770775672

11306739708304724483816533873502340845647058077308

82959174767140363198008187129011875491310547126581

97623331044818386269515456334926366572897563400500

42846280183517070527831839425882145521227251250327

55121603546981200581762165212827652751691296897789

32238195734329339946437501907836945765883352399886

75506164965184775180738168837861091527357929701337

62177842752192623401942399639168044983993173312731

32924185707147349566916674687634660915035914677504

99518671430235219628894890102423325116913619626622

73267460800591547471830798392868535206946944540724

76841822524674417161514036427982273348055556214818

97142617910342598647204516893989422179826088076852

87783646182799346313767754307809363333018982642090

10848802521674670883215120185883543223812876952786

71329612474782464538636993009049310363619763878039

62184073572399794223406235393808339651327408011116

66627891981488087797941876876144230030984490851411

60661826293682836764744779239180335110989069790714

85786944089552990653640447425576083659976645795096

66024396409905389607120198219976047599490197230297

64913982680032973156037120041377903785566085089252

16730939319872750275468906903707539413042652315011

94809377245048795150954100921645863754710598436791

78639167021187492431995700641917969777599028300699

15368713711936614952811305876380278410754449733078

40789923115535562561142322423255033685442488917353

44889911501440648020369068063960672322193204149535

41503128880339536053299340368006977710650566631954

81234880673210146739058568557934581403627822703280

82616570773948327592232845941706525094512325230608

22918802058777319719839450180888072429661980811197

77158542502016545090413245809786882778948721859617

72107838435069186155435662884062257473692284509516

20849603980134001723930671666823555245252804609722

53503534226472524250874054075591789781264330331690

问题分析：

先说正统的解法：

此类称为"大数问题"，比如大数加法，大数乗法什么的。

大数问题，一般将数转换为字符串，然后用字符串模拟数学运算规则。

a: xxxxx

+ b: yyyyy

----------

d: wwwww

c: zzzzz

a+b要得到c的运算法则非常简单：

用d来保存进位，然后从右到左，abd的对应位相加，所得和的个位数保存在c的对应位中，

所得和的十位数保存在d的对应位中。

但要注意，c和d的最大位数可能会超过a和b的位数。

就此题而言，m个n位数相加之和的最大位数为：(m的位数)+n

所以，100个50位数相加，和的最大位数为：100的位数3加上50：53。

参考代码：

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#define LINES 100

#define COLUMNS 51 //之所以是51，因为用fgets时会将\n读入

#define SUM_DIGITS 53 //最多达到53位

char** get_data()

{

//读取题目给出的数据，并保存在一个字符串数组中

}

void free_data(char** data)

{

//释放字符串数组的空间

}

int main()

{

char** data = get_data();

char sum[SUM_DIGITS];

char *str;

int i, j, k, a, b, c;

memset(sum, '0', SUM_DIGITS);

for(i=0; i<LINES; i++)

{

str = data[i];

int temp[SUM_DIGITS]={0};

for(j=COLUMNS-2,k=SUM_DIGITS-1; k>=0; j--,k--)

{

a = j>=0?((int)str[j]-48):0;

b = (int)sum[k]-48;

c = temp[k];

sum[k] = (char)((a+b+c)%10+48);

if(k>=1)

{

temp[k-1] = (a+b+c)/10;

}

printf("%s\n", sum);

free_data(data);

return 0;

}

然后，来个比较耍小聪明的解法：

上面的解法子所以要使用字符串的形式是因为数太大，我们可以将数化小，然后进行普通的加法运算就可以了。

比如

37107287533902102798797998220837590246510135740250

化为

3.7107287533902102798797998220837590246510135740250

只要double能达到这个精度就行，事实上也是可以的。

这个故事也告诉我们，在看到超范围的大数据计算时，第一反应很可能是用字符串模拟进行大数运算，但有时是可以分析具体问题的各个条件而耍点小聪明让问题变简单的。比如48题直接用大数则会显得不那么聪明了。

本文链接

[Project Euler] 来做欧拉项目练习题吧: 题目012

2011-02-15T23:21:00Z

[Project Euler] 来做欧拉项目练习题吧: 题目012

周银辉

问题描述：

The sequence of triangle numbers is generated by adding the natural numbers. So the 7^thtriangle number would be 1 + 2 + 3 + 4 + 5 + 6 + 7 = 28. The first ten terms would be:

1, 3, 6, 10, 15, 21, 28, 36, 45, 55, ...

Let us list the factors of the first seven triangle numbers:

1: 1
3: 1,3
6: 1,2,3,6
10: 1,2,5,10
15: 1,3,5,15
21: 1,3,7,21
28: 1,2,4,7,14,28

We can see that 28 is the first triangle number to have over five divisors.

What is the value of the first triangle number to have over five hundred divisors?

问题分析：

题目要求找出第一个拥有超过500个约数的三角数。

首先，求第i个三角数很容易，其是1～i之和

long get_trangle_number(int i)

{

return ((long)(1+i)*i)/2;

}

难在如何求一个数n的约数，观察 28: 1,2,4,7,14,28 除了1和28(n本身)外，其它约数中，关键约数是2和7，剩下的则是关键约数的倍数

所以，先求出关键的这些约数，然后再求约数的倍数，而关键的约数也就是质因数(prime factor),求一个数的质因数参考003题。

get_divisors_count这个函数是上述算法的粗糙版本，

int get_divisors_count(int number)

{

if(number<1)

{

return 1;

}

int count = 0;

int factor = 2;

int n = number;

int buffer_sz = number+1;

int i;

int array[buffer_sz];

for(i=0; i<buffer_sz; i++)

{

array[i]=0;

}

array[1] = 1;

array[number] = 1;

while(n>1)

{

if(n%factor==0)

{

//printf("prime factor found: %d\n", factor);

array[factor]=1;

i=2;

while(number%(i*factor)==0)

{

array[i*factor]=1;

i++;

}

while(n%factor==0)

{

n/=factor;

}

factor++;

}

//printf("divisors of %d: ", number);

for(i=0; i<buffer_sz; i++)

{

if(array[i]==1)

{

//printf("%d ", i);

count++;

}

return count;

}

其中有个问题是如何记录已经找到的约数,由于有可能存在重复查找(比如14是2的倍数也是7的倍数，所以重复查找了)则不能简单地累计，

要记录这些数，最简单的方法是用hashtable之类的，但标准C里面没有内置，所以我用了一个数组，数组下标表示约数，值为1则表示找到了。

数组对于比较小的数没问题，但数太大的话，一是遍历是效率低下，二是如果在栈上分配的容易导致内存错误。

上述方法是可以改进的，然后得到了get_divisors_count2这个函数，理论基础来自于这里：http://mathforum.org/library/drmath/view/55843.html

于是我们得到更高效的函数：

int get_divisors_count2(long number)

{

if(number<1)

{

return 1;

}

int count = 1;

int factor = 2;

long n = number;

int i, t;

while(n>1)

{

if(n%factor==0)

{

//printf("prime factor found: %d\n", factor);

t = 1;

while(n%factor==0)

{

t++;

n/=factor;

}

count *= t;

}

factor++;

}

return count;

}

注：当完成题目后，对于某些题，官方网站会给出参考答案，在我的博客里不会将官方答案贴出来，仅仅会写下我自己当时的思路，除非两者不谋而合。另外，如果你有更好的思路，请留言告诉我，我非常乐意参与到讨论中来。

本文链接