二十进制的加法

题目描述:


        在二十进制中,我们除了使用数字0-9以外,还使用字母a-j(表示10-19),给定两个二十进制整数,求它们的和。 输入是两个二十进制整数,且都大于0,不超过100位; 输出是它们的和(二十进制),且不包含首0。我们用字符串来表示二十进制整数。                

       分析:在第一眼看到这道题的时候,我相信你也会有一个思路:从两字符的右端开始操作,并且每次都将相应的字符转化为十进制后再相加,如果有进位就将进位1加到下一位高位上,最后再将得到的额十进制结果转化为字符存储起来。当我们将所有数加完之后,你也许会发现,假如最高位有进位,那怎么办呢?这个问题还是要解决的,而且不难解决,只要我们将保存结果的字符数组声明比输入两个数的长度最长的那个长度+1就可。最终判断最高位是否溢出,如果溢出,那么就将最高位设置为字符1,否则,则将最高为去掉后再返回地址在输出。本人就根据这个思路把代码实现了,但是由于初出茅庐,代码质量不是很好,请见谅。注释只注释前一部分,因为后一部分和前面的大致一样意思。

算法实现:

char* calculate(char* x, char* y)
{
	int tempx, tempy,site,cf=0;//定义临时x,y以及标志site,是否有进位cf
	int i,clen,lenx,leny,len;//clen为两字符长度差
	char *sum;//存放结果
	//x、y的长度
	lenx = strlen(x);
	leny = strlen(y);
	//判断x、y的长度
	if (lenx>leny)
	{
		site = 1;
		clen = lenx - leny;
		len = lenx;
	}
	else
	{
		site = 0;
		clen = leny - lenx;
		len = leny;
	}

	sum = (char *)malloc((len+1) * sizeof(char));
	memset(sum, 0, sizeof(sum));
	//从字符后面算起,即低位算起
	for (i = len - 1; i >=0; i--)
	{
		if (site==1)//如果x比y的长度长
		{
			//字符转为十进制
			if (x[i]<='9')
			{
				tempx=x[i] - '0';
				tempy = 0;
			}
			else
			{
				tempx = x[i] - 87;
				tempy = 0;
			}
			if (i >= clen)//将字符短的y停止,因为y已算完
			{
				if (y[i - clen] <= '9')
				{
					tempy = y[i - clen] - '0';
				}
				else
				{
					tempy = y[i - clen] - 87;
				}
			}
			//转化为二十进制,保存结果
			if (cf + tempx + tempy>=20)//该位置的和大于等于20,则有进位
			{
				if (cf + tempx + tempy>29)
				{
					sum[i+1] = cf + tempx + tempy + 67;
				}
				else
				{
					sum[i + 1] = cf + tempx + tempy + 28;
				}
				cf = 1;
			}
			else
			{
				if (cf + tempx + tempy > 9)
				{
					sum[i + 1] = cf + tempx + tempy + 87;
				}
				else
				{
					sum[i + 1] = cf + tempx + tempy + 48;
				}
				cf = 0;
			}
		}
		else//如果x比y的长度短
		{
			if (y[i]<='9')
			{
				tempy = y[i] - '0';
				tempx = 0;
			}
			else
			{
				tempy = y[i] - 87;
				tempx = 0;
			}


			if (i >= clen)
			{
			   if (x[i - clen] <= '9')
			   {
				   tempx = x[i - clen] - '0';
			   }
			   else
			   {
				   tempx = x[i - clen] - 87;
			   }
			}

			if (cf+tempx + tempy>=20)
			{
				if (cf+tempx + tempy>29)
				{
					sum[i + 1] = cf + tempx + tempy + 67;
				}
				else
				{
					sum[i + 1] = cf + tempx + tempy + 28;
				}
				cf = 1;
			}
			else
			{
				if (cf+tempx + tempy > 9)
				{
					sum[i + 1] = cf + tempx + tempy + 87;
					int aaaa = 0;
				}
				else
				{
					sum[i + 1] = cf + tempx + tempy + 48;
				}
				cf = 0;
			}
		}
	}
	if (cf==1)
	{
		sum[0] = 49;
	}
	else
	{
		sum++;
	}
	return  sum;
}



### 二十六进制加法的实现方法 二十六进制是一种基于字母表的进制表示方式,其中每一位可以用英文字母 'A' 到 'Z' 表示数值范围为 0 至 25。为了实现二十六进制加法,可以通过以下逻辑完成: #### 加法规则 1. 将输入的两个二十六进制字符串按位相加。 2. 如果某一位的结果超过 25,则向高位进一,并将该位置调整到对应的余数。 3. 处理最高位可能产生的额外进位。 以下是具体的 Python 和 C 实现代码示例。 --- ### Python 实现二十六进制加法 通过逐字符遍历并累加的方式实现二十六进制加法: ```python def hex26_add(a, b): result = [] carry = 0 # 反转字符串以便从最低位开始计算 a = list(reversed(a.upper())) b = list(reversed(b.upper())) max_len = max(len(a), len(b)) for i in range(max_len): digit_a = ord(a[i]) - ord('A') if i < len(a) else 0 digit_b = ord(b[i]) - ord('A') if i < len(b) else 0 total = digit_a + digit_b + carry carry = total // 26 remainder = total % 26 result.append(chr(remainder + ord('A'))) if carry > 0: result.append(chr(carry + ord('A'))) return ''.join(reversed(result)) # 测试用例 print(hex26_add("AZ", "BA")) # 输出 ZB ``` 上述代码实现了二十六进制加法的核心逻辑[^1]。它利用了 ASCII 编码特性以及模运算来处理进位问题。 --- ### C 实现二十六进制加法 在 C 中同样可以采用类似的思路实现二十六进制加法: ```c #include <stdio.h> #include <string.h> void reverse(char* str) { int n = strlen(str); for (int i = 0; i < n / 2; ++i) { char temp = str[i]; str[i] = str[n - i - 1]; str[n - i - 1] = temp; } } char* hex26_add(const char* a, const char* b) { static char result[100]; // 静态数组用于返回结果 int carry = 0; int len_a = strlen(a); int len_b = strlen(b); int max_len = (len_a > len_b ? len_a : len_b); int index_result = 0; // 创建反转副本 char rev_a[max_len], rev_b[max_len]; strcpy(rev_a, a); reverse(rev_a); strcpy(rev_b, b); reverse(rev_b); for (int i = 0; i < max_len || carry != 0; ++i) { int digit_a = (i < len_a && rev_a[i] >= 'A' && rev_a[i] <= 'Z') ? (rev_a[i] - 'A') : 0; int digit_b = (i < len_b && rev_b[i] >= 'A' && rev_b[i] <= 'Z') ? (rev_b[i] - 'A') : 0; int sum = digit_a + digit_b + carry; carry = sum / 26; result[index_result++] = (sum % 26) + 'A'; } result[index_result] = '\0'; // 结束符 reverse(result); // 转回正序 return result; } // 主函数测试 int main() { printf("%s\n", hex26_add("AZ", "BA")); // 输出 ZB return 0; } ``` 此代码片段展示了如何在 C 中实现二十六进制加法[^3]。注意这里使用静态数组作为返回值容器。 --- ### 总结 无论是 Python 还是 C 的实现方案,核心思想都是通过对字符编码的操作和模运算来解决进位问题。这种技术类似于其他进制加法的通用解决方案[^4]。 ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值