整數區間及區間集合（C#實現）

        /// <summary>
        /// 整數區間類
        /// </summary>
        private class Interval
        {
            private int _start = 0, _end = 0;
            public int Start
            {
                get { return Math.Min(this._start, this._end); }
                set { this._start = value; }
            }
            public int End
            {
                get { return Math.Max(this._start, this._end); }
                set { this._end = value; }
            }
            public bool Inside(int Value)
            {
                return (Start <= Value && Value <= End);
            }
            /// <summary>
            /// 區間求並運算，此方法不修改當前實例的值。
            /// 若不可合並則返回null，否則返回新的區間。
            /// </summary>
            /// <param name="OtherInterval">另一個區間</param>
            /// <returns>新的區間實例</returns>
            public Interval Merge(Interval OtherInterval)
            {
                if (this.Start - OtherInterval.End > 1 || OtherInterval.Start - this.End > 1)
                {
                    return null;
                }
                else
                {
                    return new Interval()
                    {
                        Start = Math.Min(this.Start, OtherInterval.Start),
                        End = Math.Max(this.End, OtherInterval.End)
                    };
                }
            }
        }
        /// <summary>
        /// 區間集合類
        /// </summary>
        private class IntervalCollection
        {
            public List<Interval> Intervals = new List<Interval>();
            /// <summary>
            /// 將一個區間並入區間集合中
            /// </summary>
            /// <param name="Start">開始位置</param>
            /// <param name="End">結束位置</param>
            public void Add(int Start, int End)
            {
                this.Add(new Interval() { Start = Start, End = End });
            }
            /// <summary>
            /// 將一個區間並入區間集合中
            /// </summary>
            /// <param name="NewInterval">需要並入的區間結構</param>
            public void Add(Interval NewInterval)
            {
                Interval MergeInterval = null;
                for (int i = 0; i < this.Intervals.Count; i++)
                {
                    MergeInterval = this.Intervals[i].Merge(NewInterval);
                    if (MergeInterval != null)
                    {
                        this.Intervals[i] = MergeInterval;
                        break;
                    }
                }
                if (MergeInterval == null)
                {
                    Intervals.Add(NewInterval);
                }
            }
            /// <summary>
            /// 檢測區間集中是否包含有指定值
            /// </summary>
            /// <param name="Value">需要查詢的數值</param>
            /// <returns>包含返回true，否則返回false</returns>
            public bool Inside(int Value)
            {
                foreach (Interval Inter in Intervals)
                {
                    if (Inter.Inside(Value) == true)
                    {
                        return true;
                    }
                }
                return false;
            }
            /// <summary>
            /// 將區間集的轉換為字符串
            /// </summary>
            /// <typeparam name="T">轉換類型</typeparam>
            /// <param name="CompleteSet">全集，當序列化后若長度過長則用以求取補集</param>
            /// <returns>返回轉換后的字符串</returns>
            public string ToString<T>(string CompleteSet = null)
            {
                StringBuilder Str = new StringBuilder("[");
                foreach (Interval Inter in Intervals)
                {
                    if (Inter.Start == Inter.End)
                    {
                        dynamic Vs = (object)Inter.Start;
                        Str.Append((T)Vs);
                    }
                    else if (Inter.End - Inter.Start == 1)
                    {
                        dynamic Vs = (object)Inter.Start;
                        dynamic Ve = (object)Inter.End;
                        Str.Append((T)Vs).Append((T)Ve);
                    }
                    else
                    {
                        dynamic Vs = (object)Inter.Start;
                        dynamic Ve = (object)Inter.End;
                        Str.AppendFormat("{0}-{1}", (T)Vs, (T)Ve);
                    }
                }
                Str.Append("]");
                if (Str[1] == '^')
                {
                    Str = Str.Replace("^", "\\^", 0, 1);
                }
                // 求取補集以試圖縮小代碼長度
                if (Str.Length >= 10 && CompleteSet != null)
                {
                    StringBuilder Complement = new StringBuilder("[^");
                    foreach (char c in CompleteSet)
                    {
                        if (this.Inside(c) == false)
                        {
                            Complement.Append(c);
                        }
                    }
                    Complement.Append("]");
                    if (Complement.Length <= Str.Length)
                    {
                        return Complement.ToString();
                    }
                }
                return Str.ToString();
            }
        }