質問をすることでしか得られない、回答やアドバイスがある。

15分調べてもわからないことは、質問しよう!

ただいまの
回答率

90.51%

  • C#

    9045questions

    C#はマルチパラダイムプログラミング言語の1つで、命令形・宣言型・関数型・ジェネリック型・コンポーネント指向・オブジェクティブ指向のプログラミング開発すべてに対応しています。

出力した逆ポーランド法の式を計算して結果を返す方法

受付中

回答 3

投稿

  • 評価
  • クリップ 0
  • VIEW 1,452
退会済みユーザー

退会済みユーザー

C#

前提・実現したいこと

出力した逆ポーランド記法の式の演算結果を出力したい

該当のソースコード

using System;
using System.Collections;
using System.Collections.Generic;

// char型要素の配列のスタックのクラス
class Stack_char :IEnumerable {
    char[] data;     // データを格納する配列
    int max;    // 要素の最大格納数
    int top=-1;     // topの初期値

    public Stack_char(int n) {  // 最大要素数 n を指定して作成
        data = new char[n];    // 要素数 n の配列を作成
        max = n;            // max を設定
    }

    public bool Push(char c) {
        if (top==max-1) return false;    // 既に最大数格納されていれば false
        top += 1; 
        data[top] = c;
        return true;    // Pushに成功すれば true
    }

    public char Pop() {
        top -= 1; 
        return data[top+1];
    }

    public char Top() {
        return data[top];
    }

    public bool isEmpty() {
        return (top==-1);
    }

    public bool isFull() {
        return (top==max-1);
    }

    public int Count() {
        return (top+1);
    }

    public IEnumerator GetEnumerator() {
        // リストの最初の要素から順に要素を取り出して返す
        int i=top;
        while (i >= 0) {
            yield return data[i];
            i -= 1;
        }
    }

    public void List() {
        foreach (char k in this)
            Console.Write("{0} ", k);
        Console.WriteLine();
    }
};


class Hoge {
    static void Main(string[] args) {
        List<char> output = new List<char>();
        // 出力される文字列を格納するchar型動的配列
        Stack_char oprs = new Stack_char(100);
        // (char型要素の)スタックを作成(要素無し) 演算子用
        char opr = ' ';

        Console.Write("B型単純式を入力 : ");
        string exp = Console.ReadLine();

        foreach (char c in exp) {
            switch (c)
            {
                case '+':
                case '-':
                case '*':
                case '/':
                    opr = c;
                    break;
                case '(':
                    if (opr!=' ')
                        oprs.Push(opr);
                    opr = ' ';
                    break;
                case ')':
                    if (!oprs.isEmpty()) {
                        char temp = oprs.Pop();
                        Console.Write("{0} ", temp);
                        output.Add(temp); output.Add(' ');                
                    }
                    break;
                case ' ':
                    break;
                default:
                    if ('0'<=c && c<='9') {
                        Console.Write("{0} ", c);
                        output.Add(c); output.Add(' ');                
                        if (opr!=' ') {
                            Console.Write("{0} ", opr);
                            output.Add(opr); output.Add(' ');
                            opr = ' ';
                        }
                    }
                    break;
            }
            if (c!=' ') { Console.Write("c="+c+" oprs = "+opr +" "); oprs.List();}
        }

        while (!oprs.isEmpty()) {
            char c = oprs.Pop();
            Console.Write("{0} ", c);
            output.Add(c); output.Add(' ');                
        }
        Console.WriteLine();
        foreach (char c in output)
            Console.Write(c);
        Console.WriteLine();
    }
}

試したこと

foreach文を最後に挿入し、cの出力結果を参考に計算するものを実装(ただ普通の式では無いので検索や発想も虚しく終了...)

補足情報(言語/FW/ツール等のバージョンなど)

B型単純式は講義内で聞いたところ、演算子による演算の優先度を無視するそうです。(1+2*3は7ではなく、9です)

  • 気になる質問をクリップする

    クリップした質問は、後からいつでもマイページで確認できます。

    またクリップした質問に回答があった際、通知やメールを受け取ることができます。

    クリップを取り消します

  • 良い質問の評価を上げる

    以下のような質問は評価を上げましょう

    • 質問内容が明確
    • 自分も答えを知りたい
    • 質問者以外のユーザにも役立つ

    評価が高い質問は、TOPページの「注目」タブのフィードに表示されやすくなります。

    質問の評価を上げたことを取り消します

  • 評価を下げられる数の上限に達しました

    評価を下げることができません

    • 1日5回まで評価を下げられます
    • 1日に1ユーザに対して2回まで評価を下げられます

    質問の評価を下げる

    teratailでは下記のような質問を「具体的に困っていることがない質問」、「サイトポリシーに違反する質問」と定義し、推奨していません。

    • プログラミングに関係のない質問
    • やってほしいことだけを記載した丸投げの質問
    • 問題・課題が含まれていない質問
    • 意図的に内容が抹消された質問
    • 広告と受け取られるような投稿

    評価が下がると、TOPページの「アクティブ」「注目」タブのフィードに表示されにくくなります。

    質問の評価を下げたことを取り消します

    この機能は開放されていません

    評価を下げる条件を満たしてません

    評価を下げる理由を選択してください

    詳細な説明はこちら

    上記に当てはまらず、質問内容が明確になっていない質問には「情報の追加・修正依頼」機能からコメントをしてください。

    質問の評価を下げる機能の利用条件

    この機能を利用するためには、以下の事項を行う必要があります。

質問への追記・修正、ベストアンサー選択の依頼

  • Zuishin

    2017/05/29 21:14

    全部書き直したいくらいです。もうちょっと練れるはずですが、とりあえずコードを少なくするためにスタックは既存の物を使って書き直してください。バグの入る可能性が減ります。

    キャンセル

  • 退会済みユーザー

    退会済みユーザー

    2017/05/29 21:20

    既存のもの・・・ですか???

    キャンセル

  • Zuishin

    2017/05/29 21:42

    System.Collections.Generic.Stack<char> です。スタッククラスにもバグが入っていますが、そのデバッグが不要になります。

    キャンセル

回答 3

+1

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text.RegularExpressions;

class Program
{
    static List<string> Split_Nums(string str)
    {
        str = str.Replace(" ", "");
        str = str.Replace("**", "^");
        str = str.Replace(",", "");

        Regex re = new Regex(@"\((?<nega>-\d+?(|.\d+?))\)");

        List<string> negative = new List<string>();

        MatchCollection mc = re.Matches(str);

        foreach (Match m in mc)
        {
            negative.Add(m.Groups["nega"].Value);
        }

        str = re.Replace(str, "f");

        List<string> for_translate = new List<string>();
        List<string> tmp = new List<string>();

        for (int i = 0; i < str.Length; i++)
        {
            if ("+-*/%^()[]{}".Contains(str[i]))
            {
                if (tmp.Count > 0)
                {
                    for_translate.Add(string.Join("", tmp));
                    tmp.Clear();
                }

                for_translate.Add(str[i].ToString());
            }
            else
            {
                tmp.Add(str[i].ToString());
            }

            if (i == str.Length - 1)
            {
                if (tmp.Count > 0)
                {
                    for_translate.Add(string.Join("", tmp));
                }
            }
        }

        for (int i = 0; i < for_translate.Count; i++)
        {
            if (for_translate[i] == "f")
            {
                for_translate[i] = negative[0];
                negative.RemoveAt(0);
            }
        }

        return for_translate;
    }

    //かっこが正しいか数値が正しいかを判定
    static Object Check(List<string> list)
    {
        bool valid_nest = true;

        List<string> nest = new List<string>();

        Dictionary<string, string> p_dic = new Dictionary<string, string>()
            {
                { ")", "(" },
                { "]", "[" },
                { "}", "{" }
            };

        foreach (string e in list)
        {
            if ("([{".Contains(e))
            {
                nest.Add(e);
            }
            else if (")]}".Contains(e))
            {
                if (nest.Count < 1)
                {
                    valid_nest = false;
                    break;
                }

                if (nest.Last() != p_dic[e])
                {
                    valid_nest = false;
                    break;
                }

                nest.RemoveAt(nest.Count - 1);
            }
        }

        if (nest.Any()) valid_nest = false;

        if (valid_nest)
        {
            int nums = 0;
            int symbol = 0;

            foreach (string e in list)
            {
                if ("+-*/%^()[]{}".Contains(e) == false)
                {
                    double d = 0;

                    if (double.TryParse(e, out d))
                    {
                        nums++;
                    }
                }
                else if (("+-*/%^".Contains(e)))
                {
                    symbol++;
                }
            }

            if (nums <= symbol) return "Invalid expression";

            for (int i = 0; i < list.Count; i++)
            {
                if ("[{".Contains(list[i])) list[i] = "(";
                if ("]}".Contains(list[i])) list[i] = ")";
            }

            return list;
        }

        return "Missing end bracket";
    }

    //逆ポーランド記法に変換
    static List<string> Translate(List<string> list)
    {
        List<string> stack = new List<string>();
        List<string> for_calc = new List<string>();

        for (int i = 0; i < list.Count; i++)
        {
            if (list[i] == "(")
            {
                stack.Add(list[i]);
            }
            else if (list[i] == ")")
            {
                while (stack.Last() != "(")
                {
                    for_calc.Add(stack.Last());
                    stack.RemoveAt(stack.Count - 1);
                }

                stack.RemoveAt(stack.Count - 1);
            }
            else if ("+-*/%^".Contains(list[i]))
            {
                if (stack.Count > 0)
                {
                    if ("+-".Contains(list[i]))
                    {
                        while ("+-*/%^".Contains(stack.Last()))
                        {
                            for_calc.Add(stack.Last());
                            stack.RemoveAt(stack.Count - 1);

                            if (stack.Count < 1) break;
                        }
                    }
                    else if ("*/%".Contains(list[i]))
                    {
                        while ("*/%^".Contains(stack.Last()))
                        {
                            for_calc.Add(stack.Last());
                            stack.RemoveAt(stack.Count - 1);

                            if (stack.Count < 1) break;
                        }
                    }
                }

                stack.Add(list[i]);
            }
            else
            {
                for_calc.Add(list[i]);
            }

            if (i == list.Count - 1)
            {
                if (stack.Count > 0)
                {
                    stack.Reverse();

                    foreach (string e in stack)
                    {
                        for_calc.Add(e);
                    }
                }
            }
        }

        return for_calc;
    }

    //逆ポーランド記法を解く
    static double Calc_Porland(List<string> list)
    {
        List<string> stack = new List<string>();

        while (list.Any())
        {
            stack.Add(list[0]); list.RemoveAt(0);

            if ("+-*/%^".Contains(stack.Last()))
            {
                List<string> tmp = stack.GetRange(stack.Count() - 3, 3);

                stack.RemoveRange(stack.Count() - 3, 3);

                double a = double.Parse(tmp[0]);
                double b = double.Parse(tmp[1]);

                double d = 0.0D;

                switch (tmp[2])
                {
                    case "+":
                        d = a + b;
                        break;
                    case "-":
                        d = a - b;
                        break;
                    case "*":
                        d = a * b;
                        break;
                    case "/":
                        d = a / b;
                        break;
                    case "%":
                        d = a % b;
                        break;
                    case "^":
                        d = Math.Pow(a, b);
                        break;
                }

                stack.Add(d.ToString());
            }
        }

        return double.Parse(stack[0]);
    }

    static string Calculate(string str)
    {
        var nums = Split_Nums(str);

        var result = Check(nums);

        if (result is String) return (string)result;

        double ans = Calc_Porland(Translate((List<string>)result));

        return ans.ToString();
    }

    static void Main(string[] args)
    {
        string input = "[{(1+2)*(3+4)}+{(5+6)*(7+8)}]*[{(9+10)*(11+12)}+{(13+14)*(15+16)}]*(-1)+0.1";
        Console.WriteLine(Calculate(input));
        Console.ReadKey();
    }
}


参考にしたサイト
【Ruby】【アルゴリズム】逆ポーランド記法
逆ポーランド記法による計算式を計算する電卓
逆ポーランド記法変換ツール
rubyについて質問です。のkatoy様の回答
逆ポーランド記法への変換2
素人ですが考えてみました。
このプログラムが正確に動くかどうかは分かりません。
B型単純式についてはよくわからなかったので何もしていません。

投稿

編集

  • 回答の評価を上げる

    以下のような回答は評価を上げましょう

    • 正しい回答
    • わかりやすい回答
    • ためになる回答

    評価が高い回答ほどページの上位に表示されます。

  • 回答の評価を下げる

    下記のような回答は推奨されていません。

    • 間違っている回答
    • 質問の回答になっていない投稿
    • スパムや攻撃的な表現を用いた投稿

    評価を下げる際はその理由を明確に伝え、適切な回答に修正してもらいましょう。

  • 2017/07/07 21:26 編集

    私の画面では編集結果が反映されていないので注意書きをします。

    回答の「編集 2017/06/29 01:57」を押すと編集履歴を見ることができます。
    編集履歴には回答の変更が反映されています。

    編集前の「編集 2017/06/29 01:57」の回答はtranslateの
    部分がおかしいです。
    +-と*/%の計算順序を間違えています。

    キャンセル

+1

逆ポーと言えばスタックなのでスタックつこてみた

尚、

  1. スタックサイズはメモリの限り
  2. 動作詳細はHP35sに準拠(完全じゃない

あたりで一つよろしく

using System;
using System.Collections.Generic;
using System.Linq;

namespace ConsoleApp6
{
    internal class Program
    {
        private static readonly Stack<double> Stack = new Stack<double>();
        private static readonly double[] Dummy = new double[4];
        private static readonly string[] Tag = {"X", "Y", "Z", "T"};

        private static void Main(string[] args)
        {
            double x, y;

            for (;;)
            {
                var input = Console.ReadLine().Split(' ');

                foreach (var s in input)
                    if (double.TryParse(s, out var d))
                    {
                        Stack.Push(d);
                    }
                    else if (s == "+")
                    {
                        if (Stack.Count >= 2)
                        {
                            x = Stack.Pop();
                            y = Stack.Pop();

                            Stack.Push(x + y);
                        }
                    }
                    else if (s == "-")
                    {
                        if (Stack.Count >= 2)
                        {
                            x = Stack.Pop();
                            y = Stack.Pop();

                            Stack.Push(x + y);
                        }
                    }
                    else if (s == "*")
                    {
                        if (Stack.Count >= 2)
                        {
                            x = Stack.Pop();
                            y = Stack.Pop();

                            Stack.Push(x * y);
                        }
                    }
                    else if (s == "/")
                    {
                        if (Stack.Count >= 2)
                        {
                            x = Stack.Pop();
                            y = Stack.Pop();

                            Stack.Push(x / y);
                        }
                    }
                    else if (s == "exit")
                    {
                        goto RETURN;
                    }
                    else
                    {
                        Console.WriteLine($"{s} is invalid input");
                    }

                DispStack();
            }

            RETURN:
            ;
        }


        private static void DispStack()
        {
            Console.ForegroundColor = ConsoleColor.Green;

            foreach (var element in Stack.Concat(Dummy).Zip(Tag, (d, s) => (value:d, tag:s)).Reverse())
                Console.WriteLine($"\t{element.tag}:{element.value}");

            Console.ForegroundColor = ConsoleColor.Gray;
        }
    }
}

投稿

  • 回答の評価を上げる

    以下のような回答は評価を上げましょう

    • 正しい回答
    • わかりやすい回答
    • ためになる回答

    評価が高い回答ほどページの上位に表示されます。

  • 回答の評価を下げる

    下記のような回答は推奨されていません。

    • 間違っている回答
    • 質問の回答になっていない投稿
    • スパムや攻撃的な表現を用いた投稿

    評価を下げる際はその理由を明確に伝え、適切な回答に修正してもらいましょう。

0

teratailの運営様に編集結果が反映されない件についてお問い合わせを
行っており、その件で改めて編集が反映されないかどうかをテストさせていただいています。

using System;
using System.Collections.Generic;
using System.Text.RegularExpressions;  
using System.Linq;
namespace calc_porland
{
   class Program
   {
       //式分解
       static List<string> split_nums(string str)
       {
           str = str.Replace(" ", "");
           str = str.Replace("**", "^");
           str = str.Replace("f", "");  

           Regex re = new Regex(@"\((?<nega>-\d+?(|.\d+?))\)");  

           List<string> negative = new List<string>();  

           MatchCollection mc = re.Matches(str);  

           foreach(Match m in mc)  
           {  
               negative.Add(m.Groups["nega"].Value);  
           }  

           str = re.Replace(str, "f");  
           List<string> for_translate = new List<string>();
           List<string> tmp = new List<string>();
           for (int i = 0; i < str.Length; i++)
           {
               if ("+-*/%^()[]{}".Contains(str[i]))
               {
                   if (tmp.Count > 0)
                   {
                       for_translate.Add(string.Join("", tmp));
                       tmp.Clear();
                   }
                   for_translate.Add(str[i].ToString());
               }
               else
               {
                   tmp.Add(str[i].ToString());
               }
               if(i == str.Length - 1)
               {
                   if(tmp.Count > 0)
                   {
                       for_translate.Add(string.Join("", tmp));
                   }
               }
           }
           for(int i =0;i < for_translate.Count; i++)  
           {  
               if (for_translate[i] == "f")  
               {  
                   for_translate[i] = negative[0];  
                   negative.RemoveAt(0);  
               }  
           }  

           return for_translate;
       }
       //かっこが正しいか数値が正しいかを判定
       static Object check(List<string> list)
       {
           bool valid_nest = true;
           List<string> nest = new List<string>();
           Dictionary<string, string> p_dic = new Dictionary<string, string>()
           {
               { ")", "(" },
               { "]", "[" },
               { "}", "{" }
           };
           foreach(string e in list)
           {
               if ("([{".Contains(e))
               {
                   nest.Add(e);
               }
               else if (")]}".Contains(e))
               {
                   if(nest.Count < 1)
                   {
                       valid_nest = false;
                       break;
                   }
                   if(nest.Last() != p_dic[e])
                   {
                       valid_nest = false;
                       break;
                   }
                   nest.RemoveAt(nest.Count - 1);
               }
           }
           if (nest.Any()) valid_nest = false;
           if(valid_nest)
           {
               bool valid_number = true;
               int nums = 0;
               int symbol = 0;
               foreach(string e in list)
               {
                   if ("+-*/%^()[]{}".Contains(e) == false)
                   {
                       double d = 0;
                       if (double.TryParse(e, out d))
                       {
                           nums++;
                       }
                       else
                       {
                           valid_number = false;
                       }
                   }
                   else if(("+-*/%^".Contains(e)))
                   {
                       symbol++;
                   }
               }
               if (nums <= symbol) return "式が不正です";
               if(valid_number)
               {
                   for (int i = 0; i < list.Count; i++)
                   {
                       if ("[{".Contains(list[i])) list[i] = "(";
                       if ("]}".Contains(list[i])) list[i] = ")";
                   }
                   return list;
               }
               else
               {
                   return "数値が不正です";
               }
           }
           return "かっこが不正です";
       }
       //逆ポーランド記法に変換
       static List<string> translate(List<string> list)
       {
           List<string> stack = new List<string>();
           List<string> for_calc = new List<string>();
           for(int i = 0; i < list.Count; i++)
           {
               if(list[i] == "(")
               {
                   stack.Add(list[i]);
               }
               else if(list[i] == ")")
               {
                   while (stack.Last() != "(")
                   {
                       for_calc.Add(stack.Last());
                       stack.RemoveAt(stack.Count - 1);
                   }
                   stack.RemoveAt(stack.Count - 1);
               }
               else if ("+-*/%^".Contains(list[i]))
               {
                   if(stack.Count > 0)
                   {
                       if ("+-".Contains(list[i]))
                       {
                           while ("*/%^".Contains(stack.Last()))
                           {
                               for_calc.Add(stack.Last());
                               stack.RemoveAt(stack.Count - 1);
                               if (stack.Count < 1) break;
                           }
                       }
                       else if (list[i] == "*")
                       {
                           while ("/%^".Contains(stack.Last()))
                           {
                               for_calc.Add(stack.Last());
                               stack.RemoveAt(stack.Count - 1);
                               if (stack.Count < 1) break;
                           }
                       }
                       else if ("/%".Contains(list[i]))
                       {
                           while (stack.Last() == "^")
                           {
                               for_calc.Add(stack.Last());
                               stack.RemoveAt(stack.Count - 1);
                               if (stack.Count < 1) break;
                           }
                       }
                   }
                   stack.Add(list[i]);
               }
               else
               {
                   for_calc.Add(list[i]);
               }
               if(i == list.Count - 1)
               {
                   if (stack.Count > 0)
                   {
                       stack.Reverse();
                       foreach(string e in stack)
                       {
                           for_calc.Add(e);
                       }
                   }
               }
           }
           return for_calc;
       }
       //逆ポーランド記法を解く
       static double calc_porland(List<string> list)
       {
           List<double> stack = new List<double>();
           foreach(string e in list)
           {
               double d = 0;
               if(double.TryParse(e, out d))
               {
                   stack.Add(d);
               }
               else
               {
                   double a = stack.Last(); stack.RemoveAt(stack.Count - 1);
                   double b = stack.Last(); stack.RemoveAt(stack.Count - 1);
                   double acue = 0;
                   switch (e)
                   {
                       case "+":
                           acue = b + a;
                           break;
                       case "-":
                           acue = b - a;
                           break;
                       case "*":
                           acue = b * a;
                           break;
                       case "/":
                           acue = b / a;
                           break;
                       case "%":
                           acue = b % a;
                           break;
                       case "^":
                           acue = Math.Pow(b, a);
                           break;
                   }
                   stack.Add(acue);
               }
           }
           return stack[0];
       }
       //上のメソッドの結果を合体
       static string porland(string str)
       {
           List<string> for_check = split_nums(str);
           var result = check(for_check);
           if (result is String)
           {
               return (string)result;
           }
           else
           {
               return calc_porland(translate((List<string>)result)).ToString();
           }
       }
       static void Main(string[] args)
       {
           //string input = "[{(1+2)*(3+4)}+{(5+6)*(7+8)}]*[{(9+10)*(11+12)}+{(13+14)*(15+16)}]";
           string input = "[{(1+2)*(3+4)}+{(5+6)*(7+8)}]*[{(9+10)*(11+12)}+{(13+14)*(15+16)}]*(-1)+0.1";
           Console.WriteLine(porland(input));
           Console.ReadKey();
       }
   }
}


参考にしたサイト
【Ruby】【アルゴリズム】逆ポーランド記法
逆ポーランド記法による計算式を計算する電卓
逆ポーランド記法変換ツール
rubyについて質問です。のkatoy様の回答
逆ポーランド記法への変換2
素人ですが考えてみました。
このプログラムが正確に動くかどうかは分かりません。
B型単純式についてはよくわからなかったので何もしていません。

投稿

編集

  • 回答の評価を上げる

    以下のような回答は評価を上げましょう

    • 正しい回答
    • わかりやすい回答
    • ためになる回答

    評価が高い回答ほどページの上位に表示されます。

  • 回答の評価を下げる

    下記のような回答は推奨されていません。

    • 間違っている回答
    • 質問の回答になっていない投稿
    • スパムや攻撃的な表現を用いた投稿

    評価を下げる際はその理由を明確に伝え、適切な回答に修正してもらいましょう。

同じタグがついた質問を見る

  • C#

    9045questions

    C#はマルチパラダイムプログラミング言語の1つで、命令形・宣言型・関数型・ジェネリック型・コンポーネント指向・オブジェクティブ指向のプログラミング開発すべてに対応しています。