Interpreter解释器_C#

-------------------------------------------------------------------------

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

//I、V、X、L、C、D、M
//相应的阿拉伯数字表示为：
//1、5、10、50、100、500、1000
//(1)相同的数字连写,所表示的数等于这些数字相加得到的数,如：Ⅲ = 3；
//(2)小的数字在大的数字的右边,所表示的数等于这些数字相加得到的数,如：Ⅷ = 8；Ⅻ = 12；
//(3)小的数字,（限于Ⅰ、X 和C）在大的数字的左边,所表示的数等于大数减小数得到的数,如：Ⅳ= 4；Ⅸ= 9；
//(4)正常使用时连写的数字重复不得超过三次.（表盘上的四点钟--“IIII”,例外.）
//(5)在一个数的上面画一条横线,表示这个数扩大1000 倍.
//罗马数字的组数规则
//(1)基本数字Ⅰ、X 、C 中的任何一个, 自身连用构成数目, 或者放在大数的右边连用构成数目, 都不能超过三个；放在大数的左边只能用一个.
//(2)不能把基本数字V 、L 、D 中的任何一个作为小数放在大数的左边采用相减的方法构成数目；放在大数的右边采用相加的方式构成数目,只能使用一个.
//(3)V 和X 左边的小数字只能用Ⅰ.
//(4)L 和C 左边的小数字只能用X.
//(5)D 和M 左边的小数字只能用C.
namespace InterpreterExample1
{
    public class InterpreterExample1 : MonoBehaviour
    {
        void Start()
        {
            string roman = "MCMXXVIII";
            Context context = new Context(roman);

            // 从左到右
            List<Expression> tree = new List<Expression>();
            tree.Add(new ThousandExpression());
            tree.Add(new HundredExpression());
            tree.Add(new TenExpression());
            tree.Add(new OneExpression());

            // Interpret
            foreach (Expression exp in tree)
            {
                exp.Interpret(context);
            }

            Debug.Log(roman+" = "+ context.Output);
        }
    }

    /// <summary>
    /// The 'Context' class
    /// </summary>
    class Context
    {
        private string _input;
        private int _output;

        // Constructor
        public Context(string input)
        {
            this._input = input;
        }

        // Gets or sets input
        public string Input
        {
            get { return _input; }
            set { _input = value; }
        }

        // Gets or sets output
        public int Output
        {
            get { return _output; }
            set { _output = value; }
        }
    }

    /// <summary>
    /// 解释器
    /// </summary>
    abstract class Expression
    {
        public void Interpret(Context context)
        {
            if (context.Input.Length == 0)
                return;

            if (context.Input.StartsWith(Nine()))
            {
                context.Output += (9 * Multiplier());
                context.Input = context.Input.Substring(2);//分割字符串
            }
            else if (context.Input.StartsWith(Four()))
            {
                context.Output += (4 * Multiplier());
                context.Input = context.Input.Substring(2);
            }
            else if (context.Input.StartsWith(Five()))
            {
                context.Output += (5 * Multiplier());
                context.Input = context.Input.Substring(1);
            }

            while (context.Input.StartsWith(One()))
            {
                context.Output += (1 * Multiplier());
                context.Input = context.Input.Substring(1);
            }
        }

        public abstract string One();
        public abstract string Four();
        public abstract string Five();
        public abstract string Nine();
        public abstract int Multiplier();
    }

   /// <summary>
   /// 千分位组合只有一个M
   /// </summary>
    class ThousandExpression : Expression
    {
        public override string One() { return "M"; }
        public override string Four() { return " "; }
        public override string Five() { return " "; }
        public override string Nine() { return " "; }
        public override int Multiplier() { return 1000; }
    }

/// <summary>
/// 百分位的组合有C CD D CM
/// </summary>
    class HundredExpression : Expression
    {
        public override string One() { return "C"; }//100
        public override string Four() { return "CD"; }//400
        public override string Five() { return "D"; }//500
        public override string Nine() { return "CM"; }//900
        public override int Multiplier() { return 100; }
    }

/// <summary>
/// 十分位的组合X XL L XC
/// </summary>
    class TenExpression : Expression
    {
        public override string One() { return "X"; }//10
        public override string Four() { return "XL"; }//40
        public override string Five() { return "L"; }//50
        public override string Nine() { return "XC"; }//90
        public override int Multiplier() { return 10; }
    }

/// <summary>
/// 个位 I IV V IX
/// </summary>
    class OneExpression : Expression
    {
        public override string One() { return "I"; }//1
        public override string Four() { return "IV"; }//4
        public override string Five() { return "V"; }//5
        public override string Nine() { return "IX"; }//9
        public override int Multiplier() { return 1; }
    }
}

将一个罗马数字转换成一个阿拉伯数字，其实也有点加密的意思在里面