「 【华为OD机试真题 Go语言实现】441、符号运算 | 机试真题+思路参考+代码解析（C卷）」2024年7月16日

已于 2024-07-17 19:18:43 修改
阅读量181 收藏
点赞数 3
分类专栏： 华为OD机试真题Go语言 文章标签： 笔记 华为od
于 2024-07-16 18:30:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nwpule/article/details/140473620
版权

【华为OD机试真题 C语言】441、符号运算 | 机试真题+思路参考+代码解析（C卷）

一、符号解析方法

这个方法不知道能否100%，欢迎大家抽中留言。

package _2024od

import (
	"fmt"
)

type Fraction struct {
	numerator   int
	denominator int
}

type expression struct {
	e      []byte
	offset int
}

func normalizeFraction(f *Fraction) {
	if f.denominator < 0 {
		f.numerator = -f.numerator
		f.denominator = -f.denominator
	}
}

func simplifyFraction(f *Fraction) {
	d := maxCommonDividor(f.numerator, f.denominator)
	f.numerator /= d
	f.denominator /= d
}

func maxCommonDividor(a, b int) int {
	if a < 0 {
		a = -a
	}
	if b < 0 {
		b = -b
	}
	for b != 0 {
		r := a % b
		a = b
		b = r
	}
	return a
}

func addFraction(a, b Fraction) Fraction {
	r := Fraction{
		a.numerator*b.denominator + b.numerator*a.denominator,
		a.denominator * b.denominator,
	}
	simplifyFraction(&r)
	return r
}

func subtractFraction(a, b Fraction) Fraction {
	r := Fraction{
		a.numerator*b.denominator - b.numerator*a.denominator,
		a.denominator * b.denominator,
	}
	simplifyFraction(&r)
	return r
}

func multiplyFraction(a, b Fraction) Fraction {
	r := Fraction{
		a.numerator * b.numerator,
		a.denominator * b.denominator,
	}
	simplifyFraction(&r)
	return r
}

func divideFraction(a, b Fraction) Fraction {
	r := Fraction{
		a.numerator * b.denominator,
		a.denominator * b.numerator,
	}
	simplifyFraction(&r)
	return r
}

func parseExpression(exp *expression) Fraction {
	r := parseTerm(exp)
	for exp.offset < len(exp.e) {
		if exp.e[exp.offset] == 32 {
			exp.offset++
			continue
		}
		op := exp.e[exp.offset]
		if op == '+' || op == '-' {
			exp.offset++
			next := parseTerm(exp)
			if op == '+' {
				r = addFraction(r, next)
			} else {
				r = subtractFraction(r, next)
			}
		} else {
			break
		}
	}
	return r
}

func parseTerm(exp *expression) Fraction {
	r := parseFactor(exp)
	for exp.offset < len(exp.e) {
		if exp.e[exp.offset] == 32 {
			exp.offset++
			continue
		}
		op := exp.e[exp.offset]
		if op == '*' || op == '/' {
			exp.offset++
			next := parseFactor(exp)
			if op == '*' {
				r = multiplyFraction(r, next)
			} else {
				r = divideFraction(r, next)
			}
		} else {
			break
		}
	}
	return r
}

func parseFactor(exp *expression) Fraction {
	for exp.offset < len(exp.e) {
		if exp.e[exp.offset] == 32 {
			exp.offset++
			continue
		} else {
			break
		}
	}
	if exp.e[exp.offset] == '(' {
		exp.offset++
		r := parseExpression(exp)
		exp.offset++
		return r
	} else {
		return parseNumber(exp)
	}
}

func parseNumber(exp *expression) Fraction {
	value := 0
	for exp.offset < len(exp.e) {
		if '0' <= exp.e[exp.offset] && exp.e[exp.offset] <= '9' {
			value = value*10 + int(exp.e[exp.offset]-'0')
			exp.offset++
		} else {
			break
		}
	}
	r := Fraction{value, 1}
	return r
}

func solution441() {
	var exp string
	fmt.Scanf("%d", &exp)
	fraction := parseExpression(&expression{
		[]byte(exp),
		0,
	})
	normalizeFraction(&fraction)
	if fraction.denominator == 0 {
		fmt.Println("Error")
	} else if fraction.denominator == 1 {
		fmt.Println(fraction.numerator)
	} else {
		fmt.Printf("%d/%d\n", fraction.numerator, fraction.denominator)
	}
}

题干测试用例

func Test441(t *testing.T) {
	t.Log(parseExpression(&expression{
		[]byte("1 + 5 * 7 / 8"),
		0,
	}))
	t.Log(parseExpression(&expression{
		[]byte("1 /(0-5)"),
		0,
	}))
	t.Log(parseExpression(&expression{
		[]byte("1 * (3*4/(8-(7+0))"),
		0,
	}))
}

二、中缀/后缀表达式求值解法 

 2024.7.17 更新，新增逆波兰表达式求解方法。未知是否能100%。

type Fraction struct {
	numerator   int
	denominator int
}


func normalizeFraction(f *Fraction) {
	if f.denominator < 0 {
		f.numerator = -f.numerator
		f.denominator = -f.denominator
	}
}

func simplifyFraction(f *Fraction) {
	d := maxCommonDividor(f.numerator, f.denominator)
	f.numerator /= d
	f.denominator /= d
}

func maxCommonDividor(a, b int) int {
	if a < 0 {
		a = -a
	}
	if b < 0 {
		b = -b
	}
	for b != 0 {
		r := a % b
		a = b
		b = r
	}
	return a
}

func addFraction(a, b Fraction) Fraction {
	r := Fraction{
		a.numerator*b.denominator + b.numerator*a.denominator,
		a.denominator * b.denominator,
	}
	simplifyFraction(&r)
	return r
}

func subtractFraction(a, b Fraction) Fraction {
	r := Fraction{
		a.numerator*b.denominator - b.numerator*a.denominator,
		a.denominator * b.denominator,
	}
	simplifyFraction(&r)
	return r
}

func multiplyFraction(a, b Fraction) Fraction {
	r := Fraction{
		a.numerator * b.numerator,
		a.denominator * b.denominator,
	}
	simplifyFraction(&r)
	return r
}

func divideFraction(a, b Fraction) Fraction {
	r := Fraction{
		a.numerator * b.denominator,
		a.denominator * b.numerator,
	}
	simplifyFraction(&r)
	return r
}


func inFix2Suffix(exp []byte) []string {
	stack := make([]byte, 0, len(exp))
	output := make([]string, 0, len(exp))

	num := 0
	for i := 0; i < len(exp); i++ {
		// 遇到'('直接加入符号栈
		if exp[i] == '(' {
			stack = append(stack, exp[i])
			continue
		}
		// 遇到')'; 把符号栈中直到'('的符号出栈，加入output中
		if exp[i] == ')' {
			for len(stack) > 0 && stack[len(stack)-1] != '(' {
				top := stack[len(stack)-1]
				output = append(output, string(top))
				stack = stack[:len(stack)-1]
			}
			// 把'('也弹出
			stack = stack[:len(stack)-1]
			continue
		}
		// 遇到运算符
		// 如果当前运算符的优先级高于或等于栈顶运算符的优先级，将其压入操作符栈。
		if exp[i] == '*' || exp[i] == '/' {
			stack = append(stack, exp[i])
			continue
		}

		// 如果当前运算符的优先级低于栈顶运算符的优先级，则依次弹出操作符栈中的运算符并添加到后缀表达式结果栈中，
		// 直到遇到优先级小于或等于当前运算符的运算符或栈为空。然后将当前运算符压入操作符栈。
		if exp[i] == '+' || exp[i] == '-' {
			if len(stack) > 0 {
				top := stack[len(stack)-1]
				if top == '*' || top == '/' {
					for len(stack) > 0 {
						top := stack[len(stack)-1]
						output = append(output, string(top))
						stack = stack[:len(stack)-1]
					}
				}
			}
			// 当前符号入栈
			stack = append(stack, exp[i])
			continue
		}

		// 读取操作数
		for i < len(exp) && '0' <= exp[i] && exp[i] <= '9' {
			num = num*10 + int(exp[i]-'0')
			i++
		}
		output = append(output, strconv.Itoa(num))
		num = 0
		i--
	}

	// 结束处理：遍历完中缀表达式后，如果操作符栈中还有运算符，则依次弹出并添加到后缀表达式结果栈中。
	for len(stack) > 0 {
		top := stack[len(stack)-1]
		output = append(output, string(top))
		stack = stack[:len(stack)-1]
	}

	return output
}

func evalRPN(rpn []string) Fraction {
	stack := make([]Fraction, 0, len(rpn))
	for _, tok := range rpn {
		switch tok {
		case "*":
			{
				a := stack[len(stack)-1]
				stack = stack[:len(stack)-1]
				b := stack[len(stack)-1]
				stack = stack[:len(stack)-1]
				r := multiplyFraction(b, a)
				stack = append(stack, r)
				break
			}
		case "/":
			{
				a := stack[len(stack)-1]
				stack = stack[:len(stack)-1]
				b := stack[len(stack)-1]
				stack = stack[:len(stack)-1]
				r := divideFraction(b, a)
				stack = append(stack, r)
				break
			}
		case "+":
			{
				a := stack[len(stack)-1]
				stack = stack[:len(stack)-1]
				b := stack[len(stack)-1]
				stack = stack[:len(stack)-1]
				r := addFraction(b, a)
				stack = append(stack, r)
				break
			}
		case "-":
			{
				a := stack[len(stack)-1]
				stack = stack[:len(stack)-1]
				b := stack[len(stack)-1]
				stack = stack[:len(stack)-1]
				r := subtractFraction(b, a)
				stack = append(stack, r)
				break
			}
		default:
			num, _ := strconv.Atoi(tok)
			r := Fraction{
				num,
				1,
			}
			stack = append(stack, r)
			break
		}
	}
	return stack[len(stack)-1]
}

func evalExp(exp string) Fraction {
	e := []byte(strings.Join(strings.Fields(exp), ""))
	return evalRPN(inFix2Suffix(e))
}

func solution441() {
	var exp string
	fmt.Scanf("%d", &exp)
	fraction := evalExp(exp)
	normalizeFraction(&fraction)
	if fraction.denominator == 0 {
		fmt.Println("Error")
	} else if fraction.denominator == 1 {
		fmt.Println(fraction.numerator)
	} else {
		fmt.Printf("%d/%d\n", fraction.numerator, fraction.denominator)
	}
}

测试用例：

func Test441(t *testing.T) {
	t.Log(evalExp("1 + 5 * 7 / 8"))
	t.Log(evalExp("1 /(0-5)"))
	t.Log(evalExp("1 * (3*4/(8-(7+0) ))"))
}

 

nwpule
关注
专栏目录
华为OD机试D卷C卷 - 符号运算（Java & Python& JS & C++ & C ）
算法大师！
01-06 3545
给定一个表达式，求其分数计算结果。 表达式的限制如下： 所有的输入数字皆为正整数（包括0） 仅支持四则运算（±*/）和括号 结果为整数或分数，分数必须化为最简格式（比如6，3/4，7/8，90/7） 除数可能为0，如果遇到这种情况，直接输出"ERROR" 输入和最终计算结果中的数字都不会超出整型范围
华为OD最新真题+A卷+B卷+C卷+代码解析
05-07
华为OD最新真题+A卷+B卷+C卷+代码解析 华为OD最新真题+A卷+B卷+C卷+代码解析 华为OD最新真题+A卷+B卷+C卷+代码解析 华为OD最新真题+A卷+B卷+C卷+代码解析 华为OD最新真题+A卷+B卷+C卷+代码解析 华为OD最新真题+...
【华为OD机试真题2023 C&D卷 JAVA&JS】符号运算
qq_34465338的博客
12-19 624
符号运算 题目描述：给定一个表达式，求其分数计算结果表达式的限制如下：1. 所有的输入数字皆为正整数(包括0)2. 仅支持四则运算(+-*/)和括号3. 结果为整数或分数, 分数必须化为最简格式(比如6, 3/4, 7/8, 90/7)4. 除数可能为0，如果遇到这种情况，直接输出"ERROR"5.输入和最终计算结果中的数字都不会超出整型范围
【2023华为OD-C卷-第三题-符号运算】（JavaScript&Java&Python&C++）
m0_73659489的博客
12-28 1744
这种运算优先级比较高的运算符，因此需要使用一个哈希表去记录上述三个运算符的优先级，然后根据优先级的顺序计算，遇到左括号的时候入栈，遇到右括号的时候计算括号内所有表达式的值即可，一边去遍历一边计算，具体可以参考下面代码细节，Python选手可以直接使用。，因此需要使用两个栈，一个栈来存运算符，另一个栈来存储操作数，由于存在。，数字可能超过两位，可能带有空格，没有负数；用例输入一定合法，不会出现括号匹配的情况。给定一个表达式，求其分数计算结果。其实就是计算表达式的值，运算符有。字符串格式的表达式，仅支持。
2024华为OD机试真题-符号运算-(C++/Python)-C卷D卷-200分
goldarmour的博客
07-16 9930
给定一个表达式，求其分数计算结果。 表达式的限制如下： 所有的输入数字皆为正整数（包括0） 仅支持四则运算（+-*,/）和括号 结果为整数或分数，分数必须化为最简格式（比如6，3/4，7/8，90/7） 除数可能为0，如果遇到这种情况，直接输出"ERROR"
【华为OD机试真题2023 C&D卷 Python&C++】符号运算
qq_34465338的博客
12-19 438
符号运算 题目描述：给定一个表达式，求其分数计算结果表达式的限制如下：1. 所有的输入数字皆为正整数(包括0)2. 仅支持四则运算(+-*/)和括号3. 结果为整数或分数, 分数必须化为最简格式(比如6, 3/4, 7/8, 90/7)4. 除数可能为0，如果遇到这种情况，直接输出"ERROR"5.输入和最终计算结果中的数字都不会超出整型范围
华为OD机试真题（Java），四则运算（100%通过+复盘思路）
学Java，找哪吒
05-30 3138
输入一个表达式（用字符串表示），求这个表达式的值。数据范围：表达式计算结果和过程中满足。保证字符串中的有效字符包括。输入一个算术表达式。
【华为OD机试考生抽中题 C&D卷】符号运算（200 分），用 Python 编码，速通
梦想橡皮擦，专栏100例写作模式先行者，现象级专栏 《Python 爬虫 100 例》作者、《滚雪球学 Python 专栏》原创者
12-15 1012
结果为整数或分数, 分数必须化为最简格式(比如 6, 3/4, 7/8, 90/7)华为 OD C 卷和 D 卷新增题难度整体偏低，大家重点依旧建议刷 B 卷。字符串格式的表达式，仅支持±*/，数字可能超过两位，可能带有空格，没有负数。4. 除数可能为 0，如果遇到这种情况，直接输出"ERROR"1. 所有的输入数字皆为正整数(包括 0)用例的输入一定合法, 不会出现括号不匹配的情况。结果可能是负数, 负号放在最前面。表达式结果，以最简格式表达。长度小于 200 个字符。注意括号可以多重嵌套。
华为OD机试真题.pdf
04-15
华为OD机试真题中涉及的编程知识点包括： 1. 货币转换功能实现：程序需要处理人民币(CNY)、美元(USD)、英镑(GBP)、港币(HKD)之间的价值转换，包括最大兑换和最小兑换两种方式。 2. 汇率处理：题目中给出了默认汇率...
华为OD机试真题整理合集
02-09
华为OD（Online Detection）机试是华为公司招聘技术岗位时进行的一轮在线编程能力测试，旨在评估应聘者的基础编程技能、算法理解与实现能力、问题解决能力等关键素质。本合集整理了华为OD机试的真题，帮助求职者进行...
华为OD机试真题-字符串重传排列2023
04-02
【华为OD机试真题-字符串重传排列2023】是一道考察应聘者编程能力和算法理解的题目。此题目的目标是对输入的字符串进行处理，具体步骤如下： 1. **单词内部调整**：首先，对每个单词的字母进行字典序排序。这意味着...
华为OD机试（A卷+B卷+C卷+D卷）2024真题目录（全、新、准）
07-14
免费贡献专栏内容，懂事的小伙伴私我。
C++学习笔记----6、内存管理（五）---- 智能指针（3）
weixin_71738303的博客
09-11 1191
与指向特定类型的原始指针可以转化为不同类型的指针一样，shared_ptr保存特定的类型可以转化为一个另一种类型的shared_ptr。转化shared_ptr的函数是const_pointer_cast()，dynamic_pointer_cast(),static_pointer_cast()和reinterpret_pointer_cast()。前面简要提过，当拥有共享属主的智能指针，例如shared_ptr不在活动范围或者被重置时，只有它是最后指向的智能指针时才能释放其指向的资源。
ROS组合导航笔记1：融合传感器数据
最新发布
qq_44188415的博客
09-16 618
笔记
arm和riscv系统调用对比(笔记)
maosql
09-13 605
相似之处: ecall 和 SVC 都是用于从用户模式切换到内核模式，执行系统调用。它们的作用和使用方式非常相似，都是触发内核级别的处理，以处理用户请求的特权操作。不同之处: PendSV 是一个用于任务切换的中断机制，与 ecall 和 SVC 的作用不同。PendSV 主要用于上下文切换，而 ecall 和 SVC 是用于请求系统服务的机制。
shader 案例学习笔记之将坐标系分成4个象限
localhost
09-13 232
坐标系被分成了4个单元格，每个单元格都有唯一的索引，后续就可以根据索引去渲染。
UEFI学习笔记（五）：EDK II PCD的概念、类型、使用
qq_44189622的博客
09-11 859
如果在BIOS里面有一些模块是binary方式集成进来的而这些binary又需要用到PCD（用于Binary Release），那么这些Binary集成的要用到的PCD就必须要设置为。PCD的值存在memory里面，下次启动时，上次更改的值丢失了，每次启动都是从default值开始。是存在VPD空间的（在FLASH上，只读），一般是出厂配置。如果platform是从源码build出来的，没有binary在里面的时候，PCD用的都是。作用域在一个模块中（模块级的），可以在Binary Level进行修改。
JUC学习笔记(二)
zhouDonQuixote的博客
09-16 1410
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录四、共享模型之内存4.1 Java 内存模型4.2 可见性退不出的循环解决方法可见性 vs 原子性模式之 Balking1.定义2.实现4.3 有序性原理之指令级并行1. 名词2.鱼罐头的故事3.指令重排序优化4.支持流水线的处理器诡异的结果解决方法原理之 volatile1.如何保证可见性2.如何保证有序性3.double-checked locking 问题4.double-checked locking 解决happens-
华为OD机试真题解析：字符串处理与排序算法
"华为OD机试真题涉及到的是字符串处理，要求应聘者对输入字符串中的单词进行特定的排序和处理。具体任务包括单词内部字母的字典序排序和单词间的多条件排序。这是一个关于算法和字符串操作的问题，需要掌握C++或...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值