Turing Machine (OOP-like)

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace TuringGep
{
    enum Direction { Backward = -1, Stay, Forward }
    enum State { Q0, Q1, Final }
    enum SpecialChar { Triangle, Blank }

    interface IReadableCharacter { }

    interface IReadableCharacter<T> : IReadableCharacter where T : struct
    {
        T Value { get; set; }
    }

    class NumericCharacter : IReadableCharacter<int>
    {
        public int Value { get; set; }

        public NumericCharacter(int number)
        {
            Value = number;
        }
    }

    class TriangleCharacter : IReadableCharacter<SpecialChar>
    {
        public SpecialChar Value { get; set; }

        public TriangleCharacter()
        {
            Value = SpecialChar.Triangle;
        }
    }

    class BlankCharacter : IReadableCharacter<SpecialChar>
    {
        public SpecialChar Value { get; set; }

        public BlankCharacter()
        {
            Value = SpecialChar.Blank;
        }
    }

    interface ITuringMachine
    {
        void DeltaFunction();
        void MoveHead(Direction direction);
        void StartTuring();
        bool IsInterpretible(IReadableCharacter character);
        IReadableCharacter Read();
        void Write(IReadableCharacter character);
    }

    class NumericSearchTuring : ITuringMachine
    {
        private State _innerState;
        private int _position = 0;
        private int _searchTerm = -1;
        private readonly List<IReadableCharacter> _tape;
        private readonly List<int> _foundResultIndexList;

        private List<IReadableCharacter> _interpretibleCharacters = new List<IReadableCharacter>();

        public static NumericSearchTuring StartNew(List<int> numbersList, int searchTerm)
        {
            var turing = new NumericSearchTuring(numbersList, searchTerm);
            turing.StartTuring();
            return turing;
        }

        private NumericSearchTuring(IEnumerable<int> listOfNumbers, int seachTerm)
        {
            _tape = new List<IReadableCharacter>();
            _foundResultIndexList = new List<int>();
            _searchTerm = seachTerm;

            _innerState = State.Q0;
            _tape.Add(new TriangleCharacter());
            IEnumerable<int> listEnums = listOfNumbers as int[] ?? listOfNumbers.ToArray();
            _tape.AddRange(listEnums.Select(x => new NumericCharacter(x)));
            _tape.Add(new BlankCharacter());

            for (int i = 0; i < 10; i++)
            {
                _interpretibleCharacters.Add(new NumericCharacter(i));
            }
            _interpretibleCharacters.Add(new TriangleCharacter());
            _interpretibleCharacters.Add(new BlankCharacter());
        }

        public void StartTuring()
        {
            while (_innerState != State.Final)
            {
                DeltaFunction();
            }
        }

        public void DeltaFunction()
        {
            IReadableCharacter value;
            switch (_innerState)
            {
                case State.Q0:
                    if (!IsInterpretible(value = Read())) return;
                    value = value as TriangleCharacter;
                    SetInnerState(value != null ? State.Q1 : State.Final);
                    return;
                case State.Q1:
                    if (!IsInterpretible(value = Read())) return;
                    var character = value as NumericCharacter;
                    if (character != null)
                    {
                        if (_searchTerm == character.Value)
                        {
                            _foundResultIndexList.Add(_position - 1);
                        }
                        SetInnerState(State.Q1);
                    }
                    else
                    {
                        Write(new BlankCharacter());
                        SetInnerState(State.Final);
                    }
                    return;
                case State.Final:
                    Write(new BlankCharacter());
                    break;
            }
        }

        public void SetInnerState(State state)
        {
            _innerState = state;
            MoveHead(Direction.Forward);
        }

        public bool IsInterpretible(IReadableCharacter character)
        {
            if (character is TriangleCharacter || character is BlankCharacter) return true;
            var temp = character as NumericCharacter;
            return temp != null &&
                   _interpretibleCharacters.Where(chars => (chars as NumericCharacter) != null)
                       .Cast<NumericCharacter>()
                       .Any(num => temp.Value == num.Value);
        }

        public IReadableCharacter Read()
        {
            return _tape[_position];
        }

        public void Write(IReadableCharacter character)
        {
            _tape[_position] = character;
        }

        public void MoveHead(Direction direction)
        {
            if (_position + (int)direction < _tape.Count)
                _position += (int)direction;
        }

        public List<int> GetResults()
        {
            // Csak akkor van végeredmény, ha kész vagyunk, tehát az állapot final
            return _innerState != State.Final ? null : _foundResultIndexList;
        }
    }

    class Program
    {
        static void Main()
        {
            int seachTerm = 5;
            Random rand = new Random();
            List<int> randomValues = new List<int>();
            for (int i = 0; i < 30; i++)
            {
                randomValues.Add(rand.Next(10));
                Console.Write(i + ": " + randomValues[i] + " \n");
                Debug.Write(i + ": " + randomValues[i] + " \n");
            }
            Console.WriteLine("Keressett szám: " + seachTerm);
            Debug.WriteLine("Keressett szám: " + seachTerm);
            NumericSearchTuring searchTuring = NumericSearchTuring.StartNew(randomValues, seachTerm);
            Console.Write("Indexek: ");
            Debug.Write("Indexek: ");
            foreach (var result in searchTuring.GetResults())
            {
                Console.Write(result + " ");
                Debug.Write(result + " ");
            }
            Console.WriteLine();
            Console.ReadKey();
        }
    }
}