Имплементация простого калькулятора на Golang

Question

Задача: Создать простой калькулятор для операций сложения/вычитания простых чисел, т.е. простых цифр от 0 до 9.

Условие: Необходимо использовать структуры Golang. Результат вычисления записывать в первое поле структуры, во втором хранить последующие поступающие цифры, в третьем - необходимую функцию для вычисления.

Пример 1: Input string: "1+ 1"
Output: 2

Пример 2: Input string: "2-1 +2"
Output: 3

Я написал код, который работает только для первого случая. Результат вычисляется верно.

Вопрос: как необходимо записывать результат первой операции в первое поле структуры, чтобы продолжать вычисления в последовательности как указано во втором примере выше.

Я понимаю так, что заполнение структуры это цикл. И заполнение с выполнением операций пока не иссякнет последовательность это тоже цикл? Не хватает еще одного цикла для решения задачи?

Мой код для первого примера.

package main

import (
    "fmt"
    "strings"
)

// Operation function
type Operate func(int, int) int

// Structure of operands and the operator
type Expression struct {
    X, Y      int
    Operation Operate
}

// Map of single digits
var singledigits = map[string]int{
    "0": 0, "1": 1, "2": 2, "3": 3, "4": 4, "5": 5, "6": 6, "7": 7, "8": 8, "9": 9,
}

// Map of operators "+" "-" and funcs
var operators = map[string]Operate{
    "+": func(x, y int) int { return x + y },
    "-": func(x, y int) int { return x - y },
}

// Filling Expression structure
func (exp Expression) FillingExpression(stringarr []string) Expression {
    for _, elem := range stringarr {
        _, ok := singledigits[elem]

        if ok {
            exp.X = singledigits[stringarr[0]]
            exp.Y = singledigits[stringarr[2]]
        } else {
            exp.Operation = operators[elem]
        }

    }
    return Expression{exp.X, exp.Y, exp.Operation}
}

// Preparing input condition with trim spaces
func PreparingInputCondition(condition string) []string {
    stringArr := []string{}
    conditionArr := strings.Split(condition, "")

    for _, str := range conditionArr {
        if str != " " {
            stringArr = append(stringArr, str)
        }
    }
    return stringArr
}

func main() {
    inputCondition := "1+ 1" // Второе условие "2-1 + 2"
    preparedCondition := PreparingInputCondition(inputCondition)
    fmt.Println("Prepared condition: ", PreparingInputCondition(inputCondition))

    expression := Expression{}

    completeExpression := expression.FillingExpression(preparedCondition)

    result := Expression{
        X:         completeExpression.X,
        Y:         completeExpression.Y,
        Operation: completeExpression.Operation,
    }

    fmt.Println("Result of operation: ", result.Operation(result.X, result.Y))

}

Answer 1

Отвечу на свой вопрос сам. Решение работает для последовательности любой величины)

package main

import (
    "fmt"
    "strings"
)

// Structure of operands and the operator
type Expression struct {
    X, Y      int
    Operation Operate
}

// Filling Expression structure
func (exp *Expression) FillingExpression(stringarr []string) (*Expression, []string) {

    for _, elem := range stringarr {
        _, ok := singledigits[elem]

        if ok {
            exp.X = singledigits[stringarr[0]]
            exp.Y = singledigits[stringarr[2]]
        } else {
            exp.Operation = operators[stringarr[1]]
        }

    }
    exp.X = exp.Operation(exp.X, exp.Y)

    stringarr = stringarr[3:]

    return exp, stringarr
}

// Operation function
type Operate func(int, int) int

// Map of operators "+" "-" and funcs
var operators = map[string]Operate{
    "+": func(x, y int) int { return x + y },
    "-": func(x, y int) int { return x - y },
}

// Map of single digits
var singledigits = map[string]int{
    "0": 0, "1": 1, "2": 2, "3": 3, "4": 4, "5": 5, "6": 6, "7": 7, "8": 8, "9": 9,
}

// Preparing input condition with trim spaces
func PreparingInputSequence(condition string) []string {
    stringArr := []string{}
    conditionArr := strings.Split(condition, "")

    for _, str := range conditionArr {
        if str != " " {
            stringArr = append(stringArr, str)
        }
    }
    return stringArr
}

//  Operations with filled structures
func Operations(exp *Expression, stringarr []string) int {

    for _, elem := range stringarr {
        if len(stringarr) >= 2 {

            _, ok := singledigits[elem]
            if ok {
                exp.Y = singledigits[stringarr[1]]

                exp.X = exp.Operation(exp.X, exp.Y)
                stringarr = stringarr[2:]

            } else {
                exp.Operation = operators[stringarr[0]]
            }

        } else {
            fmt.Println("The sequence is empty")
            break
        }

    }

    return exp.X
}

func main() {

    // First input
    firstInput := "1+1"
    preparedSequence := PreparingInputSequence(firstInput)
    fmt.Println("Prepared first sequence: ", PreparingInputSequence(firstInput)) // [1 + 1]

    firstExpression := Expression{}

    completeFirstExpression, firstSeq := firstExpression.FillingExpression(preparedSequence)

    resultOfFirstInput := Operations(completeFirstExpression, firstSeq)

    fmt.Println("Result of first input: ", resultOfFirstInput) // Output 2

    //Second input
    secondInput := "2+1  -2"
    prSequence := PreparingInputSequence(secondInput)
    fmt.Println("Prepared second sequence: ", prSequence) //[2 + 1 - 2]

    secondExpression := Expression{}

    completeSecondExpression, secondSeq := secondExpression.FillingExpression(prSequence)

    resultOfSecondInput := Operations(completeSecondExpression, secondSeq) // Output 1

    fmt.Println("Result of second input: ", resultOfSecondInput)

    // Third input
    thirdInput := "1+9-4+4-8+8-8+6"

    preSequence := PreparingInputSequence(thirdInput)
    fmt.Println("Prepared third sequence: ", preSequence)

    thirdExpression := Expression{}

    completedThirdExpression, thirdSeq := thirdExpression.FillingExpression(preSequence)

    resultOfThirdInput := Operations(completedThirdExpression, thirdSeq)

    fmt.Println("Result of second input: ", resultOfThirdInput) // Output 8

}

БЛОГ НА HUSL

Имплементация простого калькулятора на Golang

Ответы (1 шт):