Un autómata finito no determinista es una máquina de estados finitos donde una tupla se asigna a múltiples estados. Es decir. reemplazamos la función de transición habitual de un DFA con otra función .δ : Q × Σ → Q
Si sabe qué es un NFA, puede saltear la siguiente sección.
Definicion formal
Un NFA se describe únicamente por
- un conjunto finito de estados
- un conjunto finito de símbolos
- la función de transición
- el estado inicial
- un conjunto de estados finales
La máquina comienza en y lee una cadena finita de símbolos , para cada símbolo aplicará simultáneamente la función de función de transición con un estado actual y agregará cada nuevo conjunto de estados al conjunto de estados actuales. w ∈ Σ ∗
Desafío
Para este desafío, ignoraremos para simplificarlo, además, el alfabeto siempre será las letras (minúsculas) to \ texttt {z} \ y el conjunto de estados será \ {0 \ puntos N \} para algunos no negativo número entero N . El estado inicial siempre será 0 .a z { 0 ... N } N 0
Dada una palabra y una descripción de la NFA, su tarea es determinar todos los estados finales.
Ejemplo
Considere la cadena y la siguiente descripción:
state, symbol, new-states
0, 'a', [1]
1, 'a', [0]
1, 'b', [1,2]
La máquina comenzará en :
- leer un : nuevos estados { 1 }
- lea a : nuevos estados
- leer un : nuevos estados
- leer un : nuevos estados
- lea a : nuevos estados
Entonces, los estados finales y, por lo tanto, la salida serían .
Nota: En el paso (2), la transición del estado asigna a ya que la descripción solo incluye transiciones a conjuntos no vacíos.
Reglas
La entrada consistirá en una cadena y algún tipo de descripción de la NFA (sin transiciones ):
- la cadena de entrada siempre será elemento de
- entradas válidas (no limitadas a):
- lista / conjunto de tuplas / listas
- entrada separada de nueva línea
- la descripción de la NFA solo contendrá transiciones con conjuntos no vacíos como resultado
- puede abreviar reglas con los mismos caracteres si su resultado es el mismo (por ejemplo, reglas
0,'a',[1,2]y0,'b',[1,2]podría abreviarse con0,"ab",[1,2] - puede tomar cada regla por separado (por ejemplo, la regla
0,'a',[1,2]puede ser0,'a',[1]y0,'a',[2])
- puede abreviar reglas con los mismos caracteres si su resultado es el mismo (por ejemplo, reglas
- puedes elegir letras mayúsculas si quieres
- puede tomar el número de estados como entrada
- puede asumir algún tipo de orden de las entradas (por ejemplo, ordenado por estado o símbolos)
La salida será una salida separada por lista / conjunto / nueva línea, etc. de los estados finales
- el orden no importa
- sin duplicados (ya que es un conjunto)
Casos de prueba
Estos ejemplos estarán en el formato description word -> statesdonde descriptionhay una lista de tuplas (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]