回答編集履歴

25 修正

退会済みユーザー

退会済みユーザー

2017/07/17 03:31  投稿

```C#
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)
       {
           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 "Invalid expression";
           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 "Invalid number";
           }
           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】【アルゴリズム】逆ポーランド記法](http://sekai.hateblo.jp/entry/2013/09/15/185314)
[逆ポーランド記法による計算式を計算する電卓](http://calc.exinfo.biz/)
[逆ポーランド記法変換ツール](http://tamanegi-core.net/memo/article/polish_notation_converter)
[rubyについて質問です。](https://teratail.com/questions/80654)のkatoy様の回答
[逆ポーランド記法への変換2](http://www.gg.e-mansion.com/~kkatoh/program/novel2/novel208.html)
素人ですが考えてみました。
このプログラムが正確に動くかどうかは分かりません。
B型単純式についてはよくわからなかったので何もしていません。
24 修正

退会済みユーザー

退会済みユーザー

2017/07/17 03:06  投稿

```C#
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text.RegularExpressions;
class Program
{
   static Object Split_Nums(string str)
   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)
       {
           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 "Invalid expression";
           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 "Invalid number";
           }
       }
       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);
       if (nums is String) return (string)nums;
       var result = Check((List<string>)nums);
       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】【アルゴリズム】逆ポーランド記法](http://sekai.hateblo.jp/entry/2013/09/15/185314)
[逆ポーランド記法による計算式を計算する電卓](http://calc.exinfo.biz/)
[逆ポーランド記法変換ツール](http://tamanegi-core.net/memo/article/polish_notation_converter)
[rubyについて質問です。](https://teratail.com/questions/80654)のkatoy様の回答
[逆ポーランド記法への変換2](http://www.gg.e-mansion.com/~kkatoh/program/novel2/novel208.html)
素人ですが考えてみました。
このプログラムが正確に動くかどうかは分かりません。
B型単純式についてはよくわからなかったので何もしていません。
23 修正

退会済みユーザー

退会済みユーザー

2017/07/17 02:56  投稿

```C#
using System;
using System.Collections.Generic;
using System.Text.RegularExpressions;   
using System.Linq;
namespace calc_porland
using System.Text.RegularExpressions;
class Program
{
  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();
      }
  }
   static Object 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)
       {
           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 "Invalid expression";
           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 "Invalid number";
           }
       }
       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);
       if (nums is String) return (string)nums;
       var result = Check((List<string>)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】【アルゴリズム】逆ポーランド記法](http://sekai.hateblo.jp/entry/2013/09/15/185314)
[逆ポーランド記法による計算式を計算する電卓](http://calc.exinfo.biz/)
[逆ポーランド記法変換ツール](http://tamanegi-core.net/memo/article/polish_notation_converter)
[rubyについて質問です。](https://teratail.com/questions/80654)のkatoy様の回答
[逆ポーランド記法への変換2](http://www.gg.e-mansion.com/~kkatoh/program/novel2/novel208.html)
素人ですが考えてみました。
このプログラムが正確に動くかどうかは分かりません。
B型単純式についてはよくわからなかったので何もしていません。
22 テスト3

退会済みユーザー

退会済みユーザー

2017/07/11 21:48  投稿

```C#
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】【アルゴリズム】逆ポーランド記法](http://sekai.hateblo.jp/entry/2013/09/15/185314)
[逆ポーランド記法による計算式を計算する電卓](http://calc.exinfo.biz/)
[逆ポーランド記法変換ツール](http://tamanegi-core.net/memo/article/polish_notation_converter)
[rubyについて質問です。](https://teratail.com/questions/80654)のkatoy様の回答
[逆ポーランド記法への変換2](http://www.gg.e-mansion.com/~kkatoh/program/novel2/novel208.html)
素人ですが考えてみました。
このプログラムが正確に動くかどうかは分かりません。
B型単純式についてはよくわからなかったので何もしていません。
21 テスト2

退会済みユーザー

退会済みユーザー

2017/07/11 21:47  投稿

```C#
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】【アルゴリズム】逆ポーランド記法](http://sekai.hateblo.jp/entry/2013/09/15/185314)
[逆ポーランド記法による計算式を計算する電卓](http://calc.exinfo.biz/)
[逆ポーランド記法変換ツール](http://tamanegi-core.net/memo/article/polish_notation_converter)
[rubyについて質問です。](https://teratail.com/questions/80654)のkatoy様の回答
[逆ポーランド記法への変換2](http://www.gg.e-mansion.com/~kkatoh/program/novel2/novel208.html)
素人ですが考えてみました。
このプログラムが正確に動くかどうかは分かりません。
B型単純式についてはよくわからなかったので何もしていません。
20 テスト

退会済みユーザー

退会済みユーザー

2017/07/11 21:45  投稿

```C#
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】【アルゴリズム】逆ポーランド記法](http://sekai.hateblo.jp/entry/2013/09/15/185314)
[逆ポーランド記法による計算式を計算する電卓](http://calc.exinfo.biz/)
[逆ポーランド記法変換ツール](http://tamanegi-core.net/memo/article/polish_notation_converter)
[rubyについて質問です。](https://teratail.com/questions/80654)のkatoy様の回答
[逆ポーランド記法への変換2](http://www.gg.e-mansion.com/~kkatoh/program/novel2/novel208.html)
素人ですが考えてみました。
このプログラムが正確に動くかどうかは分かりません。
B型単純式についてはよくわからなかったので何もしていません。
19 修正

退会済みユーザー

退会済みユーザー

2017/07/07 21:14  投稿

```C#
using System;
using System.Collections.Generic;
using System.Text.RegularExpressions; 
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); 
         
  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();
      }
  }
           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 ("*/%".Contains(stack.Last()))
                       {
                           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<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);
           Console.WriteLine(string.Join(", ", translate((List<string>)result)));
           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 = "88%494*993%614*507";
           Console.WriteLine(porland(input));
           Console.ReadKey();
       }
   }
}
```
参考にしたサイト
[【Ruby】【アルゴリズム】逆ポーランド記法](http://sekai.hateblo.jp/entry/2013/09/15/185314)
[逆ポーランド記法による計算式を計算する電卓](http://calc.exinfo.biz/)
[逆ポーランド記法変換ツール](http://tamanegi-core.net/memo/article/polish_notation_converter)
[rubyについて質問です。](https://teratail.com/questions/80654)のkatoy様の回答
[逆ポーランド記法への変換2](http://www.gg.e-mansion.com/~kkatoh/program/novel2/novel208.html)
素人ですが考えてみました。
このプログラムが正確に動くかどうかは分かりません。
B型単純式についてはよくわからなかったので何もしていません。
18 修正

退会済みユーザー

退会済みユーザー

2017/07/06 09:18  投稿

```C#
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()))
                          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】【アルゴリズム】逆ポーランド記法](http://sekai.hateblo.jp/entry/2013/09/15/185314)
[逆ポーランド記法による計算式を計算する電卓](http://calc.exinfo.biz/)
[逆ポーランド記法変換ツール](http://tamanegi-core.net/memo/article/polish_notation_converter)
[rubyについて質問です。](https://teratail.com/questions/80654)のkatoy様の回答
[逆ポーランド記法への変換2](http://www.gg.e-mansion.com/~kkatoh/program/novel2/novel208.html)
素人ですが考えてみました。
このプログラムが正確に動くかどうかは分かりません。
B型単純式についてはよくわからなかったので何もしていません。
17 修正

退会済みユーザー

退会済みユーザー

2017/07/06 09:15  投稿

```C#
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()))
                          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】【アルゴリズム】逆ポーランド記法](http://sekai.hateblo.jp/entry/2013/09/15/185314)
[逆ポーランド記法による計算式を計算する電卓](http://calc.exinfo.biz/)
[逆ポーランド記法変換ツール](http://tamanegi-core.net/memo/article/polish_notation_converter)
[rubyについて質問です。](https://teratail.com/questions/80654)のkatoy様の回答
[逆ポーランド記法への変換2](http://www.gg.e-mansion.com/~kkatoh/program/novel2/novel208.html)
素人ですが考えてみました。
このプログラムが正確に動くかどうかは分かりません。
B型単純式についてはよくわからなかったので何もしていません。
16 修正

退会済みユーザー

退会済みユーザー

2017/06/29 12:07  投稿

```C#
using System;
using System.Collections.Generic;
using System.Text.RegularExpressions; 
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); 
         
  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();
      }
  }
           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】【アルゴリズム】逆ポーランド記法](http://sekai.hateblo.jp/entry/2013/09/15/185314)
[逆ポーランド記法による計算式を計算する電卓](http://calc.exinfo.biz/)
[逆ポーランド記法変換ツール](http://tamanegi-core.net/memo/article/polish_notation_converter)
[rubyについて質問です。](https://teratail.com/questions/80654)のkatoy様の回答
[逆ポーランド記法への変換2](http://www.gg.e-mansion.com/~kkatoh/program/novel2/novel208.html)
素人ですが考えてみました。
このプログラムが正確に動くかどうかは分かりません。
B型単純式についてはよくわからなかったので何もしていません。
15 修正

退会済みユーザー

退会済みユーザー

2017/06/29 12:05  投稿

```C#
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】【アルゴリズム】逆ポーランド記法](http://sekai.hateblo.jp/entry/2013/09/15/185314)
[逆ポーランド記法による計算式を計算する電卓](http://calc.exinfo.biz/)
[逆ポーランド記法変換ツール](http://tamanegi-core.net/memo/article/polish_notation_converter)
[rubyについて質問です。](https://teratail.com/questions/80654)のkatoy様の回答
[逆ポーランド記法への変換2](http://www.gg.e-mansion.com/~kkatoh/program/novel2/novel208.html)
素人ですが考えてみました。
このプログラムが正確に動くかどうかは分かりません。
B型単純式についてはよくわからなかったので何もしていません。
14 変更が反映されない?

退会済みユーザー

退会済みユーザー

2017/06/29 06:32  投稿

```C#
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 = Console.ReadLine();
           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】【アルゴリズム】逆ポーランド記法](http://sekai.hateblo.jp/entry/2013/09/15/185314)
[逆ポーランド記法による計算式を計算する電卓](http://calc.exinfo.biz/)
[逆ポーランド記法変換ツール](http://tamanegi-core.net/memo/article/polish_notation_converter)
[rubyについて質問です。](https://teratail.com/questions/80654)のkatoy様の回答
[逆ポーランド記法への変換2](http://www.gg.e-mansion.com/~kkatoh/program/novel2/novel208.html)
素人ですが考えてみました。
このプログラムが正確に動くかどうかは分かりません。
B型単純式についてはよくわからなかったので何もしていません。
13 修正

退会済みユーザー

退会済みユーザー

2017/06/29 06:28  投稿

```C#
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 = Console.ReadLine();
           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】【アルゴリズム】逆ポーランド記法](http://sekai.hateblo.jp/entry/2013/09/15/185314)
[逆ポーランド記法による計算式を計算する電卓](http://calc.exinfo.biz/)
[逆ポーランド記法変換ツール](http://tamanegi-core.net/memo/article/polish_notation_converter)
[rubyについて質問です。](https://teratail.com/questions/80654)のkatoy様の回答
[逆ポーランド記法への変換2](http://www.gg.e-mansion.com/~kkatoh/program/novel2/novel208.html)
素人ですが考えてみました。
このプログラムが正確に動くかどうかは分かりません。
B型単純式についてはよくわからなかったので何もしていません。
12 修正

退会済みユーザー

退会済みユーザー

2017/06/29 06:26  投稿

```C#
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 = Console.ReadLine();
           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】【アルゴリズム】逆ポーランド記法](http://sekai.hateblo.jp/entry/2013/09/15/185314)
[逆ポーランド記法による計算式を計算する電卓](http://calc.exinfo.biz/)
[逆ポーランド記法変換ツール](http://tamanegi-core.net/memo/article/polish_notation_converter)
[rubyについて質問です。](https://teratail.com/questions/80654)のkatoy様の回答
[逆ポーランド記法への変換2](http://www.gg.e-mansion.com/~kkatoh/program/novel2/novel208.html)
素人ですが考えてみました。
このプログラムが正確に動くかどうかは分かりません。
B型単純式についてはよくわからなかったので何もしていません。
11 修正

退会済みユーザー

退会済みユーザー

2017/06/29 01:57  投稿

```C#
using System;
using System.Collections.Generic;
using System.Linq;
namespace calc_porland
{
   class Program
   {
       //式分解
       static List<string> split_nums(string str)
       {
           str = str.Replace(" ", "");
           str = str.Replace("**", "^");
           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));
                   }
               }
           }
           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
               {
                   double d = 0;
                   if(double.TryParse(list[i], out d)) for_calc.Add(list[i]);
                   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)}]";
           string input = Console.ReadLine();
           Console.WriteLine(porland(input));
           Console.ReadKey();
       }
   }
}
```
参考にしたサイト
[【Ruby】【アルゴリズム】逆ポーランド記法](http://sekai.hateblo.jp/entry/2013/09/15/185314)
[逆ポーランド記法による計算式を計算する電卓](http://calc.exinfo.biz/)
[逆ポーランド記法変換ツール](http://tamanegi-core.net/memo/article/polish_notation_converter)
[rubyについて質問です。](https://teratail.com/questions/80654)のkatoy様の回答
[逆ポーランド記法への変換2](http://www.gg.e-mansion.com/~kkatoh/program/novel2/novel208.html)
素人ですが考えてみました。
このプログラムが正確に動くかどうかは分かりません。
B型単純式についてはよくわからなかったので何もしていません。
10 修正

退会済みユーザー

退会済みユーザー

2017/06/29 01:46  投稿

```C#
using System;
using System.Collections.Generic;
using System.Linq;
namespace calc_porland
{
   class Program
   {
       //式分解
       static List<string> split_nums(string str)
       {
           str = str.Replace(" ", "");
           str = str.Replace("**", "^");
           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));
                   }
               }
           }
           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 (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
               {
                   double d = 0;
                   if(double.TryParse(list[i], out d)) 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)}]";
           Console.WriteLine(porland(input));
           Console.ReadKey();
       }
   }
}
```
参考にしたサイト
[【Ruby】【アルゴリズム】逆ポーランド記法](http://sekai.hateblo.jp/entry/2013/09/15/185314)
[逆ポーランド記法による計算式を計算する電卓](http://calc.exinfo.biz/)
[逆ポーランド記法変換ツール](http://tamanegi-core.net/memo/article/polish_notation_converter)
[rubyについて質問です。](https://teratail.com/questions/80654)のkatoy様の回答
[逆ポーランド記法への変換2](http://www.gg.e-mansion.com/~kkatoh/program/novel2/novel208.html)
素人ですが考えてみました。
このプログラムが正確に動くかどうかは分かりません。
B型単純式についてはよくわからなかったので何もしていません。
9 修正

退会済みユーザー

退会済みユーザー

2017/06/29 01:44  投稿

```C#
using System;
using System.Collections.Generic;
using System.Linq;
namespace calc_porland
{
   class Program
   {
       //式分解
       static List<string> split_nums(string str)
       {
           str = str.Replace(" ", "");
           str = str.Replace("**", "^");
           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));
                   }
               }
           }
           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
               {
                   double d = 0;
                   if(double.TryParse(list[i], out d)) 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)}]";
           Console.WriteLine(porland(input));
           Console.ReadKey();
       }
   }
}
```
参考にしたサイト
[【Ruby】【アルゴリズム】逆ポーランド記法](http://sekai.hateblo.jp/entry/2013/09/15/185314)  
[逆ポーランド記法による計算式を計算する電卓](http://calc.exinfo.biz/)  
[逆ポーランド記法変換ツール](http://tamanegi-core.net/memo/article/polish_notation_converter)  
[rubyについて質問です。](https://teratail.com/questions/80654)のkatoy様の回答  
[逆ポーランド記法への変換2](http://www.gg.e-mansion.com/~kkatoh/program/novel2/novel208.html)
[逆ポーランド記法変換ツール](http://tamanegi-core.net/memo/article/polish_notation_converter)  
[【Ruby】【アルゴリズム】逆ポーランド記法](http://sekai.hateblo.jp/entry/2013/09/15/185314)  
[rubyについて質問です。](https://teratail.com/questions/80654)のkatoy様の回答  
素人ですが考えてみました。
このプログラムが正確に動くかどうかは分かりません。
B型単純式についてはよくわからなかったので何もしていません。
8 修正

退会済みユーザー

退会済みユーザー

2017/06/29 01:38  投稿

```C#
using System;
using System.Collections.Generic;
using System.Linq;
namespace calc_porland
{
   class Program
   {
       //式分解
       static List<string> split_nums(string str)
       {
           str = str.Replace(" ", "");
           str = str.Replace("**", "^");
           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));
                   }
               }
           }
           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
               {
                   double d = 0;
                   if(double.TryParse(list[i], out d)) 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)}]";
           Console.WriteLine(porland(input));
           Console.ReadKey();
       }
   }
}
```
参考にしたサイト
[逆ポーランド記法への変換2](http://www.gg.e-mansion.com/~kkatoh/program/novel2/novel208.html)
[逆ポーランド記法変換ツール](http://tamanegi-core.net/memo/article/polish_notation_converter)
[【Ruby】【アルゴリズム】逆ポーランド記法](http://sekai.hateblo.jp/entry/2013/09/15/185314)
[rubyについて質問です。](https://teratail.com/questions/80654)のkatoy様の回答
素人ですが考えてみました。
このプログラムが正確に動くかどうかは分かりません。
B型単純式についてはよくわからなかったので何もしていません。
7 修正

退会済みユーザー

退会済みユーザー

2017/06/29 01:35  投稿

```C#
using System;
using System.Collections.Generic;
using System.Linq;
namespace calc_porland
{
   class Program
   {
       //式分解
       static List<string> split_nums(string str)
       {
           str = str.Replace(" ", "");
           str = str.Replace("**", "^");
           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)
               {
                   for_translate.Add(string.Join("", tmp));
                   if(tmp.Count > 0)
                   {
                       for_translate.Add(string.Join("", tmp));
                   }
               }
           }
           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;
                   }
                   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))
                       {
                           //Do Nothing!
                           nums++;
                       }
                       else
                       {
                           valid_number = false;
                       }
                   }
                   else if(("+-*/%^".Contains(e)))  
                   {  
                       symbol++;  
                   }  
               }  
 
               if (nums <= symbol)  
               {  
                   return "式が不正です";  
               }
               if(valid_number)
               {
                   for (int i = 0; i < list.Count - 1; i++)
                   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
               {
                   double d = 0;
                   if(double.TryParse(list[i], out d)) for_calc.Add(list[i]);
               }
               if(i == list.Count - 1)
               {
                   if (stack.Count > 0)
                   {
                       while (stack[0] != "(")
                       {
                           if(stack.Last() != "") for_calc.Add(stack.Last());
                           stack.RemoveAt(stack.Count - 1);
                           if (stack.Count < 1) break;
                       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)}]";
           Console.WriteLine(porland(input));
           Console.ReadKey();
       }
   }
}
```
参考にしたサイト
[逆ポーランド記法への変換2](http://www.gg.e-mansion.com/~kkatoh/program/novel2/novel208.html)
[逆ポーランド記法変換ツール](http://tamanegi-core.net/memo/article/polish_notation_converter)
[【Ruby】【アルゴリズム】逆ポーランド記法](http://sekai.hateblo.jp/entry/2013/09/15/185314)
[rubyについて質問です。](https://teratail.com/questions/80654)のkatoy様の回答
素人ですが考えてみました。
このプログラムが正確に動くかどうかは分かりません。
B型単純式についてはよくわからなかったので何もしていません。
6 修正

退会済みユーザー

退会済みユーザー

2017/06/29 00:58  投稿

```C#
using System;
using System.Collections.Generic;
using System.Linq;
namespace calc_porland
{
   class Program
   {
       //式分解
       static List<string> split_nums(string str)
       {
           str = str.Replace(" ", "");
           str = str.Replace("**", "^");
           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)
               {
                   for_translate.Add(string.Join("", tmp));
               }
           }
           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;
                   }
                   nest.RemoveAt(nest.Count - 1);
               }
           }
           if(valid_nest)
           {
               bool valid_number = true;
               foreach(string e in list)
               {
                   if ("+-*/%^()[]{}".Contains(e) == false)
                   {
                       double d = 0;
                       if (double.TryParse(e, out d))
                       {
                           //Do Nothing!
                       }
                       else
                       {
                           valid_number = false;
                       }
                   }
               }
               if(valid_number)
               {
                   for (int i = 0; i < list.Count - 1; 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
               {
                   double d = 0;
                   if(double.TryParse(list[i], out d)) for_calc.Add(list[i]);
               }
               if(i == list.Count - 1)
               {
                   if (stack.Count > 0)
                   {
                       while (stack[0] != "(")
                       {
                           if(stack.Last() != "") for_calc.Add(stack.Last());
                           stack.RemoveAt(stack.Count - 1);
                           if (stack.Count < 1) break;
                       }
                   }
               }
           }
           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)}]";
           Console.WriteLine(porland(input));
           Console.ReadKey();
       }
   }
}
```
参考にしたサイト
[逆ポーランド記法への変換2](http://www.gg.e-mansion.com/~kkatoh/program/novel2/novel208.html)  
[逆ポーランド記法変換ツール](http://tamanegi-core.net/memo/article/polish_notation_converter)  
[【Ruby】【アルゴリズム】逆ポーランド記法](http://sekai.hateblo.jp/entry/2013/09/15/185314)
[rubyについて質問です。](https://teratail.com/questions/80654)のkatoy様の回答
[逆ポーランド記法への変換2](http://www.gg.e-mansion.com/~kkatoh/program/novel2/novel208.html)
素人ですが考えてみました。
このプログラムが正確に動くかどうかは分かりません。
B型単純式についてはよくわからなかったので何もしていません。
5 修正

退会済みユーザー

退会済みユーザー

2017/06/29 00:57  投稿

```C#
using System;
using System.Collections.Generic;
using System.Linq;
namespace calc_porland
{
   class Program
   {
       //式分解
       static List<string> split_nums(string str)
       {
           str = str.Replace(" ", "");
           str = str.Replace("**", "^");
           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)
               {
                   for_translate.Add(string.Join("", tmp));
               }
           }
           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;
                   }
                   nest.RemoveAt(nest.Count - 1);
               }
           }
           if(valid_nest)
           {
               bool valid_number = true;
               foreach(string e in list)
               {
                   if ("+-*/%^()[]{}".Contains(e) == false)
                   {
                       double d = 0;
                       if (double.TryParse(e, out d))
                       {
                           //Do Nothing!
                       }
                       else
                       {
                           valid_number = false;
                       }
                   }
               }
               if(valid_number)
               {
                   for (int i = 0; i < list.Count - 1; 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
               {
                   double d = 0;
                   if(double.TryParse(list[i], out d)) for_calc.Add(list[i]);
               }
               if(i == list.Count - 1)
               {
                   if (stack.Count > 0)
                   {
                       while (stack[0] != "(")
                       {
                           if(stack.Last() != "") for_calc.Add(stack.Last());
                           stack.RemoveAt(stack.Count - 1);
                           if (stack.Count < 1) break;
                       }
                   }
               }
           }
           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)}]";
           Console.WriteLine(porland(input));
           Console.ReadKey();
       }
   }
}
```
参考にしたサイト
[【Ruby】【アルゴリズム】逆ポーランド記法](http://sekai.hateblo.jp/entry/2013/09/15/185314)
[rubyについて質問です。](https://teratail.com/questions/80654)のkatoy様の回答
[逆ポーランド記法への変換2](http://www.gg.e-mansion.com/~kkatoh/program/novel2/novel208.html)  
素人ですが考えてみました。
このプログラムが正確に動くかどうかは分かりません。
B型単純式についてはよくわからなかったので何もしていません。
4 修正

退会済みユーザー

退会済みユーザー

2017/06/29 00:53  投稿

```C#
using System;
using System.Collections.Generic;
using System.Linq;
namespace calc_porland
{
   class Program
   {
       //式分解
       static List<string> split_nums(string str)
       {
           str = str.Replace(" ", "");
           str = str.Replace("**", "^");
           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)
               {
                   for_translate.Add(string.Join("", tmp));
               }
           }
           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;
                   }
                   nest.RemoveAt(nest.Count - 1);
               }
           }
           if(valid_nest)
           {
               bool valid_number = true;
               foreach(string e in list)
               {
                   if ("+-*/%^()[]{}".Contains(e) == false)
                   {
                       double d = 0;
                       if (double.TryParse(e, out d))
                       {
                           //Do Nothing!
                       }
                       else
                       {
                           valid_number = false;
                       }
                   }
               }
               if(valid_number)
               {
                   for (int i = 0; i < list.Count - 1; 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
               {
                   double d = 0;
                   if(double.TryParse(list[i], out d)) for_calc.Add(list[i]);
               }
               if(i == list.Count - 1)
               {
                   if (stack.Count > 0)
                   {
                       while (stack[0] != "(")
                       {
                           if(stack.Last() != "") for_calc.Add(stack.Last());
                           stack.RemoveAt(stack.Count - 1);
                           if (stack.Count < 1) break;
                       }
                   }
               }
           }
           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)}]";
           Console.WriteLine(porland(input));
           Console.ReadKey();
       }
   }
}
```
参考にしたサイト
[【Ruby】【アルゴリズム】逆ポーランド記法](http://sekai.hateblo.jp/entry/2013/09/15/185314)
[rubyについて質問です。](https://teratail.com/questions/80654)のkatoy様の回答  
素人ですが考えてみました。
このプログラムが正確に動くかどうかは分かりません。
B型単純式についてはよくわからなかったので何もしていません。
3 修正

退会済みユーザー

退会済みユーザー

2017/06/29 00:51  投稿

```C#
using System;
using System.Collections.Generic;
using System.Linq;
namespace polandtest1
namespace calc_porland
{
   class Program
   {
       static void Main(string[] args)
       {
           Console.Write("式を入力してください:");
           string input = Console.ReadLine() ;
           List<string> strs = input.Split(' ').ToList();
       //式分解
       static List<string> split_nums(string str)
       {
           str = str.Replace(" ", "");
           str = str.Replace("**", "^");
           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)
               {
                   for_translate.Add(string.Join("", tmp));
               }
           }
           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;
                   }
                   nest.RemoveAt(nest.Count - 1);
               }
           }
           if(valid_nest)
           {
               bool valid_number = true;
               foreach(string e in list)
               {
                   if ("+-*/%^()[]{}".Contains(e) == false)
                   {
                       double d = 0;
                       if (double.TryParse(e, out d))
                       {
                           //Do Nothing!
                       }
                       else
                       {
                           valid_number = false;
                       }
                   }
               }
               if(valid_number)
               {
                   for (int i = 0; i < list.Count - 1; 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
               {
                   double d = 0;
                   if(double.TryParse(list[i], out d)) for_calc.Add(list[i]);
               }
               if(i == list.Count - 1)
               {
                   if (stack.Count > 0)
                   {
                       while (stack[0] != "(")
                       {
                           if(stack.Last() != "") for_calc.Add(stack.Last());
                           stack.RemoveAt(stack.Count - 1);
                           if (stack.Count < 1) break;
                       }
                   }
               }
           }
           return for_calc;
       }
       //逆ポーランド記法を解く
       static double calc_porland(List<string> list)
       {
           List<double> stack = new List<double>();
           foreach(string e in strs)
           {
               double i;
               if(double.TryParse(e, out i))
               {
                   stack.Add(i);
               }
               else
               {
                   double acue = 0;
           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);
               }
           }
           foreach(double s in stack)
           {
               Console.WriteLine(s.ToString());
           }
           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)}]";
           Console.WriteLine(porland(input));
           Console.ReadKey();
       }
   }
}
```
入力値  
```  
1 2 + 3 4 + * 5 6 + 7 8 + * + 9 10 + 11 12 + * 13 14 + 15 16 + * + *  
```  
出力  
```  
236964  
```  
回答のチェックに使ったサイト  
[逆ポーランド記法変換ツール](http://tamanegi-core.net/memo/article/polish_notation_converter#introduction)  
[逆ポーランド記法による計算式を計算する電卓](http://calc.exinfo.biz/)  
 
入力値  
```  
1,2+3,4+*5,6+7,8+*+9,10+11,12+*13,14+15,16+*+*  
```  
出力  
```  
236964  
```  
 
参考にしたサイト
[【Ruby】【アルゴリズム】逆ポーランド記法](http://sekai.hateblo.jp/entry/2013/09/15/185314)
素人ですが考えてみました。
このプログラムが正確に動くかどうかは分かりません。
B型単純式についてはよくわからなかったので何もしていません。
B型単純式についてはよくわからなかったので何もしていません。
2 修正

退会済みユーザー

退会済みユーザー

2017/05/29 22:33  投稿

```C#
using System;
using System.Collections.Generic;
using System.Linq;
namespace polandtest1
{
   class Program
   {
       static void Main(string[] args)
       {
           Console.Write("式を入力してください:");
           string input = Console.ReadLine() ;
           List<string> strs = input.Split(' ').ToList();
           List<double> stack = new List<double>();
           foreach(string e in strs)
           {
               double i;
               if(double.TryParse(e, out i))
               {
                   stack.Add(i);
               }
               else
               {
                   double acue = 0;
                   double a = stack.Last(); stack.RemoveAt(stack.Count - 1);
                   double b = stack.Last(); stack.RemoveAt(stack.Count - 1);
                   switch (e)
                   {
                       case "+":
                           acue = b + a;
                           break;
                       case "-":
                           acue = b - a;
                           break;
                       case "*":
                           acue = b * a;
                           break;
                       case "/":
                           acue = b / a;
                           break;
                   }
                   stack.Add(acue);
               }
           }
           foreach(double s in stack)
           {
               Console.WriteLine(s.ToString());
           }
           Console.ReadKey();
       }
   }
}
```
入力値
```
1 2 + 3 4 + * 5 6 + 7 8 + * + 9 10 + 11 12 + * 13 14 + 15 16 + * + *
```
出力
```
236964
```
回答のチェックに使ったサイト
[逆ポーランド記法変換ツール](http://tamanegi-core.net/memo/article/polish_notation_converter#introduction)  
[逆ポーランド記法による計算式を計算する電卓](http://calc.exinfo.biz/)
入力値
```
1,2+3,4+*5,6+7,8+*+9,10+11,12+*13,14+15,16+*+*
```
出力
```
236964
```
参考にしたサイト
[【Ruby】【アルゴリズム】逆ポーランド記法](http://sekai.hateblo.jp/entry/2013/09/15/185314)
素人ですが考えてみました。
このプログラムが正確に動くかどうかは分かりません。
B型単純式についてはよくわからなかったので何もしていません。
1 修正

退会済みユーザー

退会済みユーザー

2017/05/29 22:26  投稿

```C#
using System;
using System.Collections.Generic;
using System.Linq;
namespace polandtest1
{
   class Program
   {
       static void Main(string[] args)
       {
           Console.Write("式を入力してください:");
           string input = Console.ReadLine() ;
           List<string> strs = input.Split(' ').ToList();
           List<double> stack = new List<double>();
           foreach(string e in strs)
           {
               double i;
               if(double.TryParse(e, out i))
               {
                   stack.Add(i);
               }
 
               else
               {
                   double acue = 0;
                   double a = stack.Last(); stack.RemoveAt(stack.Count - 1);
                   double b = stack.Last(); stack.RemoveAt(stack.Count - 1);
                   switch (e)
                   {
                       case "+":
                           acue = b + a;
                           break;
                       case "-":
                           acue = b - a;
                           break;
                       case "*":
                           acue = b * a;
                           break;
                       case "/":
                           acue = b / a;
                           break;
                   }
                   stack.Add(acue);
               }
           }
           foreach(double s in stack)
           {
               Console.WriteLine(s.ToString());
           }
           Console.ReadKey();
       }
   }
}
```
入力値
```
1 2 + 3 4 + * 5 6 + 7 8 + * + 9 10 + 11 12 + * 13 14 + 15 16 + * + *
```
出力
```
236964
```
回答のチェックに使ったサイト
[逆ポーランド記法による計算式を計算する電卓](http://calc.exinfo.biz/)
入力値
```
1,2+3,4+*5,6+7,8+*+9,10+11,12+*13,14+15,16+*+*
```
出力
```
236964
```
参考にしたサイト
[【Ruby】【アルゴリズム】逆ポーランド記法](http://sekai.hateblo.jp/entry/2013/09/15/185314)
素人ですが考えてみました。
このプログラムが正確に動くかどうかは分かりません。
B型単純式についてはよくわからなかったので何もしていません。

思考するエンジニアのためのQ&Aサイト「teratail」について詳しく知る