Program sprawdzający czy dany ciąg jest zgodny z opisem automatu det realizacja na liście

Mam listę, w której mam opis automatu. Zczytywałam kolejny stan i do niego przechodziłam, opierałam się jednak na tym że numery stanów, były numerami listy. Przykładowo stan zerowy opis dla niego jest w automat[0], dla pierwszego automat[1] etc... Czytałam jaki ma być kolejny stan, po sukcesie czyli dobrym znaku i tam przechodziłam. Jednak są sytuacje kiedy moje rozwiązanie się nie sprawdza, jest to na przykład gdy jeden stan wskazuje na siebie i na inny, lub gdy opis automatu składa się z dwóch automatów - wtedy leżę. Mogłabym podzielić opis automatu na n mniejszych i puścić na zasadzie "dla sukcesu wystarczy jak dla jedeng opisu automatu jest okey". Problem nadal by był z tą pierwszą sytuacja. Czy mogę jakoś na tej liście to zrobić? Czy muszę wybrać inną strukturę danych?

Nie bardzo rozumiem twój problem.

1. Jaki automat? Zgaduje ze szklaną kulą: Skończony? Deterministyczny? Zupełny?
2. Pokaż przykład który ci nie pasuje.

Deterministyczny, skończenie stanowy.

 0 1 a
1 1 b
1 2 c
0 3 k
3 4 o
4 5 t
2
5

dla

0 1 a
1 2 b
2 3 c
3

jest okey

Mogłabym wyszukać "0" i pociachać opis na mniejsze, miałabym wtedy znowu indeksy 0,1,2,3,...n musiałabym jednak od innych niż zero odjąć pewną liczbę i zapisać do automatu. To znaczy zamiast tego pierwszego, miałabym:

 0 1 a
1 1 b
1 2 c
2

i

 
0 1 k
1 2 o
2 3 t
3

Łatwiej by to było na innej strukturze danych, gdzie odnosiłabym sie za pomocą znaku do zawartości struktury np słownik, słowników etc. Zastanawiam sięjednak jak zrobić to na liście. Nawet jak podzielę automat na n mniejszych i zaakceptuje ciąg jeśli przynajmniej był jeden sukces, a raczej do pierwszego sukcesu bo nie ma sensu dalej obliczać w takim wypadku, tylko obciąża się komputer. Nawet jeśli mam n małych opisów, to:

 0 1 a
1 1 b
1 2 c
2

czyli automat[0] = 0 1 a automat[1] = 1 1 b automat[2] = 1 2 c automat[3] = 2 jeśli napotka c ma iść do stanu 2, tylko że w tym wypadku stan 2 to nie automat[2] tylko automat[3]

Robienie tego na liście jest bez sensu, a na jednopoziomowej strukturze to już w ogóle. Ale jeśli bardzo chcesz listami to:

1. Transponuj terminale na liczby np. poprzez terminale -'a' (czyli dla a mamy 0, dla c mamy 3 etc)
2. Zrób listę która przechowuje listy. Indeksem w tej głównej liście jest nasz transponowany terminal i zwraca nam listę stanów z których mamy przejście wypisujące taki terminal
3. W wewnętrznych listach indeksem jest stan "przed przejściem" a wartością jest kolejny pierwotny.

Czyli dla

0 1 a
1 1 b
0 0 b

Masz listę: [["0->1"],["1->1", "0->0"]] i teraz przy dekodowaniu ciągu abba robisz:
transponowane a -> 0
lista[0] == ["0->1"]
jesteśmy w stanie 0 więc przechodzimy do stanu 1, zostaje nam bba
transponowane b -> 1
lista[1] == ["1->1", "0->0"]
jesteśmy w stanie 1 więc przechodzimy do 1, zostaje nam ba
transponowane b -> 1
lista[1] == ["1->1", "0->0"]
jesteśmy w stanie 1 więc przechodzimy do 1, zostaje nam a
transponowane a -> 0
lista[0] == ["0->1"]
Nie ma przejśćia ze stanu 1 które wpisuje a więc odrzucamy ciąg.