Un automate fini non déterministe est une machine à états finis dans laquelle un tuple est mappé à plusieurs états. C'est à dire. nous remplaçons la fonction de transition δ : Q × Σ → Q habituelle d'un DFA par une autre fonction Δ : Q × Σ → P ( Q ) .
Si vous savez ce qu'est un NFA, vous pouvez ignorer la section suivante.
Définition formelle
Un NFA est uniquement décrit par
- Un ensemble fini d'états
- un ensemble fini de symboles
- la fonction de transition
- l'état initial
- un ensemble d'états finaux
La machine démarre en et lit une chaîne finie de symboles w ∈ Σ ∗ , pour chaque symbole, elle appliquera simultanément la fonction de fonction de transition avec un état actuel et ajoutera chaque nouvel ensemble d'états à l'ensemble d'états actuels.
Défi
Pour ce défi , nous ignorerons de la simplifier, en outre l'alphabet sera toujours les lettres (minuscules) a à z et l'ensemble des états sera { 0 ... N } pour un entier non négatif N . L'état initial sera toujours 0 .
Étant donné un mot et une description du NFA, votre tâche consiste à déterminer tous les états finaux.
Exemple
Considérez la chaîne et la description suivante:
state, symbol, new-states
0, 'a', [1]
1, 'a', [0]
1, 'b', [1,2]
La machine démarre en :
- lire un : nouveaux états { 1 }
- lire a : nouveaux états { 1 , 2 }
- lire un : nouveaux états { 0 }
- lire un : nouveaux états { 1 }
- lire a : nouveaux états { 1 , 2 }
Ainsi, les états finaux et donc la sortie seraient .
Remarque: à l' étape (2), la transition de l'état correspond à ∅ car la description inclut uniquement les transitions vers des ensembles non vides.
Règles
L'entrée consistera en une chaîne et une sorte de description du NFA (sans transitions ):
- la chaîne d'entrée sera toujours un élément de
- entrées valides (non limitées à):
- liste / tableau de tuples / listes
- entrée séparée par nouvelle ligne
- la description de la NFA ne contiendra que des transitions avec des ensembles non vides
- vous pouvez abréger des règles avec les mêmes caractères si leur résultat est le même (par exemple des règles
0,'a',[1,2]et0,'b',[1,2]pourrait être abrégé avec0,"ab",[1,2] - vous pouvez séparer chaque règle (par exemple, la règle
0,'a',[1,2]peut être0,'a',[1]et0,'a',[2])
- vous pouvez abréger des règles avec les mêmes caractères si leur résultat est le même (par exemple des règles
- vous pouvez choisir des majuscules si vous le souhaitez
- vous pouvez prendre le nombre d'états en entrée
- vous pouvez supposer une sorte de classement des entrées (par exemple, triées par état ou symboles)
La sortie sera une sortie séparée par liste / ensemble / nouvelle ligne, etc. des états finaux
- l'ordre n'a pas d'importance
- pas de doublons (car c'est un ensemble)
Cas de test
Ces exemples seront au format description word -> statesoù se descriptiontrouve une liste de tuples (state,symbol,new-states):
[] "x" -> []
[] "" -> [0]
[(0,'a',[1]),(1,'a',[0]),(1,'b',[1,2])] "abaab" -> [1,2]
[(0,'a',[1]),(1,'a',[0]),(1,'b',[1,2])] "abc" -> []
[(0,'p',[0,1]),(0,'g',[2]),(1,'c',[1]),(1,'g',[4]),(1,'p',[2]),(2,'c',[0])] "ppcg" -> [2,4]
[(0,'f',[1]),(1,'o',[1,2]),(2,'b',[3]),(3,'a',[4]),(4,'r',[0,4])] "foobar" -> [0,4]
[(0,'f',[1]),(1,'o',[1,2]),(2,'b',[3]),(3,'a',[4]),(4,'r',[0,4])] "fooooooobar" -> [0,4]
[(0,'f',[1]),(1,'o',[1,2]),(2,'b',[3]),(3,'a',[4]),(4,'r',[0,4])] "fobarfo" -> [1,2]
[(0,'f',[1]),(1,'o',[1,2]),(2,'b',[3]),(3,'a',[4]),(4,'r',[0,4])] "foobarrf" -> [1]
[(0,'d',[1,2]),(1,'u',[2]),(2,'u',[2,3]),(2,'p',[3]),(3,'p',[3])] "dup" -> [3]
[(0,'a',[0,2]),(0,'b',[3]),(1,'a',[1]),(1,'b',[1]),(2,'b',[1,4]),(4,'b',[2])] "aab" -> [3,1,4]
[(0,'a',[0,2]),(0,'b',[3]),(1,'a',[1]),(1,'b',[1]),(2,'b',[1,4]),(4,'b',[2])] "abb" -> [1,2]