长字符串四则运算

最新推荐文章于 2023-01-05 15:50:54 发布
最新推荐文章于 2023-01-05 15:50:54 发布
阅读量471 收藏
点赞数 1
分类专栏： Algorithm 文章标签： 字符串 四则运算
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/broadCE/article/details/78939673
版权

大数是指长度超过long long int（8字节）类型的自然数，该类型的自然数无法直接用整形数据来进行加减乘数四则运算，所以需要将该整形数据转换成int型的字符串，然后再通过对字符串逐位进行加减乘除运算，即可得出实际运算结果。

核心算法见solution.cpp文件。

/*********************************************************************/

                                      main.cpp

/*********************************************************************/

#include <iostream>

#include <string.h>


using namespace std;


char button;
// int dummy1[...];
char number[32 + 1];
// int dummy2[...];
char compare[32 + 1];
// int dummy3[...];
char display[32 + 1];


void Run(char button, char display[32 + 1]);


int main(void)
{
freopen("sample_input.txt", "r", stdin);


int testcase;
cin >> testcase;
for (int t = 1; t <= testcase; ++t)
{
int cnt;
cin >> cnt;
int ret = 0;
for (int i = 0; i < cnt; ++i)
{
cin >> button >> number;
if (button == 'N')
{
int len = strlen(number);
for (int j = 0; j < len; ++j)
{
compare[j] = number[j];
compare[j + 1] = 0;
Run(number[j], display);
if (strcmp(display, compare) == 0)
++ret;
}
}
else
{
Run(button, display);
if (strcmp(display, number) == 0)
++ret;
}
}
cout << "#" << t << " " << ret << endl;
}
return 0;

}


/*********************************************************************/

                                      solution.cpp

/*********************************************************************/

#include <iostream>
#include <string.h>


#define MAX_LEN  (32+1)


//#define DBG




typedef enum
{
FALSE,
TRUE
}STATUS_T;


typedef struct
{
int operate[MAX_LEN];//操作数，按照int型字符串存储
int len;//操作数的长度
}operate_t;


typedef struct
{
operate_t first_orig;//第一个操作数的原始数据
operate_t first_num;//第一个操作数的操作数据
char charact;//操作符
operate_t second_orig;//第二个操作数的原始数据
operate_t second_num;//第二个操作数的操作数据
operate_t dis_result;//操作结果
int flag;


}calculate_t;


calculate_t calculate;


static void init(void)
{
int i;
/*初始化，将所有操作符和操作数清空*/
for (i = 0; i<MAX_LEN; i++)
{
calculate.first_orig.operate[i] = 0;
calculate.first_num.operate[i] = 0;

calculate.second_orig.operate[i] = 0;
calculate.second_num.operate[i] = 0;

calculate.dis_result.operate[i] = 0;
}
calculate.first_orig.len = 0;
calculate.first_num.len = 0;


calculate.second_orig.len = 0;
calculate.second_num.len = 0;
calculate.flag = FALSE;


calculate.dis_result.len = 0;
calculate.charact = '\0';
}
static void debug(void)
{
#ifdef DBG
int i, j;
printf("first num len:%d \n", calculate.first_num.len);


for (i = 0; i<calculate.first_num.len; i++)
{
printf("%d ", calculate.first_num.operate[i]);
}
printf("\n");


printf("second num len:%d \n", calculate.second_num.len);
for (i = 0; i<calculate.second_num.len; i++)
{
printf("%d ", calculate.second_num.operate[i]);
}
printf("\n");
#endif
}


/*对操作数进行翻转，使之按顺序由低序到高序排列*/
static void rollover(void)
{
int i, j, len = 0;
int result[MAX_LEN];


calculate.first_num.len = calculate.first_orig.len;
for (i = 0; i<calculate.first_num.len; i++)
{
calculate.first_num.operate[calculate.first_num.len - i - 1] = calculate.first_orig.operate[i];
}
for (i = calculate.first_num.len; i<MAX_LEN; i++)
{
calculate.first_num.operate[i] = 0;
}


calculate.second_num.len = calculate.second_orig.len;
for (i = 0; i<calculate.second_num.len; i++)
{
calculate.second_num.operate[calculate.second_num.len - i - 1] = calculate.second_orig.operate[i];
}
for (i = calculate.second_num.len; i<MAX_LEN; i++)
{
calculate.second_num.operate[i] = 0;
}


for (i = 0; i<MAX_LEN; i++)
{
calculate.dis_result.operate[i] = 0;
}
calculate.dis_result.len = 0;
}


static void store_result(void)
{
int len = 0, i = MAX_LEN;
while (calculate.dis_result.operate[i] == '\0')
{
i--;
len++;
}
calculate.first_orig.len = MAX_LEN - len + 1;
if (calculate.first_orig.len <= 0)
{
calculate.first_orig.len = 1;
}
for (i = 0; i < calculate.first_orig.len; i++)
{
calculate.first_orig.operate[calculate.first_orig.len - i - 1] = calculate.dis_result.operate[i];
}


calculate.dis_result.len = calculate.first_orig.len;
for (i = 0; i< calculate.dis_result.len; i++)
{
calculate.dis_result.operate[i] = calculate.first_orig.operate[i];
}


calculate.flag = FALSE;
calculate.second_orig.len = 0;
}


static void add(void)
{
int i;
int len, len_first, len_second;


rollover();
debug();
len = (calculate.first_num.len>calculate.second_num.len) ? calculate.first_num.len : calculate.second_num.len;
len_first = calculate.first_num.len;
len_second = calculate.second_num.len;


for (i = 0; i<len; i++)//循环相加
{
calculate.dis_result.operate[i] += calculate.first_num.operate[i];
calculate.dis_result.operate[i] += calculate.second_num.operate[i];


calculate.dis_result.operate[i + 1] += calculate.dis_result.operate[i] / 10;
calculate.dis_result.operate[i] = calculate.dis_result.operate[i] % 10;
}
store_result();
}
static void minus(void)
{
int i, len;


rollover();
debug();


len = calculate.first_num.len;
for (i = 0; i<len; i++)
{
if (i< calculate.second_num.len)//如果长度小于第二个数的长度
{
if (calculate.first_num.operate[i] >= calculate.second_num.operate[i])//第一个数的当前位大于第二个数的当前位，直接减
{
calculate.dis_result.operate[i] = calculate.first_num.operate[i] - calculate.second_num.operate[i];
}
else//第一个数的当前位小于第二个数的当前位，向高位借位之后减
{
calculate.dis_result.operate[i] = calculate.first_num.operate[i] + 10 - calculate.second_num.operate[i];
calculate.first_num.operate[i + 1]--;
}
}
else
{
if (calculate.first_num.operate[i] < 0)//判断减数减完了之后高一位是否小于0
{
calculate.dis_result.operate[i] += 10;
calculate.first_num.operate[i + 1]--;
}
}
}
store_result();
}


static void mult(void)
{
int i, j, len = 0;


/*乘数为0或者被乘数为0， 结果也为0*/
if (((calculate.first_orig.len == 1) && (calculate.first_orig.operate[0] == 0)) || ((calculate.second_orig.len == 1) && (calculate.second_orig.operate[0] == 0)))
{
calculate.first_orig.len = 1;
calculate.first_orig.operate[0] = 0;


calculate.dis_result.len = 1;
calculate.dis_result.operate[0] = 0;


calculate.flag = FALSE;
calculate.second_orig.len = 0;


return;
}


rollover();
debug();


for (i = 0; i<calculate.first_num.len; i++)//从低位到高位循环相乘
{
for (j = 0; j<calculate.second_num.len; j++)
{
calculate.dis_result.operate[i + j] += (calculate.first_num.operate[i])*(calculate.second_num.operate[j]);
calculate.dis_result.operate[i + j + 1] += calculate.dis_result.operate[i + j] / 10;
calculate.dis_result.operate[i + j] = calculate.dis_result.operate[i + j] % 10;
}
}
store_result();
}


static int substract(int* num1, int* num2, int len1, int len2)
{
int i, j;


if (len1 < len2)//如果减数的长度小于被减数，直接退出
{
return -1;
}
if (len1 == len2)//如果减数和被减数相等
{
for (i = len1 - 1; i >= 0; i--)//判断减数是否大于被减数
{
if (num1[i] > num2[i])//大于则继续
{
break;
}
else if (num1[i] < num2[i])//小于则退出
{
return -1;
}
}
}

for (i = 0; i <= len1 - 1; i++)//从低位向高位循环递减
{
num1[i] -= num2[i];
if (num1[i] < 0)//向高位借位
{
num1[i] += 10;
num1[i + 1]--;
}
}
for (i = len1 - 1; i >= 0; i--)
{
if (num1[i])
{
return (i + 1);//返回减完之后结果的长度
}
}

return 0;
}


static void divis(void)
{
int i, j;
int result[MAX_LEN];
int len_first, len_second, len_dif;
int temp;
int* num1, *num2;


rollover();
debug();


len_first = calculate.first_num.len;
len_second = calculate.second_num.len;
if ((len_second == 1) && (calculate.second_num.operate[0] == 0))//如果被除数为0，直接退出
{
return;
}
if ((len_first == 1) && (calculate.first_num.operate[0] == 0))//如果除数为0，则结果为0
{
calculate.first_orig.len = 1;
calculate.first_orig.operate[0] = 0;


calculate.dis_result.len = 1;
calculate.dis_result.operate[0] = 0;


calculate.flag = FALSE;
calculate.second_orig.len = 0;


return;
}


num1 = calculate.first_num.operate;
num2 = calculate.second_num.operate;


if (len_first < len_second)//如果除数小于被除数，直接退出
{
return;
}


len_dif = len_first - len_second;//计算除数和被除数之间的长度差
for (i = len_first - 1; i >= 0; i--)//将被除数左移，使其和除数长度一样
{
if (i >= len_dif)
{
calculate.second_num.operate[i] = calculate.second_num.operate[i - len_dif];//将被除数左移
}
else
{
calculate.second_num.operate[i] = 0;//将剩余位补0
}
}
len_second = calculate.second_num.len = len_first;


for (i = 0; i <= len_dif; i++)//在0-len_dif范围内，对除数和被除数循环做减法运算
{
while ((temp = substract(num1, num2 + i, len_first, len_second - i)) >= 0)//如果做差之后剩余长度大于0
{
len_first = temp;//将该长度赋值给第一个数
calculate.dis_result.operate[len_dif - i]++;//结果的相应位+1
}
}


store_result();
}




void Run(char button, char display[32 + 1])
{
int i;


for (i = 0; i<MAX_LEN; i++)
{
display[i] = '\0';
}
if (button == 'C')
{
init();
display[0] = '0';
return;
}
if(calculate.charact == '\0')
{
if(button == '+' || button == '-' || button == '*' || button == '/' || button == '=')
{
calculate.charact = button;
}
else
{
calculate.first_orig.operate[calculate.first_orig.len++] = button - '0';
}
for (i = 0; i<calculate.first_orig.len; i++)
{
display[i] = calculate.first_orig.operate[i] + '0';
}
}


else //not first num
{
if ((calculate.flag == TRUE) && (button == '+' || button == '-' || button == '*' || button == '/' || button == '='))
{//have the first and second num
if (calculate.charact == '+')
{
add();
}
else if (calculate.charact == '-')
{
minus();
}
else if (calculate.charact == '*')
{
mult();
}
else if (calculate.charact == '/')
{
divis();
}
if (button != '=')
{
calculate.charact = button;
}
else
{
calculate.charact = '\0';
}


for (i = 0; i< calculate.dis_result.len; i++)
{
display[i] = calculate.dis_result.operate[i] + '0';
}
}
else  //second num
{
calculate.flag = TRUE;
calculate.second_orig.operate[calculate.second_orig.len++] = button - '0';
for (i = 0; i<calculate.second_orig.len; i++)
{
display[i] = calculate.second_orig.operate[i] + '0';
}
}
}
}


/*********************************************************************/

                                      sample_input.txt

/*********************************************************************/

6
18
C 0
N 178
/ 178
N 5
= 35
/ 35
N 5
= 7
+ 7
N 5
* 12
N 8
- 96
N 40
= 56
* 56
N 2
= 112
9
C 0
N 123456789
* 123456789
N 123456789123456789
* 15241578765432099750190521
N 987654
/ 15053406233994075046674668827734
N 483969384392948296938372859
= 31104
13
C 0
N 17698243644999381322284432307691
/ 17698243644999381322284432307691
N 238299204849929059530684839
* 74269
N 3920458102912849295
- 291168502845234404290355
N 124859209629582437568939
- 166309293215651966721416
N 69472849396839609384838
- 96836443818812357336578
N 96836443813386970438548
= 5425386898030
27
C 0
N 12345
* 12345
N 9197723418922634758233
* 113545895606599926090386385
N 134786
* 15304397085231177638018819288610
N 0
/ 0
N 3829859374838693945832858
+ 0
N 9991111111111111111111111111
+ 9991111111111111111111111111
N 8888888888888888888888888
+ 9999999999999999999999999999
N 9999999999999999999999
= 10000009999999999999999999998
+ 10000009999999999999999999998
N 9999999999999999999999
= 10000019999999999999999999997
+ 10000019999999999999999999997
N 939583949028693904595893945962
+ 949583969028693904595893945959
N 9949395028492956782934958385939
/ 10898978997521650687530852331898
N 39560386930286930498376983968375
= 0
15
C 0
N 28285828472854892754728478568323
- 28285828472854892754728478568323
N 28285828472854892754728478568323
= 0
+ 0
N 14362352580688212207152021252245
/ 14362352580688212207152021252245
N 492958729386930228493290587
= 29135
C 0
N 48289567434167997493876823785837
/ 48289567434167997493876823785837
N 4829439687385538294392834728
= 9999

输入字符串实现加减乘除四则运算（java）
12-06
将近250行的算法 实现了通过字符串进行加减乘除四则运算 纯通过处理字符串和数组实现 希望能帮助大家： 例如：String input "33+26 77+70"; String result ""; try { result AccountString input ; } catch Exception e { TODO: handle exception } System out println result ; 输出 ：2150">将近250行的算法 实现了通过字符串进行加减乘除四则运算 纯通过处理字符串和数组实现 希望能帮助大家： 例如：String input "33+26 77+70"; String result ""; try { result AccountString input ; } catch Exception e { [更多]
字符串的四则运算
weixin_34159110的博客
09-16 209
四则运算，最常用的当然是逆波兰方法，现将表达式由中缀表达式转化为后缀表达式，然后再使用栈计算即可。这两步下来，估计没有三四百行代码是实现不了的。 中缀表达式转前缀后缀表达式 将中缀表达式转换为后缀表达式的算法思想： 数字时，加入后缀表达式； 运算符： a. 若为 '('，入栈； b. 若为 ')'，则依次把栈中的的运算符加入后缀表达式中，直到出现'('，从栈中删除'('...
字符串四则运算
lionway
05-18 903
#include//中缀表达式求值 #include using namespace std;   int precede(char t1,char t2) //shuru//判断优先级 {     int t=0;     switch(t2)     {     case '+':     case '-':             if(t1=='(
字符串-四则运算
weixin_30888707的博客
09-12 222
题目大意： 有字符串表示的一个四则运算表达式，要求计算出该表达式的正确数值。四则运算即：加减乘除"+-*/"，另外该表达式中的数字只能是1位（数值范围0~9）。另若有不能整除的情况，按向下取整处理，eg: 8/3得出值为2。若有字符串"8+7*2-9/3"，计算出其值为19。 题目来源： 2012年华为上机的一个题目 题目思路： 建立栈分别存储操作符和操作数，比较...
java实现字符串四则运算公式解析工具类的方法
08-27
"java实现字符串四则运算公式解析工具类的方法" 今天小编将为大家分享java实现字符串四则运算公式解析工具类的方法，这个工具类能够帮助用户快速解析和计算字符串形式的四则运算公式。这个工具类被命名为...
Delphi7字符串四则运算解析
07-04
《Delphi7字符串四则运算解析》 在编程领域，Delphi7是一款经典的面向对象的集成开发环境（IDE），尤其适合开发Windows桌面应用程序。本文将深入探讨如何在Delphi7中实现字符串四则运算，这对于那些需要处理动态...
VC++中运算表达式字符串解析求值（四则运算，三角和反三角函数等）
04-09
本主题将探讨如何在VC++中实现一个能够解析和求值包含四则运算及三角和反三角函数的字符串表达式。这种方法的核心是构建一个解析器，它可以理解并执行这些复杂的数学表达式。 首先，我们要明白，对于四则运算，我们...
解析字符串换算为四则运算
最新发布
03-13
解析字符串换算为四则运算公式根据优先级进行数字运算
c++实现数学表达式的四则运算
09-09
c++实现浮点数的四则运算，有兴趣的同学可以多实现几个运算符
c语言四则运算的一个例子
07-27
C 语言的一个四则运算例子 仅供参考 其中设置的加减乘除算法子程序。
简单字符串四则运算
sleeping_dog的专栏
08-07 744
/********************************************************* 3. 简单四则运算 问题描述： 输入一个只包含个位数字的简单四则运算表达式字符串，计算该表达式的值 注 1、表达式只含 +, -, *, / 四则运算符，不含括号 2、表达式数值只包含个位整数(0-9)，且不会出现0作为除数的情况 3、要考虑加减乘除按通常四则运算规定
字符串四则运算求值
susershine的专栏
11-21 1416
假定给定一个四则运算字符串：8+7*2 –9/3;那么该表达式的值为19. 但是如何用C/C++程序上实现计算一个字符串表达式呢？一个常用的做法是将表达式的字符串转换为后缀表达式，即：1）表达式8+2，转换为后缀表达式是8 2+；2）表达式8 +3*4，转换为后缀表达式是834*+； 然后通过栈的操作可以求得它们的结果： 以2）例为例： 压入8，                    
C++实现字符串型四则运算
高高冷的博客
04-17 1080
标题 #include <iostream> #include<bits/stdc++.h> #include <stack> using namespace std; /* 4 + 2 + 4/2 30 / 90 - 26 + 97 - 5 - 6 - 13 / 88 * 6 + 51 / 29 + 79 * 87 + 57 * 92 */ int cmp(const char c1,const char c2) //判断优先级 { if(c1==c2) //
C++四则运算字符串解析（附动图以及动图制作方法）
DayDayUp
04-05 3651
算法动态演示的演示图一般是怎么制作的，PPT https://juejin.cn/post/6844903749203263501 https://github.com/MisterBooo/Play-With-Sort-OC https://www.screentogif.com/
长整型的四则法则混合运算，乘方，阶乘
WXD1234Q的博客
01-05 1232
利用双向循环链表实现长整数的存储，每个结点含一个整型遍历。任何整型变量的范围是-(2^15-1)~(2^15-1)。输入和输出形式：按中国对于长整数的表示习惯，每四位一组，组间用逗号隔开。整型量范围是-(2^n-1)~(2^n-1)，其中，n是由程序读人的参量。输入数据的分组方法可以另外规定。设计一个实现任意长的整数进行四则混合运算的演示程序。实现长整型的四则混合运算；实现长整型的乘方和阶乘运算。
c语言输入字符串做四则运算,C++字符串四则运算实例讲解
weixin_30068505的博客
05-17 1711
15 {16 if (num[i] >= '0'&&num[i] <= '9')17 {18 num2[i] = num[i]-48;//char转换成int19 }20 }21 for (i = 0; i < n; i++)22 {23 if ...
Java实现字符串四则运算示例及解析
在Java编程中，实现字符串的四则运算是一个常见的练习，尤其对于初学者来说，它可以帮助理解基础语法和表达式解析。这个题目要求创建一个简单的程序，能够处理用户输入的数学表达式并进行加减乘除运算。下面将详细...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值