POJ 1001

题目要求：

Description

Problems involving the computation of exact values of very large magnitude and precision are common. For example, the computation of the national debt is a taxing experience for many computer systems. 

This problem requires that you write a program to compute the exact value of Rⁿ where R is a real number ( 0.0 < R < 99.999 ) and n is an integer such that 0 < n <= 25.

Input

The input will consist of a set of pairs of values for R and n. The R value will occupy columns 1 through 6, and the n value will be in columns 8 and 9.

Output

The output will consist of one line for each line of input giving the exact value of R^n. Leading zeros should be suppressed in the output. Insignificant trailing zeros must not be printed. Don't print the decimal point if the result is an integer.

Sample Input

95.123 12

0.4321 20

5.1234 15

6.7592 9

98.999 10

1.0100 12

Sample Output

548815620517731830194541.899025343415715973535967221869852721

.00000005148554641076956121994511276767154838481760200726351203835429763013462401

43992025569.928573701266488041146654993318703707511666295476720493953024

29448126.764121021618164430206909037173276672

90429072743629540498.107596019456651774561044010001

1.126825030131969720661201

解题思路

这是一个大数乘法的问题，大数乘法用到的方法就是用一个数组保存大数相乘的结果，通过列一个竖式我们知道最终相加到一起的数其实是下标和相同的数，所以把下表和相同的加到一起，然后再进位即是大数乘法的方法。更明朗的逻辑其实可是是这个样子，用一个函数专门计算两个大数相乘，然后用一个动态数组记录结果，但是这个题目蛋疼的地方是它还有小数，我的做法是先把小数点去掉，记录小数位数，相乘后再把小数点加上。

边界问题其实也有很多，比如如果是小数，后面的0应该都去掉，在小数点前，数字首位的几个0也应该去掉，比如要考虑000.010的1次方，000.00的一次方但都是要考虑的边界条件。

这是我第一次尝试自己去做poj的题目，我花的时间比较久可能大牛分分钟就搞定了，那些边界问题真的很头疼，不过看到一次次的Wrong Answer，让自己一次次反思是不是那个边界值没有考虑，然后不断地修改，当最后出现AC的时候超级激动~也算是自己的一个小小的进步吧，回来看看代码写的好水，逻辑也不是很清晰，也期望能得到一些好的建议~么么哒~

1. #include <stdio.h>
2. #include <stdlib.h>
3. #include <string.h>
4. #define LENGTH 6
5. int arraylength(char arraytemp[])
6. {
7.    int number=0;
8.    for(number=0;arraytemp[number]!='\0';number++);
9.    return number;
10. }
11. int point(char arraytemp[])
12. {
13.    int number=0,pointnumber=0,flag=0;
14.    for(number=0;arraytemp[number]!='\0';number++)
15.    {
16.       if(arraytemp[number]=='.')
17.          flag=1;
18.       if(flag==1)
19.          pointnumber++;
20.    }
21.    if(flag==1)
22.       pointnumber--;
23.    return pointnumber;
24. }
25. char * move(char number[])
26. {
27.    int i=0,j=0,m=arraylength(number);
28.    for(i=arraylength(number)-point(number)-1,j=i+1;i<m+1;i++,j++)
29.    {
30.       number[i]=number[j];
31.    }
32.    number[i]='\0';
33.    return number;
34. }
35. char * multiply(char number1[],char number2[])
36. {
37.    int i,j,number1length,number2length,*result;
38.    char *lastresult;
39.    number1length=arraylength(number1);
40.    number2length=arraylength(number2);
41.    result=(int *)malloc(sizeof(int)*(number1length+number2length));
42.    for(i=0;i<number1length+number2length;i++)
43.       result[i]=0;
44.    for(i=0;i<number1length;i++)
45.       for(j=0;j<number2length;j++)
46.       {
47.          result[i+j+1]+=(number1[i]-'0')*(number2[j]-'0');
48.       }
49.    for(i=number1length+number2length-1;i>=0;i--)
50.    {
51.       if(result[i]>=10)
52.       {
53.          result[i-1]+=result[i]/10;
54.          result[i]%=10;
55.       }
56.    }
57.    lastresult=(char *)malloc((number1length+number2length)*sizeof(char));
58.    i=0;
59.    while(result[i]==0)
60.       i++;
61.    for(j=0;i<number1length+number2length;i++,j++)
62.       lastresult[j]=result[i]+'0';
63.    lastresult[j]='\0';
64.    return lastresult;
65.    free(lastresult);
66. }
67.  
68. char * calculate(char basenumber1[],int timenumber)
69. {
70.    int length=LENGTH*timenumber+1;
71.    int i=0,number=0;
72.    char *result=(char *)malloc(length*sizeof(char));
73.    if(timenumber==1)
74.       return basenumber1;
75.    result=multiply(basenumber1,basenumber1);
76.    for(i=0;i<timenumber-2;i++)
77.       result=multiply(basenumber1,result);
78.    return result;
79. }
80. void decorate(char number[],int pointnumber)
81. {
82.    int i=arraylength(number)-1,j,m;
83.    if(pointnumber&&arraylength(number)>pointnumber)
84.    {
85.       for(j=i+1,m=0,number[j+1]='\0';m<pointnumber;m++,i--,j--)
86.       {
87.          number[j]=number[i];
88.       }
89.       i++;
90.       number[i]='.';
91.    }
92.    if(pointnumber>arraylength(number))
93.    {
94.       for(i=arraylength(number),m=pointnumber-arraylength(number)+1,j=i+m;i>=0;i--,j--)
95.          number[j]=number[i];
96.       number[0]='.';
97.       for(i=1;i<m;i++)
98.          number[i]='0';
99.    }
100.    i=arraylength(number);
101.    while(number[i-1]=='0')
102.    {
103.       i--;
104.    }
105.    if(i<arraylength(number))
106.    {
107.       number[i]='\0';
108.    }
109.    if(number[arraylength(number)-1]=='.')
110.    {
111.       number[arraylength(number)-1]='\0';
112.    }
113.    if(number[0]=='0'&&number[1]!='\0')
114.    {
115.       for(i=1;number[i]=='0';i++);
116.       for(j=i;number[j]!='\0';j++)
117.       {
118.          number[j-i]=number[j];
119.       }
120.       number[j-i]='\0';
121.       if(number[0]=='\0')
122.       {
123.          number[0]='0';
124.          number[1]='\0';
125.       }
126.    }
127.    for(i=0;number[i]!='\0';i++)
128.    {
129.       printf("%c",number[i]);
130.    }
131.    printf("\n");
132. }
133. int main()
134. {
135.    char basenumber[8] = {0},times[10],number,*basenumber1;
136.    int temp=1,i=0,j=0,k=0,timenumber=0,pointnumber,sumpoint, count = 0;
137.    char * s;
138.    int n;
139.    while(1)
140.    {
141.       for(count = 0; count < 8; count ++)
142.       {
143.          basenumber[count] = 'a';
144.       }
145.  
146.       while((number=getchar())!=' ')
147.       {
148.          basenumber[i]=number;
149.          i++;
150.          if(basenumber[0]==EOF)
151.          {
152.             //free(basenumber);
153.             return 0;
154.          }
155.       }
156.       basenumber[i]='\0';
157.  
158.       while((number=getchar())!='\n')
159.       {
160.          while((number) == ' ')
161.             number = getchar();
162.          times[k]=number;
163.          k++;
164.       }
165.       times[k]='\0';
166.       for(j=0;j<k;j++)
167.       {
168.          temp=times[j]-'0';
169.          for(i=0;i<k-j-1;i++)
170.             temp*=10;
171.          timenumber+=temp;
172.       }
173.       pointnumber=point(basenumber);
174.       sumpoint=pointnumber*timenumber;
175.       if(pointnumber!=0)
176.       {
177.          basenumber1=move(basenumber);
178.          for(i=0;basenumber1[i]!='\0';i++)
179.             basenumber[i]=basenumber1[i];
180.       }
181.          decorate(calculate(basenumber,timenumber),sumpoint);
182.       temp=1,i=0,j=0,k=0,timenumber=0;
183.    }
184.    free(basenumber);
185.    return 0;
186. }