主页 / 问题 / 1411032
Accepted
Ерлан Сакан
Asked:2022-07-18 04:54:08 +0800 CST2022-07-18 04:54:08 +0800 CST

帮忙举个例子

  • 772

1.6 波兰符号表达式的经济评估（econom.go，4 分） 波兰符号表达式由变量名（从 a 到 z）、括号和三个运算符符号组成：#、$ 和 @（我们将不定义含义的运营商）。

表达式可以包含重复的子表达式。此类表达式的简约求值意味着重复的子表达式仅求值一次。

需要编写一个程序 econom.go 来计算必须执行的操作数以经济地评估表达式。表中给出了程序操作的例子：

对波兰记数法表达式进行经济评估的程序的一组测试 输出应该是什么

(#($(#xy)($(#ab)(#ab)))(@z($(#ab)(#ab)))) = 6

($xy) = 1

x=0

我尝试了不同的方式，但它不能通过循环和新数组来找到类似的

res1 := strings.Count(str1, "($(#ab)(#ab))")

写在这里

res1 := strings.Count(str1, "строка для поиска")

计数用于条件，如果大于 1，则计为 1

golang

1 个回答

  1. Best Answer
    package main

func main() {
    println(opCount("(#($(#xy)($(#ab)(#ab)))(@z($(#ab)(#ab))))"))
    println(opCount("($xy)"))
    println(opCount("x"))
}

func opCount(expr string) int {
    expressions := map[string]bool{}
    var openBraces []int
    for i, c := range expr {
        switch c {
        case '(':
            openBraces = append(openBraces, i)
        case ')':
            lastOpenBrace := len(openBraces) - 1
            subExprStart := openBraces[lastOpenBrace]
            subExpr := expr[subExprStart:i]
            expressions[subExpr] = true
            openBraces = openBraces[:lastOpenBrace]
        }
    }
    return len(expressions)
}

    括号大大简化了任务，而在真正的波兰表示法中，不需要括号。如果表达式没有括号，这就是代码的样子

    package main

import "fmt"

func main() {
    println(opCount("#$#xy$#ab#ab@z$#ab#ab"))
    println(opCount("$xy"))
    println(opCount("x"))
}

type node_t = string

const oper = node_t("oper")
const expr = node_t("expr")

type node struct {
    t node_t
    v string
}

func opCount(input string) int {
    expressions := map[string]bool{}
    var stack []node
    for _, c := range input {
        switch c {
        case '$', '#', '@':
            stack = append(stack, node{t: oper, v: fmt.Sprintf("%s", c)})
        default:
            stack = append(stack, node{t: expr, v: fmt.Sprintf("%s", c)})
        }
        for canFold(stack) {
            lastIdx := len(stack) - 1
            operIdx := lastIdx - 2
            folded := node{t: expr, v: stack[operIdx].v + stack[operIdx+1].v + stack[operIdx+2].v}
            expressions[folded.v] = true
            stack[operIdx] = folded
            stack = stack[:operIdx+1]
        }
    }
    return len(expressions)
}

func canFold(stack []node) bool {
    stackLen := len(stack)
    return stackLen >= 3 && stack[stackLen-3].t == oper && stack[stackLen-2].t == expr && stack[stackLen-1].t == expr
}
    • 2

相关问题