64,639
社区成员
发帖
与我相关
我的任务
分享请发表友善的回复…
发表回复
lm_whales 2014-05-09
- 打赏
- 举报
恭喜
lyramilk 2014-05-09
- 打赏
- 举报
这只是个笨办法，也许还有许多精妙的办法。
我原来考虑是用查表的，只是不知道能不能做到。
我自己没有想通，所以，就换了这个一定可行的办法
从算法上来说，并没多少该进，就像冒泡排序，和插入排序，差别不大
还是二次的，只是改进的规模比较大一点
我想一定还有更好的。
[/quote]
在这个方法上我又作了一些优化，最后终于优化到debug 2秒，release瞬间完成的程度了。我也想到了一些其它的优化方法，不过暂时不需要讨论了，有这个效率我想是可以接受的了。
结帖。
蠓虫带着秤砣飞 2014-05-06
- 打赏
- 举报
这个，用加权系数法转换就好了。
gz_qmc 2014-05-06
- 打赏
- 举报
我来谈谈我的思路，仅供参考
假设16进制字串有4096个字符吧
那么在32位机器上
建立4096/4=1024个字串表示各段位的10进制数
比如：000000010000000A............
则可简单得到x[0]="1";x[2]="12"...................
那么显而易见
最后10进制数的结果就是
n=((((x[0]*16)+x[1])*16)+x[2])*16........+x[1022])*16+x[1023];
所以，建立两函数就可以
函数1：10进制字串相加 char *Add(char *d1,char *d2);
函数2：10进制字串*16 char *Mul16(char *d);
于是实现就变成
y=Mul16(x[0]);
for(int i=1;i<1023;i++)
{
y=Add(y,x[i]);
y=Mul16(y);
}
y=Add(y,x[1023]);
lm_whales 2014-05-06
- 打赏
- 举报
这只是个笨办法，也许还有许多精妙的办法。
我原来考虑是用查表的，只是不知道能不能做到。
我自己没有想通，所以，就换了这个一定可行的办法
从算法上来说，并没多少该进，就像冒泡排序，和插入排序，差别不大
还是二次的，只是改进的规模比较大一点
我想一定还有更好的。
lyramilk 2014-05-06
- 打赏
- 举报
感谢大家，尤其是lm_whales的帮助，确实除法次数虽然不可避免，但可以减少每一次除法所需要处理数据的量。这个办法己经可以把我的计算从8分多减少到19秒了。
lyramilk 2014-05-06
- 打赏
- 举报
我改用分段除，确实速度快了不少。
旧代码
xint k = r;
std::stringstream ss;
while(k > 0){
xint v = k%10;
k /= 10;
unsigned int p = v.d.empty()?0:v.d.front();
ss << p;
}
xint k = r;
std::stringstream ss;
while(k > 0){
xint v = k%1000000000000000;
k /= 1000000000000000;
while(v > 0){
xint m = v%10;
v /= 10;
unsigned int p = m.d.empty()?0:m.d.front();
ss << p;
}
}
lyramilk 2014-05-06
- 打赏
- 举报
用BCD码确实是一个不错的想法。。。。
lyramilk 2014-05-05
- 打赏
- 举报
我的大整数不是字符串表示的，而是用字节数组的形式，格式和普通的int一样，只不过长度大而己，并且也是小端。计算上还好，用传统的除十取余转十进制然打再输出成字符串就太慢了。
lyramilk 2014-05-05
- 打赏
- 举报
我的大整数是计算得到的结果，以十六进制形式打印成字符串很容易，但是想打印十进制就很晕了。我用除10取余的方法，算个2的1000次方都要算小十分钟，时间全在除10取余这个过程上。所以我想知道是不是有可以遍历常数次就可以得到结果的办法。
赵4老师 2014-05-05
- 打赏
- 举报
#include <iostream>
#include <string>
using namespace std;
inline int compare(string str1,string str2) {//相等返回0，大于返回1，小于返回-1
if (str1.size()>str2.size()) return 1; //长度长的整数大于长度小的整数
else if (str1.size()<str2.size()) return -1;
else return str1.compare(str2); //若长度相等，则头到尾按位比较
}
string SUB_INT(string str1,string str2);
string ADD_INT(string str1,string str2) {//高精度加法
int sign=1; //sign 为符号位
string str;
if (str1[0]=='-') {
if (str2[0]=='-') {
sign=-1;
str=ADD_INT(str1.erase(0,1),str2.erase(0,1));
} else {
str=SUB_INT(str2,str1.erase(0,1));
}
} else {
if (str2[0]=='-') {
str=SUB_INT(str1,str2.erase(0,1));
} else { //把两个整数对齐，短整数前面加0补齐
string::size_type L1,L2;
int i;
L1=str1.size();
L2=str2.size();
if (L1<L2) {
for (i=1;i<=L2-L1;i++) str1="0"+str1;
} else {
for (i=1;i<=L1-L2;i++) str2="0"+str2;
}
int int1=0,int2=0; //int2 记录进位
for (i=str1.size()-1;i>=0;i--) {
int1=(int(str1[i])-'0'+int(str2[i])-'0'+int2)%10;
int2=(int(str1[i])-'0'+int(str2[i])-'0'+int2)/10;
str=char(int1+'0')+str;
}
if (int2!=0) str=char(int2+'0')+str;
}
}
//运算后处理符号位
if ((sign==-1)&&(str[0]!='0')) str="-"+str;
return str;
}
string SUB_INT(string str1,string str2) {//高精度减法
int sign=1; //sign 为符号位
string str;
int i,j;
if (str2[0]=='-') {
str=ADD_INT(str1,str2.erase(0,1));
} else {
int res=compare(str1,str2);
if (res==0) return "0";
if (res<0) {
sign=-1;
string temp =str1;
str1=str2;
str2=temp;
}
string::size_type tempint;
tempint=str1.size()-str2.size();
for (i=str2.size()-1;i>=0;i--) {
if (str1[i+tempint]<str2[i]) {
j=1;
while (1) {//zhao4zhong1添加
if (str1[i+tempint-j]=='0') {
str1[i+tempint-j]='9';
j++;
} else {
str1[i+tempint-j]=char(int(str1[i+tempint-j])-1);
break;
}
}
str=char(str1[i+tempint]-str2[i]+':')+str;
} else {
str=char(str1[i+tempint]-str2[i]+'0')+str;
}
}
for (i=tempint-1;i>=0;i--) str=str1[i]+str;
}
//去除结果中多余的前导0
str.erase(0,str.find_first_not_of('0'));
if (str.empty()) str="0";
if ((sign==-1) && (str[0]!='0')) str ="-"+str;
return str;
}
string MUL_INT(string str1,string str2) {//高精度乘法
int sign=1; //sign 为符号位
string str;
if (str1[0]=='-') {
sign*=-1;
str1 =str1.erase(0,1);
}
if (str2[0]=='-') {
sign*=-1;
str2 =str2.erase(0,1);
}
int i,j;
string::size_type L1,L2;
L1=str1.size();
L2=str2.size();
for (i=L2-1;i>=0;i--) { //模拟手工乘法竖式
string tempstr;
int int1=0,int2=0,int3=int(str2[i])-'0';
if (int3!=0) {
for (j=1;j<=(int)(L2-1-i);j++) tempstr="0"+tempstr;
for (j=L1-1;j>=0;j--) {
int1=(int3*(int(str1[j])-'0')+int2)%10;
int2=(int3*(int(str1[j])-'0')+int2)/10;
tempstr=char(int1+'0')+tempstr;
}
if (int2!=0) tempstr=char(int2+'0')+tempstr;
}
str=ADD_INT(str,tempstr);
}
//去除结果中的前导0
str.erase(0,str.find_first_not_of('0'));
if (str.empty()) str="0";
if ((sign==-1) && (str[0]!='0')) str="-"+str;
return str;
}
string DIVIDE_INT(string str1,string str2,int flag) {//高精度除法。flag==1时,返回商; flag==0时,返回余数
string quotient,residue; //定义商和余数
int sign1=1,sign2=1;
if (str2 == "0") { //判断除数是否为0
quotient= "ERROR!";
residue = "ERROR!";
if (flag==1) return quotient;
else return residue ;
}
if (str1=="0") { //判断被除数是否为0
quotient="0";
residue ="0";
}
if (str1[0]=='-') {
str1 = str1.erase(0,1);
sign1 *= -1;
sign2 = -1;
}
if (str2[0]=='-') {
str2 = str2.erase(0,1);
sign1 *= -1;
}
int res=compare(str1,str2);
if (res<0) {
quotient="0";
residue =str1;
} else if (res == 0) {
quotient="1";
residue ="0";
} else {
string::size_type L1,L2;
L1=str1.size();
L2=str2.size();
string tempstr;
tempstr.append(str1,0,L2-1);
for (int i=L2-1;i<L1;i++) { //模拟手工除法竖式
tempstr=tempstr+str1[i];
tempstr.erase(0,tempstr.find_first_not_of('0'));//zhao4zhong1添加
if (tempstr.empty()) tempstr="0";//zhao4zhong1添加
for (char ch='9';ch>='0';ch--) { //试商
string str;
str=str+ch;
if (compare(MUL_INT(str2,str),tempstr)<=0) {
quotient=quotient+ch;
tempstr =SUB_INT(tempstr,MUL_INT(str2,str));
break;
}
}
}
residue=tempstr;
}
//去除结果中的前导0
quotient.erase(0,quotient.find_first_not_of('0'));
if (quotient.empty()) quotient="0";
if ((sign1==-1)&&(quotient[0]!='0')) quotient="-"+quotient;
if ((sign2==-1)&&(residue [0]!='0')) residue ="-"+residue ;
if (flag==1) return quotient;
else return residue ;
}
string DIV_INT(string str1,string str2) {//高精度除法,返回商
return DIVIDE_INT(str1,str2,1);
}
string MOD_INT(string str1,string str2) {//高精度除法,返回余数
return DIVIDE_INT(str1,str2,0);
}
int main() {
char ch;
string s1,s2,res;
while (cin>>s1>>ch>>s2) {
switch (ch) {
case '+':res=ADD_INT(s1,s2);break;
case '-':res=SUB_INT(s1,s2);break;
case '*':res=MUL_INT(s1,s2);break;
case '/':res=DIV_INT(s1,s2);break;
case '%':res=MOD_INT(s1,s2);break;
default : break;
}
cout<<res<<endl;
}
return(0);
}
赵4老师 2014-05-05
- 打赏
- 举报
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <locale.h>
int main() {
int i,v;
char bs[33];
char b[33];
char hs[9];
char h[9];
char s[4];
char *e;
// 十进制整数转二进制串；
i=1024;
ltoa(i,b,2);
sprintf(bs,"%032s",b);
printf("i=%d,bs=%s\n",i,bs);
// 十进制整数转十六进制串；
i=1024;
ltoa(i,h,16);
sprintf(hs,"%08s",h);
printf("i=%d,hs=%s\n",i,hs);
// 十六进制字符串转成十进制数
strcpy(hs,"00000400");
sscanf(hs,"%x",&i);
printf("hs=%s,i=%d\n",hs,i);
// 二进制字符串转化为十六进制字符串；
strcpy(bs,"00000000000000000000010000000000");
i=strtol(bs,&e,2);
ltoa(i,h,16);
sprintf(hs,"%08s",h);
printf("bs=%s,hs=%s\n",bs,hs);
// 二进制字符串转化为十进制数；
strcpy(bs,"00000000000000000000010000000000");
i=strtol(bs,&e,2);
printf("bs=%s,i=%d\n",bs,i);
// 十六进制字符串转成二进制串
strcpy(hs,"00000400");
sscanf(hs,"%x",&i);
ltoa(i,b,2);
sprintf(bs,"%032s",b);
printf("hs=%s,bs=%s\n",hs,bs);
// ASC\GBK字符串转十六进制串
strcpy(s,"a汉");
i=0;
while (1) {
if (0==s[i]) break;
sprintf(hs+i*2,"%02X",(unsigned char)s[i]);
i++;
}
setlocale(LC_ALL,"chs");
printf("s=%s,hs=%s\n",s,hs);
// 十六进制字符串转成汉字（GBK）及字符(ASC)
strcpy(hs,"61BABA");
i=0;
while (1) {
if (1!=sscanf(hs+i*2,"%2x",&v)) break;
s[i]=(char)v;
i++;
}
s[i]=0;
printf("hs=%s,s=%s\n",hs,s);
return 0;
}
//i=1024,bs=00000000000000000000010000000000
//i=1024,hs=00000400
//hs=00000400,i=1024
//bs=00000000000000000000010000000000,hs=00000400
//bs=00000000000000000000010000000000,i=1024
//hs=00000400,bs=00000000000000000000010000000000
//s=a汉,hs=61BABA
//hs=61BABA,s=a汉
lm_whales 2014-05-05
- 打赏
- 举报
32Bits一千位以上十六进制共1000/8 =125 个整数
大约做不到125*125或者更少次除法，可以计算出1000000000进制数
直接输出1000000000进制数，转换的除法大约9* K次除以10 操作
K表示1000000000进制数的位数
PDD123 2014-05-05
- 打赏
- 举报
你的大整数应该是以十六进制字符串输入的吧？
1.你要了解超过8字节的大数可以用什么方法（可直接计算的方法）来表示，然后把字符串转成合适的格式的大数
2.把这个大数转成十进制格式的字符串。我百度了一下itoa函数的资料，好像其算法也是求余，算出末尾，然后除10，一直循环……这样算出来的。估计这是最快的方法了。
lm_whales 2014-05-05
- 打赏
- 举报
100000000进制或者1000000000进制
lm_whales 2014-05-05
- 打赏
- 举报
16进制32Bits存储
先转换成100000000进制整数，然后输出
除法用64Bits计算，，，差不多不用考虑溢出问题
mujiok2003 2014-05-05
- 打赏
- 举报
if(len > 0 && last >=0){
char fmt[8];
sprintf(fmt, "%%%dx", len);
sscanf(hex, fmt, &aux);
sprintf(buf[last],"%u", aux);
for(; last < 1024; ++last){
printf("%s", buf[last]);
}
}if(len > 0 && last >=0){
char fmt[8];
sprintf(fmt, "%%%dx", len);
sscanf(hex, fmt, &aux);
sprintf(buf[last],"%u", aux);
}
for(; last < 1024; ++last){
printf("%s", buf[last]);
}
mujiok2003 2014-05-05
- 打赏
- 举报
sprintf + sscanf, 参考一下。
#include <stdio.h>
#include <string.h>
#include <limits.h>
int main()
{
char const * const hex = "123456789abcdef";
int len = strlen(hex);
unsigned int aux = 0;
static char buf[1024][32];
int last = 1023;
while(len > 8 && last >= 0){
len -= 8;
sscanf(hex + len, "%8x",&aux);
sprintf(buf[last],"%u", aux);
--last;
}
if(len > 0 && last >=0){
char fmt[8];
sprintf(fmt, "%%%dx", len);
sscanf(hex, fmt, &aux);
sprintf(buf[last],"%u", aux);
for(; last < 1024; ++last){
printf("%s", buf[last]);
}
}
return 0;
}
「已注销」 2014-05-05
- 打赏
- 举报
#include<iostream>
#include<string.h>
#include<cmath>
using namespace std;
int ToDigit(int n){
if(n>='A'&&n<='F')
return n-'A'+10;
return n-'1'+1;
}
int main()
{
int nlength, sum=0;
char arr[10];
cout<<"请输入一个十六进制数(字母需大写):"<<endl;
cin>>arr;
nlength=strlen(arr);
for(int i=0;i<=nlength-1;i++)
{
sum+=ToDigit(arr[i])*pow(16,nlength-1-i);
}
cout<<"转制结果为:"<<sum<<endl;
return 0;
}
/*
请输入一个十六进制数(字母需大写):
1F
转制结果为:31
Process returned 0 (0x0) execution time : 1.966 s
Press any key to continue.
*/
buyong 2014-05-05
- 打赏
- 举报
加载更多回复（4）
