fork download
copy 
  1. using System;
  2. class Program
  3. {
  4.   static void Main(string[] args)
  5.   {
  6.     string[] data = new string[] {
  7.       "a",
  8.       "1",
  9.       "0",
  10.       "01",
  11.       "-5",
  12.       "1.2",
  13.       "1.2.3",
  14.       "12-3",
  15.       "1a",
  16.       "+1",
  17.       "-0.123",
  18.       "1.2e2",
  19.       "1.2E2",
  20.       "1.2e",
  21.       "1.2e+3",
  22.       "1.2e-3",
  23.       "1.2e-3.5",
  24.       ".5",
  25.       ".5e2",
  26.       "5.e2",
  27.     };
  28.  
  29.     Checker ic = new IntChecker();
  30.     Checker fc = new FloatChecker();
  31.     foreach (string str in data)
  32.     {
  33.       ic.Reset();
  34.       fc.Reset();
  35.       Console.Write(str + " : ");
  36.       foreach (char ch in str)
  37.       {
  38.         if (ic.IsError() && fc.IsError())
  39.         {
  40.           break;
  41.         }
  42.  
  43.         if (!ic.IsError())
  44.         {
  45.           ic.Next(ch);
  46.         }
  47.         if (!fc.IsError())
  48.         {
  49.           fc.Next(ch);
  50.         }
  51.       }
  52.  
  53.       if (ic.IsAcceptable())
  54.       {
  55.         Console.WriteLine("int({0})", int.Parse(str));
  56.       }
  57.       else if (fc.IsAcceptable())
  58.       {
  59.         Console.WriteLine("double({0})", double.Parse(str));
  60.       }
  61.       else
  62.       {
  63.         Console.WriteLine("string({0})", str);
  64.       }
  65.     }
  66.     Console.WriteLine("int.Parse(\"01\") -> {0}", int.Parse("01"));
  67.     Console.WriteLine("double.Parse(\"01\") -> {0}", double.Parse("01"));
  68.   }
  69. }
  70.  
  71. interface Checker
  72. {
  73.   void Reset();
  74.   void Next(char ch);
  75.   bool IsAcceptable();
  76.   bool IsError();
  77. }
  78.  
  79. class IntChecker : Checker
  80. {
  81.   enum IntParsingState
  82.   {
  83.     State0,
  84.     State1,
  85.     State2,
  86.     State3,
  87.   }
  88.  
  89.   IntParsingState _state;
  90.  
  91.   public IntChecker()
  92.   {
  93.     Reset();
  94.   }
  95.  
  96.   public void Reset()
  97.   {
  98.     _state = IntParsingState.State0;
  99.   }
  100.  
  101.   public void Next(char ch)
  102.   {
  103.     switch (_state)
  104.     {
  105.       case IntParsingState.State0:
  106.         if (ch == '-' ||
  107.           ch == '+')
  108.         {
  109.           _state = IntParsingState.State1;
  110.         }
  111.         else if (ch == '1' ||
  112.           ch == '2' ||
  113.           ch == '3' ||
  114.           ch == '4' ||
  115.           ch == '5' ||
  116.           ch == '6' ||
  117.           ch == '7' ||
  118.           ch == '8' ||
  119.           ch == '9')
  120.         {
  121.           _state = IntParsingState.State2;
  122.         }
  123.         else
  124.         {
  125.           _state = IntParsingState.State3;
  126.         }
  127.         break;
  128.       case IntParsingState.State1:
  129.         if (ch == '1' ||
  130.           ch == '2' ||
  131.           ch == '3' ||
  132.           ch == '4' ||
  133.           ch == '5' ||
  134.           ch == '6' ||
  135.           ch == '7' ||
  136.           ch == '8' ||
  137.           ch == '9')
  138.         {
  139.           _state = IntParsingState.State2;
  140.         }
  141.         else
  142.         {
  143.           _state = IntParsingState.State3;
  144.         }
  145.         break;
  146.       case IntParsingState.State2:
  147.         if (ch == '0' ||
  148.           ch == '1' ||
  149.           ch == '2' ||
  150.           ch == '3' ||
  151.           ch == '4' ||
  152.           ch == '5' ||
  153.           ch == '6' ||
  154.           ch == '7' ||
  155.           ch == '8' ||
  156.           ch == '9')
  157.         {
  158.           _state = IntParsingState.State2;
  159.         }
  160.         else
  161.         {
  162.           _state = IntParsingState.State3;
  163.         }
  164.         break;
  165.       case IntParsingState.State3:
  166.         _state = IntParsingState.State3;
  167.         break;
  168.     }
  169.   }
  170.  
  171.   public bool IsAcceptable()
  172.   {
  173.     return _state == IntParsingState.State2;
  174.   }
  175.  
  176.   public bool IsError()
  177.   {
  178.     return _state == IntParsingState.State3;
  179.   }
  180. }
  181.  
  182. class FloatChecker : Checker
  183. {
  184.   enum FloatParsingState
  185.   {
  186.     Error,
  187.     State00,
  188.     State01,
  189.     State02,
  190.     State03,
  191.     State04,
  192.     State05,
  193.     State06,
  194.     State07,
  195.     State08,
  196.     State09,
  197.     State10,
  198.     State11,
  199.   }
  200.  
  201.   FloatParsingState _state;
  202.  
  203.   public FloatChecker()
  204.   {
  205.     Reset();
  206.   }
  207.  
  208.   public void Reset()
  209.   {
  210.     _state = FloatParsingState.State00;
  211.   }
  212.  
  213.   void Transition(char ch, FloatParsingState whenX, FloatParsingState whenY, FloatParsingState whenZ, FloatParsingState whenDot)
  214.   {
  215.     if (ch == '-' || ch == '+')
  216.     {
  217.       _state = whenX;
  218.     }
  219.     else if (char.IsDigit(ch))
  220.     {
  221.       _state = whenY;
  222.     }
  223.     else if (ch == 'e' || ch == 'E')
  224.     {
  225.       _state = whenZ;
  226.     }
  227.     else if (ch == '.')
  228.     {
  229.       _state = whenDot;
  230.     }
  231.     else
  232.     {
  233.       _state = FloatParsingState.Error;
  234.     }
  235.   }
  236.  
  237.   public void Next(char ch)
  238.   {
  239.     switch (_state)
  240.     {
  241.       case FloatParsingState.State00:
  242.         Transition(
  243.           ch,
  244.           FloatParsingState.State01,
  245.           FloatParsingState.State02,
  246.           FloatParsingState.Error,
  247.           FloatParsingState.State03);
  248.         break;
  249.       case FloatParsingState.State01:
  250.         Transition(
  251.           ch,
  252.           FloatParsingState.Error,
  253.           FloatParsingState.State02,
  254.           FloatParsingState.Error,
  255.           FloatParsingState.State03);
  256.         break;
  257.       case FloatParsingState.State02:
  258.         Transition(
  259.           ch,
  260.           FloatParsingState.Error,
  261.           FloatParsingState.State02,
  262.           FloatParsingState.State04,
  263.           FloatParsingState.State05);
  264.         break;
  265.       case FloatParsingState.State03:
  266.         Transition(
  267.           ch,
  268.           FloatParsingState.Error,
  269.           FloatParsingState.State06,
  270.           FloatParsingState.Error,
  271.           FloatParsingState.Error);
  272.         break;
  273.       case FloatParsingState.State04:
  274.         Transition(
  275.           ch,
  276.           FloatParsingState.State07,
  277.           FloatParsingState.State08,
  278.           FloatParsingState.State08,
  279.           FloatParsingState.Error);
  280.         break;
  281.       case FloatParsingState.State05:
  282.         Transition(
  283.           ch,
  284.           FloatParsingState.Error,
  285.           FloatParsingState.State09,
  286.           FloatParsingState.State04,
  287.           FloatParsingState.Error);
  288.         break;
  289.       case FloatParsingState.State06:
  290.         Transition(
  291.           ch,
  292.           FloatParsingState.Error,
  293.           FloatParsingState.State10,
  294.           FloatParsingState.State04,
  295.           FloatParsingState.Error);
  296.         break;
  297.       case FloatParsingState.State07:
  298.         Transition(
  299.           ch,
  300.           FloatParsingState.Error,
  301.           FloatParsingState.State08,
  302.           FloatParsingState.Error,
  303.           FloatParsingState.Error);
  304.         break;
  305.       case FloatParsingState.State08:
  306.         Transition(
  307.           ch,
  308.           FloatParsingState.Error,
  309.           FloatParsingState.State11,
  310.           FloatParsingState.Error,
  311.           FloatParsingState.Error);
  312.         break;
  313.       case FloatParsingState.State09:
  314.         Transition(
  315.           ch,
  316.           FloatParsingState.Error,
  317.           FloatParsingState.State09,
  318.           FloatParsingState.State04,
  319.           FloatParsingState.Error);
  320.         break;
  321.       case FloatParsingState.State10:
  322.         Transition(
  323.           ch,
  324.           FloatParsingState.Error,
  325.           FloatParsingState.State10,
  326.           FloatParsingState.State04,
  327.           FloatParsingState.Error);
  328.         break;
  329.       case FloatParsingState.State11:
  330.         Transition(
  331.           ch,
  332.           FloatParsingState.Error,
  333.           FloatParsingState.State11,
  334.           FloatParsingState.Error,
  335.           FloatParsingState.Error);
  336.         break;
  337.     }
  338.   }
  339.  
  340.   public bool IsAcceptable()
  341.   {
  342.     return
  343.       _state == FloatParsingState.State02 ||
  344.       _state == FloatParsingState.State05 ||
  345.       _state == FloatParsingState.State06 ||
  346.       _state == FloatParsingState.State08 ||
  347.       _state == FloatParsingState.State09 ||
  348.       _state == FloatParsingState.State10 ||
  349.       _state == FloatParsingState.State11;
  350.   }
  351.  
  352.   public bool IsError()
  353.   {
  354.     return _state == FloatParsingState.Error;
  355.   }
  356. }
  357.  
Success #stdin #stdout 0.01s 131520KB
comments (?)
stdin
copy 
Standard input is empty
stdout
copy 
a : string(a)
1 : int(1)
0 : double(0)
01 : double(1)
-5 : int(-5)
1.2 : double(1.2)
1.2.3 : string(1.2.3)
12-3 : string(12-3)
1a : string(1a)
+1 : int(1)
-0.123 : double(-0.123)
1.2e2 : double(120)
1.2E2 : double(120)
1.2e : string(1.2e)
1.2e+3 : double(1200)
1.2e-3 : double(0.0012)
1.2e-3.5 : string(1.2e-3.5)
.5 : double(0.5)
.5e2 : double(50)
5.e2 : double(500)
int.Parse("01") -> 1
double.Parse("01") -> 1
https://ideone.com/hso9ex
language:
C# (gmcs 5.20.1)
created:
5 years ago
visibility:
secret

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!