精华内容
下载资源
问答
  • 高精除以高精

    2019-12-26 17:10:21
    高精除以高精,求它们的商和余数。 【算法分析】 高精除以低精是对被除数的每一位(这里的“一位”包含前面的余数,以下都是如此)都除以除数。 高精除以高精则是用减法模拟除法,对被除数的每一位都减去除数,一直...

    高精除以高精,求它们的商和余数。
    【算法分析】
    高精除以低精是对被除数的每一位(这里的“一位”包含前面的余数,以下都是如此)都除以除数。
    高精除以高精则是用减法模拟除法,对被除数的每一位都减去除数,一直减当前位置的数字(包含前面的余数)小于除数(由于每一位的数字小于10,所以对于每一位最多进行10次计算),具体实现< 方法一 >:

    #include<iostream>
    #include<cstring>
    using namespace std;
    int a[101],b[101],c[101],d,i;
    void init(int a[]){//获取字符串 并将字符串逆向存储转换为数组  
    	string s;
    	cin>>s;
    	a[0]=s.length();//a[0]储存字符串的长度 
    	for(i=1;i<=a[0];i++)
    		a[i]=s[a[0]-i]-'0';
    }
    void print(int a[]){//打印函数 逆向输出 
    	if(a[0]==0) {
    		cout<<0<<endl;
    		return ;
    	}
    	for(int i=a[0];i>0;i--) cout<<a[i];
    	cout<<endl;
    	return ;
    } 
    int compare(int a[],int b[]){//比较函数 a>b返回1;a<b返回-1;a=b返回0
    	if(a[0]>b[0]) return 1;
    	if(a[0]<b[0]) return -1;
    	for(int i=a[0];i>0;i--){//从高位向低位比较 
    		if(a[i]>b[i]) return 1;
    		if(a[i]<b[i]) return -1;
    	}
    	return 0;//每一位都相等 
    } 
    void jian(int a[],int b[]){
    	int flag,i;
    	flag=compare(a,b);
    	if(flag==0) {a[0]=0;return;}
    	if(flag==1){
    		for(i=1;i<=a[0];i++){
    			if(a[i]<b[i]){//处理借位 
    				a[i+1]--;
    				a[i]+=10;
    			} 
    			a[i]-=b[i];
    		}
    		while(a[0]>0&&a[a[0]]==0) a[0]--;//修正位数 
    		return;
    	}
    }
    void numcpy(int p[],int q[],int det){//将p数组拷贝到q数组中,从q的det位置开始 
    	for(int i=1;i<=p[0];i++)q[i+det-1]=p[i];
    	q[0]=p[0]+det-1;//更新q的位数 
    }
    void chu(int a[],int b[],int c[]){//除法运算函数 
    	int i,tmp[101];
    	c[0]=a[0]-b[0]+1;//确定商的位数 
    	for(i=c[0];i>0;i--){
    		memset(tmp,0,sizeof(tmp));
    		numcpy(b,tmp,i);
    		while(compare(a,tmp)>=0){//减法模拟除法运算过程 
    			c[i]++;
    			jian(a,tmp);	
    		}
    	}
    	while(c[0]>0&&c[c[0]]==0) c[0]--;
    	return ;
    } 
    int main()
    {
    	memset(a,0,sizeof(a));
    	memset(b,0,sizeof(b));
    	memset(c,0,sizeof(c));
    	init(a);
    	init(b);
    	chu(a,b,c);
    	print(c);
    	print(a);
    	return 0;
    }

    < 方法二 >:

    #include <iostream>
    #include <string.h>
    #include <algorithm> 
    using namespace std;
    #define MAX 400
    
    void IntToChar(int Arr[],char str[],int begin,int end){
    	for(int i=begin;i<end;i++)	str[i]=Arr[i]+'0';	
    	str[end]='\0';
    }
    void CharToInt(char str[],int Arr[]){
    	int i=0;
    	while(str[i]!='\0')	Arr[i]=str[i++]-'0';
    }
    void swap(int &a,int &b){
    	int t=a;a=b;b=t;
    } 
    void filterZero(char a[]){
    	int l;
    	while(a[0]=='0' && a[1]!='\0')	{
    		l=strlen(a);
    		for(int i=0;i<l;i++)	a[i]=a[i+1];
    	}
    }
    void sub( char s1[], char s2[],char s3[])
    {
    	char a[MAX]={0},b[MAX]={0};
    	int ia[MAX]={0},ib[MAX]={0},ic[MAX]={0};
    	int size,la,lb;
    	bool flag = false; //符号位
    	filterZero(s1),filterZero(s2);
    	la=strlen(s1),lb=strlen(s2);
    	if(la<lb ||(la==lb && strcmp(s1,s2)<0)){
    		flag = true;  //结果为负数
    	    strcpy(a,s2),strcpy(b,s1); //复制被减数和减数 
    	    swap(la,lb);
    	}
    	else 	strcpy(a,s1),strcpy(b,s2); //复制被减数和减数 
    	size = la>lb?la:lb;
    	reverse(a,a+la),reverse(b,b+lb);
    	CharToInt(a,ia);
    	CharToInt(b,ib);
    	//减法
    	for(int i=0;i<size;i++){
    		ic[i]+=ia[i]-ib[i];
    		if(ic[i]<0){
    			ic[i+1]--;
    			ic[i]+=10;
    		}
    	}
    	//输出
    	bool bOut=false;
    	int k=0;
    	if(flag)  s3[k++]='-';
     	for(int i=size;i>=0;i--){
     		if(ic[i]) bOut = true;
     		if(bOut) s3[k++]=ic[i]+'0';
     	}
     	//正好为0的情况
    	if(k==0) s3[k++]='0'; 
     	s3[k]='\0';
    } 
    int main(int argc, char *argv[])
    {
    	char a[MAX]={0},b[MAX]={0};
    	int c[MAX]={0};
    	char bcx[MAX],bk[MAX];
    	int size,la,lb,k;
    	cin>>a>>b;
    	la=strlen(a),lb=strlen(b);
    	//特殊情况不够除直接输出结果
    	if(la<lb || (la==lb && strcmp(a,b)<0))
    	{
    		cout<<"0"<<endl<<a<<endl;
    		return 0;
    	} 
    	size=la-lb+1; //确定除的次数 
    	//除法模拟 
    	for(int i=0;i<size;i++){
    		if(i==0){
    			strncpy(bcx,a,lb); //根据除数的长度确定开始的被除数 
    			bcx[lb]='\0'; 
    		}	
    		else{
    			k=strlen(bcx);
    			bcx[k]=a[lb+i-1],bcx[k+1]='\0';
    		}
    		//尝试减法 
    		k=0;
    		sub(bcx,b,bk);  //bk为高精度减法结果数据 
    		while(bk[0]!='-'){
    			k++;
    			strcpy(bcx,bk); //将减的结果更新为被减数 
    			sub(bcx,b,bk);  //继续尝试减法 
    		}
    		c[i]=k; //保存结果
    	}
    	//输出商
    	bool bOut=false;
    	for(int i=0;i<size;i++){
    		if(c[i]) bOut = true;
    		if(bOut) cout<<c[i];
    	}
    	//输出余数 
    	cout<<endl<<bcx<<endl;
    	
    	return 0;
    }

     

    展开全文
  • c++高精除以高精

    2020-09-30 11:20:49
    #include<bits/stdc++.h> using namespace std; int a[1000],b[1000]; int len1,len2,len; int index; int re[1000],p=0; //记录结果 int judge() { int i,j; for(i=len2-1,j=len1-1;...b
    #include<bits/stdc++.h>
    using namespace std;
    int a[1000],b[1000];
    int len1,len2,len;
    int index;
    int re[1000],p=0;  //记录结果 
    int judge()
    {
      int i,j;
      for(i=len2-1,j=len1-1;i>=0;i--,j--)
      {
        if(a[j]<b[i])
        return 1;
        else if(a[j]>b[i])
        return 0;
        else
        continue;
      }
      return 0;
    }
    int main()
    {
      string n,m;
      while(cin>>n>>m)
      {
        index=1;
        memset(re,0,sizeof(re));
        memset(a,0,sizeof(a));
        memset(b,0,sizeof(b));
        int i,j;
        for(i=0;i<n.size();i++)    //倒序存储 
        {
          a[n.size()-1-i]=n[i]-'0';
        }
        for(i=0;i<m.size();i++)
        {
          b[m.size()-1-i]=m[i]-'0';
        }
        len1=n.size();
        len2=m.size();
        index=len1-len2;
        int time=index+1; 
        if(len1==len2&&judge()||len1<len2)
        {
          cout<<0<<endl;
          continue;
        }
        if(b[0]==0)
        {
          cout<<0<<endl;
          continue;
        }
        while(index>=0)      //index相当于除数先与被除数的相同数位对应,例如除数有两位,那么它先与被除数的头两位对应 
        {  
          if(judge())       
          {
            if(a[len1-1]==0)    //之前被除数的数位减去除数的数位 ,使得最后一位变为零,那么将数组a的长度减一,再修正index 
            {
              len1--;
              if(index!=len1-len2)
              {
                index=len1-len2;
                p++;
              }
              if(index<0)
              break;
            }
            if(judge()&&len1-index==len2)    //将被除数与除数的对应数位比较,如除数先与被除数头两位比较,若除数大,则index--,模拟手算 
            {
              index--;
              p++;
              if(index<0)
              break;
            }        
          }  
          for(i=index,j=0;i<len1,j<len2;i++,j++)    //不断进行相减 
          {
            if(a[i]<b[j])
            {
              a[i]=a[i]+10-b[j];
              a[i+1]--;
            }
            else
            {
              a[i]=a[i]-b[j];
            }
          }
          re[p]++;  //相减多少次,商就变为多少 
        }
        i=0;
        while(re[i]==0)    //除去前导零 
        i++;
        for(;i<p;i++)  //输出 
        cout<<re[i];
        cout<<endl;
      }
      return 0;
     } 
    
    展开全文
  • 高精度除法(高精除以高精)模板

    千次阅读 2019-11-01 16:57:57
    (若想查看高精除以单精,请点击链接) 链接 嗯,这个还有点儿难度(虽然不常用),其实也不难,稍微讲讲吧! 在用竖式计算除法的时候,用减法模拟每次的相除,从高位到低位,每次减到不能再减为止,然后向后移一...

    (若想查看高精除以单精,请点击链接)链接
    嗯,这个还有点儿难度(虽然不常用),其实也不难,稍微讲讲吧!

    在用竖式计算除法的时候,用减法模拟每次的相除,从高位到低位,每次减到不能再减为止,然后向后移一位。嗯,就这样。

    Code

    #include<bits/stdc++.h>
    using namespace std;
    
    int c[300];
    char ch1[300],ch2[300],ans[300];
    
    bool cmp(int p,char ch1[],char ch2[])//对前p位的被除数字符串ch1和整个除数字符串ch2比较大小
    {
    	int l=1;
    	while(ch1[l]=='0'&&l<=p-1) l++;//删除被除数的第p位之前已经被减为0的位
    	char tch[300];
    	int cnt=0;
    	for(int i=l;i<=p;i++)
    	{
    		tch[++cnt]=ch1[i];//把被除数删完之后的部分存储在tch里
    	}
    	tch[cnt+1]='\0';
    	if(strlen(tch+1)>strlen(ch2+1)||(strlen(tch+1)==strlen(ch2+1)&&strcmp(tch+1,ch2+1)>=0)) return true;
    	//如果被除数位数比除数位数多,被除数大
    	//如果两者位数相等,根据字母序比较两个字符串大小即可
    	else return false;
    }
    
    void subtraction(int p,char ch1[],char ch2[])
    {
    	int l=1;
    	while(ch1[l]=='0'&&l<=p-1) l++;//删除被除数的第p位之前已经被减为0的位
    	char tch[300];
    	int cnt=-1;
    	for(int i=l;i<=p;i++)
    	{
    		tch[++cnt]=ch1[i];//把被除数删完之后的部分存储在tch里
    	}
    	int ta[300],tb[300];
    	memset(ta,0,sizeof(ta));
    	memset(tb,0,sizeof(tb));
    	int len2=strlen(ch2+1);
    	for(int i=1;i<=cnt+1;i++) ta[i]=tch[cnt+1-i]-'0';//把被除数要相减的部分转化为整数数组
    	for(int i=1;i<=len2;i++) tb[i]=ch2[len2+1-i]-'0';//把除数转化为整数数组
    	int tc[300];
    	memset(tc,0,sizeof(tc));
    	for(int i=1;i<=cnt+1;i++)//高精度减法模板
    	{
    		if(ta[i]-tb[i]<0)
    		{
    			ta[i+1]--;
    			ta[i]+=10;
    		}
    		tc[i]=ta[i]-tb[i];
    	}
    	for(int i=1;i<=cnt+1;i++)
    	{
    		ch1[l-1+i]=tc[cnt+2-i]+'0';//将相减的结果又转化成字符串,并更新被除数
    	}
    }
    
    void add_ans(int p)
    {
    	ans[p]++;
    }
    
    int main()
    {
    	cin>>ch1+1>>ch2+1;//不用转化为整数数组,每次直接对字符串进行操作
    	int len1=strlen(ch1+1);
    	int len2=strlen(ch2+1);
    	for(int i=len2;i<=len1;i++)//从可能产生答案的最高位len2减到最后一位len1
    	{
    		while(cmp(i,ch1,ch2)==true)//每位减到不能再减为止,因此这儿需要做个比较
    		{
    			subtraction(i,ch1,ch2);//用减法模拟每次相除
    			add_ans(i);//答案数组的i位上+1
    		}
    	}
    	int l1=1,l2=1;
    	while(ans[l1]==0&&l1<=len1-1) l1++;//删除存储商的数组中的多余的前导0
    	for(int i=l1;i<=len1;i++) printf("%d",ans[i]);//ans即为存储商的数组
    	cout<<endl;
    	while(ch1[l2]=='0'&&l2<=len1-1) l2++;//删除余数中多余的前导0
    	for(int i=l2;i<=len1;i++) printf("%c",ch1[i]);//ch1(被除数数组)剩余的即为相除余数
    	return 0;
    }
    

    嗯,还是比较有难度,结合竖式相除的过程再理解一下,应该不会有太大问题。(记住:用高精度减法模拟每位相除的过程)

    学习厌倦了?点我有更多精彩哦!

    展开全文
  • 999999999748590 179780909068307566598992807564736854549985603543237528310337 【算法分析】 高精除以低精是对被除数的每一位(这里的“一位”包含前面的余数,以下都是如此)都除以除数,而高精除以高精则是用...

    【题目描述】
           输入两个正整数,求它们的商和余数。
    【输入】
           输入两个低于300位的正整数
    【输出】
           输出商和余数
    【输入样例】
    1231312318457577687897987642324567864324567876543245671425346756786867867867
    1231312318767141738178325678412414124141425346756786867867867
    【输出样例】
    999999999748590
    179780909068307566598992807564736854549985603543237528310337
    【算法分析】
           高精除以低精是对被除数的每一位(这里的“一位”包含前面的余数,以下都是如此)都除以除数,而高精除以高精则是用减法模拟除法,对被除数的每一位都减去除数,一直减到当前位置的数字(包含前面的余数)小于除数(由于每一位的数字小于10,所以对于每一位最多进行10次计算)。
    【参考程序】

    #include <cstdio>
    #include <iostream>
    #include <cstring>
    using namespace std;
    
    int a[101], b[101], c[101], d;
    
    void init(int a[]) {
    	string s;
    	cin >> s;						// 读入字符串s
    	a[0] = s.length();				// 用a[0]计算字符串s的位数
    	for (int i=1; i<=a[0]; i++) {
    		a[i] = s[a[0]-i] - 48;		// 将数串s转换为数组a,并倒序存储 
    	} 	
    }
    
    void print(int a[]) {				// 打印输出 
    	if (a[0] == 0) {
    		cout << 0 << endl;
    		return;
    	}
    	for (int i=a[0]; i>=1; i--) {
    		cout << a[i];
    	}
    	cout << endl;
    	return;
    } 
    
    int compare(int a[], int b[]) {		// 比较a和b的大小关系,若a>b则为1,a<b则为-1,a=b则为0
    	if (a[0] > b[0]) {
    		return 1;
    	} 
    	if (a[0] < b[0]) {
    		return -1;
    	}
    	for (int i=a[0]; i>=1; i--) {	// 从高位到低位比较 
    		if (a[i] > b[i]) {
    			return 1;
    		} 
    		if (a[i] < b[i]) {
    			return -1;
    		}
    	} 
    	return 0;						// 各位都相等则两数相等 
    }
    
    void numcpy(int p[], int q[], int det) {	// 复制p数组到q数组从det开始的地方 
    	for (int i=1; i<=p[0]; i++) {
    		q[i+det-1] = p[i];
    	}
    	q[0] = p[0] + det - 1;
    }
    
    void jian(int a[], int b[]) {			// 计算 a=a-b 
    	int flag = compare(a, b);			// 调用比较函数判断大小 
    	if (flag == 0)  {					// 相等 
    		a[0] = 0;
    		return;
    	}
    	if (flag == 1) {					// 大于 
    		for (int i=1; i<=a[0]; i++) {
    			if (a[i] < b[i]) {			 
    				a[i+1]--;				// 若不够减,则向上借一位 
    				a[i] += 10;
    			}
    			a[i] -= b[i];
    		}
    		while (a[0]>0 && a[a[0]]==0) {
    			a[0]--;						// 修正a的位数 
    		} 
    		return; 
    	}				 
    }
    
    void chugao(int a[], int b[], int c[]) {
    	int tmp[101];
    	c[0] = a[0] - b[0] + 1;
    	for (int i=c[0]; i>0; i--) {
    		memset(tmp, 0, sizeof(tmp));		// 数组清零
    		numcpy(b, tmp, i);
    		while (compare(a, tmp) >= 0) {
    			c[i]++;
    			jian(a, tmp);					// 用减法来模拟 
    		} 
    	}
    	while (c[0]>0 && c[c[0]]==0) {
    		c[0]--;
    	}
    	return;
    }
    
    int main() {
    	memset(a, 0, sizeof(a));
    	memset(b, 0, sizeof(b));
    	memset(c, 0, sizeof(c));
    	
    	init(a);
    	init(b);
    	
    	chugao(a,b,c);
    	
    	print(c);
    	print(a);
    	
    	return 0;
    }
    
    
    展开全文
  • #include &amp;lt;cstdio&amp;gt; #include &amp;lt;iostream&amp;gt; #include &amp;lt;cstring&...{//读入字符串s,用a[0]计算字符串s的位数,将数串s转换为数组a,并倒序存储。......
  • 好像NOIP并不会用到,但是作为强迫症的我还是坚持学了。高精度除以高精度我所知道的有两个思路:
  • 这里,我们讨论一下高精度数除以单精度数的结果,采取的方法是按位相除法。 【参考程序】 #include #include #include using namespace std; int main() { char a1[100]; // 被除数是高精度,使用字符数组...
  • //高精除以高精 #include<iostream> #include<cstring> using namespace std; int a[101],b[101],c[101],i;//a是被除数,b是除数,c是商 //输入函数 void init(int a[]) { string s; cin&...
  • 高精高精

    千次阅读 2018-11-13 14:13:24
    高精除以高精 高精除以高精,求它们的商和余数。 算法分析 高精除以低精是对被除数的每一位都除以除数,(和高精加减乘不一样,高精的被除数不需要倒序存储在int数组中),而高精除以高精则是用减法模拟除法,对被除...
  • 高精除以单精还是比较简单(还不用倒序存储呢),直接模拟竖式就好了。 Code #include<bits/stdc++.h> using namespace std; int a[300],b,c[300],Left; string s; int main() { cin>>s; cin>>...
  • 高精度除法(高精除以低精)利用0~9次的循环减法模拟除法的过程,并计数,从而得到商的值。#include #include #include using namespace std; int main() { char a1[100],c1[100]; int a[100],c[100],lena,i,x=0,...
  • Description高精除以高精 Input每组测试数据个栈2行,每行代表一个高精度整数(不超过100位) Output每组测试数据输出占2行,分别输出商和余数。 Sample Input140 5 Sample Output28 0 思路:高精除以高精是用减法...
  • 高精除以低精

    2018-03-09 20:24:00
    1128: 高精度高精度除法 题目描述 计算n/m的值,设n,m为整数,n的长度小于等于1000,m的长度小于等于15位,要求精确到小数点后500位。如果整数位为零,则省略小数点前的零 输入 两行,每行一个整数 ...
  • 高精除以高精,求它们的商和余数。 【输入】 输入两个低于300位的正整数。 【输出】 输出商和余数。 【输入样例】 1231312318457577687897987642324567864324567876543245671425346756786867867867 ...
  • 由于是高精除以低精(做题要注意题目给的数据范围),所以无需按高精除法做,直接根据除法公式做即可,但是要注意的一点是,如果余数为零,则说明是标号最大的位置。 #include #include #include using ...
  • 题目描述 输入两个整数 a,b,输出它们的商。 输入格式 两行,第一行是被除数,第二行是除数。 输出格式 一行,商的整数部分。... } 答案2 (python自带高精) a=int(input()) #强制类型转换 b=int(input()) print(a//b)
  • 高精除(信息学奥赛一本通-T1308)

    千次阅读 2018-04-15 13:30:46
    高精除以高精,求它们的商和余数。 【输入】 输入两个低于300位的正整数。 【输出】 输出商和余数。 【输入样例】 1231312318457577687897987642324567864324567876543245671425346756786867867867 ...
  • 高精度就是很长很长的数字 低精就是可以直接存在基本类型(int short double...)...//两个正整数,高精度除以低精度,只求整除部分,不求余数 #include<iostream> #include<stdio.h> #include<...
  • 原题转送门:https://www.luogu.com.cn/problem/P1601 题目描述 高精度加法,相当于a+b problem,不用考虑负数. 输入格式 分两行输入。a,b<=10500 输出格式 输出只有一行,代表a+ba+b的值 输入输出样例 ...using
  • } 除法(高精除以低精) #include #include using namespace std; string prec_division(string div_s1,int div_i2){ int div_i1[10100]; memset(div_i1,0,sizeof(div_i1)); int l1=div_s1.length(); for(int i...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 886
精华内容 354
关键字:

高精除以高精