POJ 1001

最新推荐文章于 2021-05-21 04:53:49 发布
最新推荐文章于 2021-05-21 04:53:49 发布
阅读量1k 收藏
点赞数
分类专栏： POJ 文章标签： POJ
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qianlizhima1/article/details/8819761
版权 
/*
 * poj_1001.c
 * accepted.
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define SIZE (125)
#define ITEM_SIZE (10)

static char item[ITEM_SIZE][SIZE];

static char * poj_1001(char dst[], char src[], int src_width, int n);
static char * move_leftward (char dst[], char src[], int n);
static char * add_to(char dst[], char src[]);

int main(int argc, char* argv[]){
	int i,j,m,n,b;
	int point;
	char number[5];
	char buf[SIZE];
	char str_temp[7];
	int n_temp;
	while(2 == scanf("%s%d", str_temp, &n_temp)){
            point = 0;
	    for(i=0,j=0; i<6; i++){
	        if(str_temp[i] != '.'){
                    number[j++] = str_temp[i];
	        }
		else{
                    point = i;
		}
            }
	    point = 5 - point;
	    point = n_temp * point;
	    point = SIZE - point -1;

	    poj_1001(buf,number,5,n_temp);
            
	    m=0;
	    n=SIZE-1;
	    for (i=0;i<SIZE;i++){
		    if ( '0' != buf[i] ){
                         m = i;
			 break;
		    }
	    }
	    
	    for (i=SIZE-1; i>=0; i--){
                  if ( '0' != buf[i] ){
                        n = i;
			break;
		  }
	    }
	    b=1;
	    for (i=0;i<SIZE;i++){
                if('0' != buf[i]){
                    b=0;
		}
	    }

	    if (b){
                printf("0");
	    }
	    else {
	        if (m>point){
                    printf(".");
                    for (i=point+1; i<=n; i++){
                        printf ("%c", buf[i]);
		    }
	        }
	        else if (m<=point && point<n){
                    for (i=m;i<=point;i++){
                        printf ("%c", buf[i]);
	  	    }
                    printf (".");
                    for (i=point+1;i<=n;i++){
                        printf ("%c", buf[i]);
		    }
	        }
	        else{
                    for (i=m;i<=point;i++){
                        printf ("%c", buf[i]);
		    }
	        }
	    }
            printf ("\n");
	}
	return 0;
}

static char * poj_1001 (char dst[], char src[], int src_width, int n){
	int i,j,k;
	int carry, bitsum;
	char buf[SIZE];
	char aux[SIZE];
	memset(item, '0', ITEM_SIZE*SIZE);
	memcpy(item[1]+SIZE-src_width, src, src_width);
	bitsum = 0;
	for (i=2;i<=9;i++){
	    carry = 0;
            for (j=SIZE-1; j>=0; j--){
		k = j - (SIZE - src_width);
		if (0<=k){
		    bitsum = i * (src[k] - '0') + carry;
                    item[i][j] = '0' + (bitsum % 10);
		    carry = bitsum / 10;
		}
		else{
			item[i][j] = '0' + carry;
			break;
		}
	    }
	}
	
	if (0 == n){
	    memset (dst, '0', SIZE);
            memset (dst + SIZE - 1, '1', 1);
	}
	else if (1 == n){
            memcpy (dst, item[1], SIZE);
	}
	else{
            memcpy (dst, item[1], SIZE);
	    for (i=0; i<n-1; i++){
                memset (aux, '0', SIZE);
                for (j=0; j<SIZE; j++){
                    move_leftward (buf, item[dst[j]-'0'], SIZE-1-j);
		    add_to (aux, buf);
		}
		memcpy (dst, aux, SIZE);
	    }
	}
	return dst;
}

static char * add_to (char dst[], char src[]){
    int carry, bitsum;
    int i;
    carry = 0;
    bitsum = 0;
    for (i=SIZE-1; i>=0; i--){
        bitsum = carry + (dst[i] - '0') + (src[i] - '0');
	dst[i] = ('0' + bitsum % 10);
	carry = bitsum / 10;
    }
    return dst;
}

static char * move_leftward (char dst[], char src[], int n){
    int i;
    int tail;
    tail = SIZE-1-n;
    memset (dst, '0', SIZE); 
    for (i=0; i<=tail; i++){
        dst[i] = src[i+n];
    }
    return dst;
}


C++用类来实现的

/*
 * C++
 * poj_1001.cpp
 * accepted
 */
#include <cstdio>
#include <cstring>
#include <assert.h>
#include <stdlib.h>
const int BUFFER_SIZE = 125;
const int LINE_SIZE = 10;
const int NUMBER_WIDTH = 6;
class Number;


class Number{
	public:
		Number(){
			int i;
			for(i=0;i<BUFFER_SIZE;i++){
				set_data_at(i, '0');
			}
			set_float_point(BUFFER_SIZE-1);
		}	
	
		Number(char* str){
			int n_fp = BUFFER_SIZE-1;
			int i,j;
			char *p = str;
			int n_str_len;
			//int n_str_point; /* str中小数点在第n_str_point字符之后,假设从1开始*/


			n_str_len = 0;
			while('\0' != *p){
				p++;
				n_str_len++;
			}
			p--;


			j=0;
			//n_str_point = 0;
			char *q = p;
			while(q!=str){
				if('0' == *q){
					j++;
				}
				else{
					break;
				}
				q--;
			}
			/*
			 * 只拷贝从str至q指向的字符，并抹去之间的小数点
			 */
			i=BUFFER_SIZE-1;
			p=q;
			int fixed = 0;
			while(p!=str){
				if('.' != *p){
					set_data_at(i,*p);
					i--;
					if(!fixed){
						n_fp--;
					}
				}
				else{
					fixed = 1;
				}
				p--;
			}
			set_data_at(i,*p);
			for(j=i-1;j>=0;j--){
				set_data_at(j,'0');
			}
			set_float_point(n_fp);


			/*for(i=0;i<BUFFER_SIZE;i++){
				printf("%c",get_data_at(i));
			}
			puts("");*/
		}


		Number operator * (int v){
			Number n_ret;
			if( 0 == v){
				return n_ret;
			}
			else{
				int i;
				int carry = 0;
				int temp;
				int digit;
				for(i=BUFFER_SIZE-1;i>=0;i--){
					temp = (get_data_at(i) - '0') * v + carry;
					digit = temp % 10;
					carry = temp / 10;
					n_ret.set_data_at(i,(char)(digit + '0'));
				}
				n_ret.set_float_point(get_float_point());
				return n_ret;
			}
		}


		/*
		 * 返回将小数点向右移动一些为数的结果
		 */


		Number operator >> (int n_move_right_ward){
			int i;
			int n_fp = get_float_point();
			Number n_ret = (*this);
			if(n_fp + n_move_right_ward < BUFFER_SIZE){
				n_ret.set_float_point(n_fp + n_move_right_ward);	
			}
			else{
				int n_blank_to_add = n_move_right_ward - (BUFFER_SIZE-1 - n_fp);
				n_ret.set_float_point(BUFFER_SIZE -1 );
				for(i=0; i<BUFFER_SIZE-n_blank_to_add;i++){
					n_ret.set_data_at(i,get_data_at(i+n_blank_to_add));
				}
				for(;i<BUFFER_SIZE;i++){
					n_ret.set_data_at(i,'0');
				}
			}
			return n_ret;
		}


		Number operator * (Number n_2){
			/*
			 * 将n_2的各位分别与第一个操作数相乘
			 */
			Number n_ret, n_temp, n_temp_2;
			int i,j;
			int n_fp_2 = n_2.get_float_point();
			int n_move_right;
			for(i=0;i<BUFFER_SIZE;i++){
				if('0' != n_2.get_data_at(i)){
					n_move_right = n_fp_2 - i;
					n_temp = (*this)>>n_move_right;
					n_temp_2 = n_temp * (n_2.get_data_at(i) - '0');
					n_ret = n_ret + n_temp_2;
				}
			}
			return n_ret;
		}


		Number operator + (const Number& b_number){
			int f_p=get_float_point();
			int f_p_b=b_number.get_float_point();
			int f_p_small;
			Number n_small;
			int f_p_big;
			Number n_big;
			/*
			 * n_small has longer float number than n_big
			 */
			if(f_p < f_p_b){
				n_small = *this;
				f_p_small = f_p;
				n_big = b_number;
				f_p_big = f_p_b;
			}
			else{
				n_small = b_number;
				f_p_small = f_p_b;
				n_big = *this;
				f_p_big = f_p;
			}
			
			Number n_ret;
			int i,j,k;
			int c=0; // 当前是否进位
			int digit; //当前位运算的结果
			/*
			 * 较多余的小数部分
			 */
			int longer_floating = f_p_big - f_p_small;
			/*
			 * copy
			 */
			for(k=BUFFER_SIZE-1; k>=0; k--){
				if(k>BUFFER_SIZE - 1 - (f_p_big - f_p_small)){
					n_ret.set_data_at(k, n_small.get_data_at(k));
				}
				else{
					i=k;
					j=k + (f_p_big - f_p_small);
					int temp = n_small.get_data_at(i) - '0' + n_big.get_data_at(j) - '0';
					temp = temp + c;
					digit = temp % 10;
					c = temp / 10;
					n_ret.set_data_at(k, (char)('0' + digit));
				}
			}


			for(i=0,j=0;i<BUFFER_SIZE;i++){
				if('0'==n_ret.get_data_at(BUFFER_SIZE-1-i) && BUFFER_SIZE-1-i>f_p_small){
					j++;
				}	
				else{
					break;
				}
			}


			/*
			 * delete 尾部多余的零(小数点之后的)
			 */
			if(j){
				for(i=BUFFER_SIZE-1;i>j-1;i--){
					n_ret.set_data_at(i,n_ret.get_data_at(i-j));
				}
				f_p_small += j;
			}


			n_ret.set_float_point(f_p_small);


			return n_ret;


		}


		void set_float_point(int p){
			float_point = p;
		}


		int get_float_point()const{
			return float_point;
		}


		char get_data_at(int p)const{
			return (char)(data[p]);
		}


		void set_data_at(int p, char ch){
			data[p] = ch;
		}


		/*
		 * return the index of the first character that is not '0', otherwise return -1
		 */
		int get_index_of_1st_non_zero_symbol()const{
			for(int i=0; i<BUFFER_SIZE; i++){
				if( '0' != get_data_at(i)){
					return i;
				}
			}
			return -1;
		}


		Number& operator = ( Number b){
			if(this != &b){
				set_float_point(b.get_float_point());
				for(int i=0;i<BUFFER_SIZE;i++){
					set_data_at(i,b.get_data_at(i));
				}
			}
			return *this;
		}


		Number operator ^ ( int v){
			Number n_ret;


			if(v == 0){
				n_ret.set_data_at(BUFFER_SIZE-1,'1');
				return n_ret;
			}
			n_ret = *this;
			int i;
			for(i = 1; i<v; i++){
				n_ret = n_ret * (*this);
			}
			return n_ret;
		}


		void print(){
			/*
			 * 从第一个有效数字开始打印，遇到小数点时停顿并打印小数点，然后打印至最后并截去末尾多余的零
			 */
			int f_p = get_float_point();
			int i;
			int n_tail_zeros = 0;
			for(i = BUFFER_SIZE-1; i>f_p;i--){
				if('0' == get_data_at(i)){
					n_tail_zeros ++;
				}
				else{
					break;
				}
			}
			/*
			 * 打印的字符中最大的Index
			 */
			int n_max_print_index = BUFFER_SIZE - 1 - n_tail_zeros;
			/*
			 * 统计左端开始连续的0的个数
			 */
			int n_head_zeros = 0;
			for(i=0; i<BUFFER_SIZE;i++){
				if('0' == get_data_at(i)){
					n_head_zeros ++;
				}
				else{
					break;
				}
			}
			int n_min_print_index = n_head_zeros;
			/*
			 * 如果小数点左端位数少于左端连续0的个数，则不打印小数点左端的0,
			 */


			char *p_str_show = str_show;
			if(n_head_zeros > 1 + f_p){
				//printf(".");
				sprintf(p_str_show, ".");
				p_str_show++;
			}
			/*
			 * 从第一个有效数字的index处开始打印
			 */
			else{
				for(i=n_min_print_index;i<=f_p;i++){
					//printf("%c",get_data_at(i));
					sprintf(p_str_show,"%c",get_data_at(i));
					p_str_show++;
				}
				//printf(".");
				sprintf(p_str_show,".");
				p_str_show++;
			}


			for(i=f_p+1;i<=n_max_print_index;i++){
				//printf("%c",get_data_at(i));
				sprintf(p_str_show,"%c",get_data_at(i));
				p_str_show++;
			}
			sprintf(p_str_show, "%c", '\0');
			//printf("  %d\n", get_float_point());
			
		}


		char* get_str_show(){
			print();
			return str_show;
		}


	private:
		char data[BUFFER_SIZE]; // right alignment, for example 12345 is stored as 000000...0000012345 with float point is stored as 124.
		char str_show[BUFFER_SIZE+2]; // to display, including dot
		int float_point; 
};




int main( int argc, char* argv[]){
	int i,j;
	char buf[1+NUMBER_WIDTH];
	char buf_aux[BUFFER_SIZE+2];
	char *t_ch;
	int n_exp;

	i=0;
	j=0;

	while( 2 == scanf("%s%d", buf, &n_exp)){
		Number n_1(buf);
		Number n_2;
		n_2 = n_1 ^ n_exp;

		strcpy (buf_aux, n_2.get_str_show ());
		t_ch = buf_aux;
		while(*t_ch){
                   t_ch++;
		}
		t_ch--;
		if(*t_ch == '.'){
                   *t_ch = '\0';
		}
		
		printf("%s\n",buf_aux);
	}
	return 0;
}


BrightPi
关注
专栏目录
POJ1001解题报告
上善若水
07-31 1751
乍一看就是大数乘法问题，要通过可不是那么容易
POJ1001 （求高精度幂，Exponentiation，C++）
qq_45246359的博客
06-20 606
北京大学程序在线评测系统 (“PekingUniversityOnlineJudge”) POJ1001 （求高精度幂，Exponentiation，C++） 题目的网址 题目大意是对一个实数R( 0.0 < R < 99.999 )，精确计算 R 的 n 次方，其中n 是整数并且 0 < n <= 25。 具体思路在代码中的注释中都有体现，不做过多解释。 话不多说，具体代...
[原创]我的北大ACM POJ1001解答
weixin_30652271的博客
03-24 120
北大ACM POJ1001解答 这题花了我半天时间，感觉不容易啊，是关于高精度的幂计算的。代码如下Source Code Problem: 1001 User: absolute Memory: 208K Time: 16MS Language: C++ Result: Accepted Source Code #include <st...
POJ 1001 题解
dgr42861的博客
09-29 128
题意：求一个实数R的N次方 解法思路：快速幂适用于整数计算，因此排除裸快速幂。题目中描述的R是一个固定长度的字符串，因此可以将小数点提取出来转换成一个整数来计算，完成后再用小数长度来确定小数点。计算N次方的时候发现N较小，所以可以使用高精度乘法来解决这个问题。 #include<iostream> #include<string> using name...
测试题-POJ-1001
私の夢は星辰の海
10-19 171
POJ10011. 题目大意2. AC难点3. 大体思路4. 代码5. 测试输入集 1. 题目大意 考察大数运算，有些时候由于编译器所能接受单个变量大小有限，需要单独编写程序完成运算。 该题是完成Rb的指数运算，其中0&lt;=R&lt;=99.999 ， 0&lt;b&lt;=25。 2. AC难点 输出格式：纯小数不需要输出小数点前的零；不能省略小数点后的必须零；表示精度的多余零必须省略。 ...
poj1001源码
05-02
poj1001源码，c语言版，通过ac，包含注释，容易懂
POJ1001的一个解决方案
05-25
简单地poj1001代码，是典型的利用数组输出结果的方法，关键的是测试数据。
POJ1001算法解析
geek_jerome的博客
08-08 453
POJ1001 求高精度幂 Time Limit: 500MS Memory Limit: 10000K Total Submissions: 170716 Accepted: 41349Description 对数值很大、精度很高的数进行高精度计算是一类十分常见的问题。比如，对国债进行计算就是属于这类问题。现在要你解决的问题是：对一个实数R( 0.0 < R < 9
POJ 1001 - Exponentiation（求幂）
神奇海螺的博客咯
08-17 472
题目链接：POJ - 1001 题目概括： 求Rn R ∈ ( 0.0 , 99.999 ) 实数 n ∈ ( 0 , 25 ] 整数 题目解析： 看到样例输出，就发现不合适直接使用double类型来直接计算，应当使用数组来模拟乘法运算过程。 将实数R以字符串的形式读入，然后将小数点去除，转化成数组（倒序逐位储存），存储结果的数组，每个单元只存储1位数。数组空间开辟6*25=150稍大一点即可。 > 12.345 > a[0] = 5 a[1] = 4 a[2] = 3 a
从拾ACM——poj1001解题报告
Mr.L1的博客
09-09 169
事情一件件来，水题一道道刷。。。 1001是一道典型的高精度问题，重点是处理字符串。最后需要按照题目的输出标准来输出答案就可以了 #include<stdio.h> #include<string.h> int output[120]; //第一位为1，方便计算 int m; //num是去掉小数点后的十进制数字,比如95.23变为9523 //因为...
杭电oj刷题c语言1001题,POJ-北大acm 1001 exponentiation 解题报告与bug
weixin_32831131的博客
05-21 305
严格来说本解法不能算大数相乘的通用算法, 而只是针对题目中(0.0 < R < 99.999)的trick. 因R位数很小, 所以本算法思路是把R扩大倍数而转成整数(99.999 -> 99999), 然后把每次乘积累加到结果数组中, 算法比较简单.同时, 发现POJ本题的审核程序有bug. 题目要求对尾部(trailing)无效的0不能打印出来, 但实际审核时没有这么严谨, 可...
POJ1001
爱吃紫菜汤的懒小猪的程序小屋
10-31 537
求高精度幂 Time Limit: 500MS   Memory Limit: 10000K Total Submissions: 173473   Accepted: 41924 Description 对数值很大、精度很高的数进行高精度计算是一类十分常见的问题。比如，对国债进行计算就是属于这类问题。 现在要你解决的问题是：对一个实
POJ 1001 解题报告 高精度大整数乘法模版
weixin_30342827的博客
01-06 335
题目是POJ1001Exponentiation 虽然是小数的幂 最终还是转化为大整数的乘法 这道题要考虑的边界情况比较多 做这道题的时候，我分析了 网上的两个解题报告，发现都有错误，说明OJ对于错误的判断还不够严厉. 对边界情况的讨论其实应该是思维严密的表现，当然这并不能表明我写的一点错误都没有，只是多多分析一下还是很有好处的。 #include <iostre...
1001. 求高精度幂
second24的博客
06-27 371
1001. 求高精度幂Description对数值很大、精度很高的数进行高精度计算是一类十分常见的问题。比如，对国债进行计算就是属于这类问题。 现在要你解决的问题是：对一个实数R( 0.0 < R < 99.999 )，要求写程序精确计算 R 的 n 次方(Rn)，其中n 是整数并且 0 < n <= 25。InputT输入包括多组 R 和 n。 R 的值占第 1 到第 6 列，n 的值占第 8
poj1001——Exponentiation
r_ax的专栏
01-02 1334
<br />题意：给出R和n，求R的n次方。<br />思路：大数操作，小数点另外处理。<br />分为：有小数点和无小数点。有小数点的数，判断小数点后面的个数与当前所求的数的位数的关系。<br />#include<iostream> #include<cstdio> #include<cstring> using namespace std; char a[8]; int result[26][1000],num[8],n; bool flag; void solve(int len,in
poj1001高精度乘法
dannis_bh的博客
03-23 532
1.题目 问题简述： 对一个实数R( 0.0 n)，其中n 是整数并且 0 输入要求： 输入包括多组 R 和 n。 R 的值占第 1 到第 6 列，n 的值占第 8 和第 9 列。 输出要求： 对于每组输入，要求输出一行，该行包含精确的 R 的 n 次方。输出需要去掉前导的 0 后不要的 0 。如果输出是整数，不要输出小数点。 输入样例： 95.123 1
poj1001解题报告+测试数据
keysona的博客
06-05 2040
题目链接：http://poj.org/problem?id=1001&lang=zh-CN&change=true当初做完A+B后，兴高采烈地做第二题就被虐了。纠结了一个小时后，含恨退出poj了。 现在过了几个月了，在来挑战。有大数加法的基础做这个还是挺轻松的，基本方向有了。唯一的障碍是小数点。这个怎么处理让当初我的纠结的痛不欲生。其实，这个小数点不用管都可以了，直接忽略就可以。看看这个例子。5
[POJ][1001]Exponentiation
热门推荐
软件工程学森
10-04 1万+
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 comp
高精度计算挑战：北京大学ACMpoj1001
"北京大学ACMpoj1001 - 高精度计算问题" 在这个问题中，我们面临的是一个高精度计算的挑战。高精度计算通常涉及到处理极大数值和极高精度的运算，这样的问题在实际中并不少见，比如精确计算国家债务等复杂财务计算...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值