回答編集履歴

6 修正

退会済みユーザー

退会済みユーザー

2017/07/11 21:59  投稿

teratailの運営様に編集結果が反映されない件についてお問い合わせを
行っており、その件で改めて編集が反映されないかどうかをテストさせていただいています。
```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】【アルゴリズム】逆ポーランド記法
逆ポーランド記法による計算式を計算する電卓
逆ポーランド記法変換ツール
rubyについて質問です。のkatoy様の回答
逆ポーランド記法への変換2
素人ですが考えてみました。
このプログラムが正確に動くかどうかは分かりません。
B型単純式についてはよくわからなかったので何もしていません。
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
5 修正

退会済みユーザー

退会済みユーザー

2017/07/11 21:57  投稿

teratailの運営様に編集結果が反映されない件についてお問い合わせを
行っており、その件で改めて編集が反映されないかどうかをテストさせていただいています。
```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】【アルゴリズム】逆ポーランド記法
逆ポーランド記法による計算式を計算する電卓
逆ポーランド記法変換ツール
rubyについて質問です。のkatoy様の回答
逆ポーランド記法への変換2
[【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型単純式についてはよくわからなかったので何もしていません。
4 テスト

退会済みユーザー

退会済みユーザー

2017/07/11 21:56  投稿

teratailの運営様に編集結果が反映されない件についてお問い合わせを
行っており、その件で改めて編集が反映されないかどうかをテストさせていただいています。
```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】【アルゴリズム】逆ポーランド記法
逆ポーランド記法による計算式を計算する電卓
逆ポーランド記法変換ツール
rubyについて質問です。のkatoy様の回答
逆ポーランド記法への変換2
素人ですが考えてみました。
このプログラムが正確に動くかどうかは分かりません。
B型単純式についてはよくわからなかったので何もしていません。
3 テスト

退会済みユーザー

退会済みユーザー

2017/07/11 21:55  投稿

teratailの運営様に編集結果が反映されない件についてお問い合わせを
行っており、その件で改めて編集が反映されないかどうかをテストさせていただいています。
```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型単純式についてはよくわからなかったので何もしていません。
```
2 テスト

退会済みユーザー

退会済みユーザー

2017/07/11 21:53  投稿

teratailの運営様に編集結果が反映されない件についてお問い合わせを
行っており、その件で改めて編集が反映されないかどうかをテストさせていただいています。
```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型単純式についてはよくわからなかったので何もしていません。
1 修正

退会済みユーザー

退会済みユーザー

2017/07/11 21:52  投稿

teratailの運営様に編集結果が反映されない件についてお問い合わせを
行っており、その件で改めて編集が反映されないかどうかをテストさせていただいています。
```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型単純式についてはよくわからなかったので何もしていません。

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