[Algorithm] 백준 1935 - 후위 표기식2 (Node / C#)

문제

https://www.acmicpc.net/problem/1935

 

풀이

1. Node.js(fs)

const fs = require('fs');
const input = fs.readFileSync('/dev/stdin').toString().trim().split('\n');

const N = parseInt(input[0]);
const expression = input[1];
const values = input.slice(2).map(Number);

function calculatePostfix(expr, values) {
    const stack = [];
    const operands = {};

    // A부터 시작하여 각 피연산자에 값 할당
    for (let i = 0; i < N; i++) {
        operands[String.fromCharCode(65 + i)] = values[i];
    }

    for (let char of expr) {
        if (char >= 'A' && char <= 'Z') {
            stack.push(operands[char]);
        } else {
            const b = stack.pop();
            const a = stack.pop();
            switch (char) {
                case '+': stack.push(a + b); break;
                case '-': stack.push(a - b); break;
                case '*': stack.push(a * b); break;
                case '/': stack.push(a / b); break;
            }
        }
    }

    return stack[0].toFixed(2);
}

console.log(calculatePostfix(expression, values));

 

2. Node.js(readLine)

const readline = require('readline');
const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
});

let N, expression, values = [];
let lineCount = 0;

rl.on('line', (line) => {
    if (lineCount === 0) {
        N = parseInt(line);
    } else if (lineCount === 1) {
        expression = line;
    } else {
        values.push(Number(line));
    }
    
    lineCount++;
    
    if (lineCount === N + 2) {
        rl.close();
    }
}).on('close', () => {
    function calculatePostfix(expr, values) {
        const stack = [];
        const operands = {};

        for (let i = 0; i < N; i++) {
            operands[String.fromCharCode(65 + i)] = values[i];
        }

        for (let char of expr) {
            if (char >= 'A' && char <= 'Z') {
                stack.push(operands[char]);
            } else {
                const b = stack.pop();
                const a = stack.pop();
                switch (char) {
                    case '+': stack.push(a + b); break;
                    case '-': stack.push(a - b); break;
                    case '*': stack.push(a * b); break;
                    case '/': stack.push(a / b); break;
                }
            }
        }

        return stack[0].toFixed(2);
    }

    console.log(calculatePostfix(expression, values));
    process.exit(0);
});

3. C#

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        int n = int.Parse(Console.ReadLine()); // 피연산자의 개수 입력
        string postfix = Console.ReadLine(); // 후위 표기식 입력
        double[] values = new double[n];

        for (int i = 0; i < n; i++)
        {
            values[i] = double.Parse(Console.ReadLine()); // 각 피연산자의 값 입력
        }

        // 피연산자와 값 매핑
        Dictionary<char, double> operandMap = new Dictionary<char, double>();
        for (int i = 0; i < n; i++)
        {
            operandMap[(char)('A' + i)] = values[i];
        }

        Stack<double> stack = new Stack<double>();

        foreach (char c in postfix)
        {
            if (char.IsLetter(c))
            {
                stack.Push(operandMap[c]); // 피연산자를 스택에 푸시
            }
            else
            {
                double b = stack.Pop();
                double a = stack.Pop();

                switch (c)
                {
                    case '+':
                        stack.Push(a + b); // 덧셈 연산
                        break;
                    case '-':
                        stack.Push(a - b); // 뺄셈 연산
                        break;
                    case '*':
                        stack.Push(a * b); // 곱셈 연산
                        break;
                    case '/':
                        stack.Push(a / b); // 나눗셈 연산
                        break;
                }
            }
        }

        Console.WriteLine(stack.Peek().ToString("F2")); // 소수점 둘째 자리까지 출력
    }
}

 

설명

1. 입력 처리:
   • 첫 줄에서 피연산자의 개수 N을 읽습니다.
   • 둘째 줄에서 후위 표기식을 읽습니다.
   • N개의 줄에서 각 피연산자에 대응하는 값을 읽습니다.
2. 후위 표기식 계산 함수 (calculatePostfix 또는 CalculatePostfix):
   • 스택을 사용하여 계산을 수행합니다.
   • 피연산자와 그 값을 매핑하는 딕셔너리(또는 해시맵)를 만듭니다.
   • 표현식을 순회하면서:
     • 피연산자(A-Z)를 만나면 해당 값을 스택에 push합니다.
     • 연산자(+, -, *, /)를 만나면 스택에서 두 값을 pop하여 연산을 수행하고 결과를 다시 push합니다.
   • 최종적으로 스택에 남은 값이 계산 결과입니다.
3. 결과 출력:
   • 계산 결과를 소수점 둘째 자리까지 반올림하여 출력합니다.